]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - fs/block_dev.c
b3c1d3dae77d06fcde3fa3ecf36b2af9e2b25d85
[~shefty/rdma-dev.git] / fs / block_dev.c
1 /*
2  *  linux/fs/block_dev.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *  Copyright (C) 2001  Andrea Arcangeli <andrea@suse.de> SuSE
6  */
7
8 #include <linux/init.h>
9 #include <linux/mm.h>
10 #include <linux/fcntl.h>
11 #include <linux/slab.h>
12 #include <linux/kmod.h>
13 #include <linux/major.h>
14 #include <linux/device_cgroup.h>
15 #include <linux/highmem.h>
16 #include <linux/blkdev.h>
17 #include <linux/module.h>
18 #include <linux/blkpg.h>
19 #include <linux/magic.h>
20 #include <linux/buffer_head.h>
21 #include <linux/swap.h>
22 #include <linux/pagevec.h>
23 #include <linux/writeback.h>
24 #include <linux/mpage.h>
25 #include <linux/mount.h>
26 #include <linux/uio.h>
27 #include <linux/namei.h>
28 #include <linux/log2.h>
29 #include <linux/cleancache.h>
30 #include <asm/uaccess.h>
31 #include "internal.h"
32
33 struct bdev_inode {
34         struct block_device bdev;
35         struct inode vfs_inode;
36 };
37
38 static const struct address_space_operations def_blk_aops;
39
40 static inline struct bdev_inode *BDEV_I(struct inode *inode)
41 {
42         return container_of(inode, struct bdev_inode, vfs_inode);
43 }
44
45 inline struct block_device *I_BDEV(struct inode *inode)
46 {
47         return &BDEV_I(inode)->bdev;
48 }
49 EXPORT_SYMBOL(I_BDEV);
50
51 /*
52  * Move the inode from its current bdi to a new bdi. If the inode is dirty we
53  * need to move it onto the dirty list of @dst so that the inode is always on
54  * the right list.
55  */
56 static void bdev_inode_switch_bdi(struct inode *inode,
57                         struct backing_dev_info *dst)
58 {
59         struct backing_dev_info *old = inode->i_data.backing_dev_info;
60
61         if (unlikely(dst == old))               /* deadlock avoidance */
62                 return;
63         bdi_lock_two(&old->wb, &dst->wb);
64         spin_lock(&inode->i_lock);
65         inode->i_data.backing_dev_info = dst;
66         if (inode->i_state & I_DIRTY)
67                 list_move(&inode->i_wb_list, &dst->wb.b_dirty);
68         spin_unlock(&inode->i_lock);
69         spin_unlock(&old->wb.list_lock);
70         spin_unlock(&dst->wb.list_lock);
71 }
72
73 sector_t blkdev_max_block(struct block_device *bdev)
74 {
75         sector_t retval = ~((sector_t)0);
76         loff_t sz = i_size_read(bdev->bd_inode);
77
78         if (sz) {
79                 unsigned int size = block_size(bdev);
80                 unsigned int sizebits = blksize_bits(size);
81                 retval = (sz >> sizebits);
82         }
83         return retval;
84 }
85
86 /* Kill _all_ buffers and pagecache , dirty or not.. */
87 void kill_bdev(struct block_device *bdev)
88 {
89         struct address_space *mapping = bdev->bd_inode->i_mapping;
90
91         if (mapping->nrpages == 0)
92                 return;
93
94         invalidate_bh_lrus();
95         truncate_inode_pages(mapping, 0);
96 }       
97 EXPORT_SYMBOL(kill_bdev);
98
99 /* Invalidate clean unused buffers and pagecache. */
100 void invalidate_bdev(struct block_device *bdev)
101 {
102         struct address_space *mapping = bdev->bd_inode->i_mapping;
103
104         if (mapping->nrpages == 0)
105                 return;
106
107         invalidate_bh_lrus();
108         lru_add_drain_all();    /* make sure all lru add caches are flushed */
109         invalidate_mapping_pages(mapping, 0, -1);
110         /* 99% of the time, we don't need to flush the cleancache on the bdev.
111          * But, for the strange corners, lets be cautious
112          */
113         cleancache_invalidate_inode(mapping);
114 }
115 EXPORT_SYMBOL(invalidate_bdev);
116
117 int set_blocksize(struct block_device *bdev, int size)
118 {
119         struct address_space *mapping;
120
121         /* Size must be a power of two, and between 512 and PAGE_SIZE */
122         if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
123                 return -EINVAL;
124
125         /* Size cannot be smaller than the size supported by the device */
126         if (size < bdev_logical_block_size(bdev))
127                 return -EINVAL;
128
129         /* Prevent starting I/O or mapping the device */
130         percpu_down_write(&bdev->bd_block_size_semaphore);
131
132         /* Check that the block device is not memory mapped */
133         mapping = bdev->bd_inode->i_mapping;
134         mutex_lock(&mapping->i_mmap_mutex);
135         if (mapping_mapped(mapping)) {
136                 mutex_unlock(&mapping->i_mmap_mutex);
137                 percpu_up_write(&bdev->bd_block_size_semaphore);
138                 return -EBUSY;
139         }
140         mutex_unlock(&mapping->i_mmap_mutex);
141
142         /* Don't change the size if it is same as current */
143         if (bdev->bd_block_size != size) {
144                 sync_blockdev(bdev);
145                 bdev->bd_block_size = size;
146                 bdev->bd_inode->i_blkbits = blksize_bits(size);
147                 kill_bdev(bdev);
148         }
149
150         percpu_up_write(&bdev->bd_block_size_semaphore);
151
152         return 0;
153 }
154
155 EXPORT_SYMBOL(set_blocksize);
156
157 int sb_set_blocksize(struct super_block *sb, int size)
158 {
159         if (set_blocksize(sb->s_bdev, size))
160                 return 0;
161         /* If we get here, we know size is power of two
162          * and it's value is between 512 and PAGE_SIZE */
163         sb->s_blocksize = size;
164         sb->s_blocksize_bits = blksize_bits(size);
165         return sb->s_blocksize;
166 }
167
168 EXPORT_SYMBOL(sb_set_blocksize);
169
170 int sb_min_blocksize(struct super_block *sb, int size)
171 {
172         int minsize = bdev_logical_block_size(sb->s_bdev);
173         if (size < minsize)
174                 size = minsize;
175         return sb_set_blocksize(sb, size);
176 }
177
178 EXPORT_SYMBOL(sb_min_blocksize);
179
180 static int
181 blkdev_get_block(struct inode *inode, sector_t iblock,
182                 struct buffer_head *bh, int create)
183 {
184         if (iblock >= blkdev_max_block(I_BDEV(inode))) {
185                 if (create)
186                         return -EIO;
187
188                 /*
189                  * for reads, we're just trying to fill a partial page.
190                  * return a hole, they will have to call get_block again
191                  * before they can fill it, and they will get -EIO at that
192                  * time
193                  */
194                 return 0;
195         }
196         bh->b_bdev = I_BDEV(inode);
197         bh->b_blocknr = iblock;
198         set_buffer_mapped(bh);
199         return 0;
200 }
201
202 static int
203 blkdev_get_blocks(struct inode *inode, sector_t iblock,
204                 struct buffer_head *bh, int create)
205 {
206         sector_t end_block = blkdev_max_block(I_BDEV(inode));
207         unsigned long max_blocks = bh->b_size >> inode->i_blkbits;
208
209         if ((iblock + max_blocks) > end_block) {
210                 max_blocks = end_block - iblock;
211                 if ((long)max_blocks <= 0) {
212                         if (create)
213                                 return -EIO;    /* write fully beyond EOF */
214                         /*
215                          * It is a read which is fully beyond EOF.  We return
216                          * a !buffer_mapped buffer
217                          */
218                         max_blocks = 0;
219                 }
220         }
221
222         bh->b_bdev = I_BDEV(inode);
223         bh->b_blocknr = iblock;
224         bh->b_size = max_blocks << inode->i_blkbits;
225         if (max_blocks)
226                 set_buffer_mapped(bh);
227         return 0;
228 }
229
230 static ssize_t
231 blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
232                         loff_t offset, unsigned long nr_segs)
233 {
234         struct file *file = iocb->ki_filp;
235         struct inode *inode = file->f_mapping->host;
236
237         return __blockdev_direct_IO(rw, iocb, inode, I_BDEV(inode), iov, offset,
238                                     nr_segs, blkdev_get_blocks, NULL, NULL, 0);
239 }
240
241 int __sync_blockdev(struct block_device *bdev, int wait)
242 {
243         if (!bdev)
244                 return 0;
245         if (!wait)
246                 return filemap_flush(bdev->bd_inode->i_mapping);
247         return filemap_write_and_wait(bdev->bd_inode->i_mapping);
248 }
249
250 /*
251  * Write out and wait upon all the dirty data associated with a block
252  * device via its mapping.  Does not take the superblock lock.
253  */
254 int sync_blockdev(struct block_device *bdev)
255 {
256         return __sync_blockdev(bdev, 1);
257 }
258 EXPORT_SYMBOL(sync_blockdev);
259
260 /*
261  * Write out and wait upon all dirty data associated with this
262  * device.   Filesystem data as well as the underlying block
263  * device.  Takes the superblock lock.
264  */
265 int fsync_bdev(struct block_device *bdev)
266 {
267         struct super_block *sb = get_super(bdev);
268         if (sb) {
269                 int res = sync_filesystem(sb);
270                 drop_super(sb);
271                 return res;
272         }
273         return sync_blockdev(bdev);
274 }
275 EXPORT_SYMBOL(fsync_bdev);
276
277 /**
278  * freeze_bdev  --  lock a filesystem and force it into a consistent state
279  * @bdev:       blockdevice to lock
280  *
281  * If a superblock is found on this device, we take the s_umount semaphore
282  * on it to make sure nobody unmounts until the snapshot creation is done.
283  * The reference counter (bd_fsfreeze_count) guarantees that only the last
284  * unfreeze process can unfreeze the frozen filesystem actually when multiple
285  * freeze requests arrive simultaneously. It counts up in freeze_bdev() and
286  * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
287  * actually.
288  */
289 struct super_block *freeze_bdev(struct block_device *bdev)
290 {
291         struct super_block *sb;
292         int error = 0;
293
294         mutex_lock(&bdev->bd_fsfreeze_mutex);
295         if (++bdev->bd_fsfreeze_count > 1) {
296                 /*
297                  * We don't even need to grab a reference - the first call
298                  * to freeze_bdev grab an active reference and only the last
299                  * thaw_bdev drops it.
300                  */
301                 sb = get_super(bdev);
302                 drop_super(sb);
303                 mutex_unlock(&bdev->bd_fsfreeze_mutex);
304                 return sb;
305         }
306
307         sb = get_active_super(bdev);
308         if (!sb)
309                 goto out;
310         error = freeze_super(sb);
311         if (error) {
312                 deactivate_super(sb);
313                 bdev->bd_fsfreeze_count--;
314                 mutex_unlock(&bdev->bd_fsfreeze_mutex);
315                 return ERR_PTR(error);
316         }
317         deactivate_super(sb);
318  out:
319         sync_blockdev(bdev);
320         mutex_unlock(&bdev->bd_fsfreeze_mutex);
321         return sb;      /* thaw_bdev releases s->s_umount */
322 }
323 EXPORT_SYMBOL(freeze_bdev);
324
325 /**
326  * thaw_bdev  -- unlock filesystem
327  * @bdev:       blockdevice to unlock
328  * @sb:         associated superblock
329  *
330  * Unlocks the filesystem and marks it writeable again after freeze_bdev().
331  */
332 int thaw_bdev(struct block_device *bdev, struct super_block *sb)
333 {
334         int error = -EINVAL;
335
336         mutex_lock(&bdev->bd_fsfreeze_mutex);
337         if (!bdev->bd_fsfreeze_count)
338                 goto out;
339
340         error = 0;
341         if (--bdev->bd_fsfreeze_count > 0)
342                 goto out;
343
344         if (!sb)
345                 goto out;
346
347         error = thaw_super(sb);
348         if (error) {
349                 bdev->bd_fsfreeze_count++;
350                 mutex_unlock(&bdev->bd_fsfreeze_mutex);
351                 return error;
352         }
353 out:
354         mutex_unlock(&bdev->bd_fsfreeze_mutex);
355         return 0;
356 }
357 EXPORT_SYMBOL(thaw_bdev);
358
359 static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
360 {
361         return block_write_full_page(page, blkdev_get_block, wbc);
362 }
363
364 static int blkdev_readpage(struct file * file, struct page * page)
365 {
366         return block_read_full_page(page, blkdev_get_block);
367 }
368
369 static int blkdev_write_begin(struct file *file, struct address_space *mapping,
370                         loff_t pos, unsigned len, unsigned flags,
371                         struct page **pagep, void **fsdata)
372 {
373         return block_write_begin(mapping, pos, len, flags, pagep,
374                                  blkdev_get_block);
375 }
376
377 static int blkdev_write_end(struct file *file, struct address_space *mapping,
378                         loff_t pos, unsigned len, unsigned copied,
379                         struct page *page, void *fsdata)
380 {
381         int ret;
382         ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
383
384         unlock_page(page);
385         page_cache_release(page);
386
387         return ret;
388 }
389
390 /*
391  * private llseek:
392  * for a block special file file->f_path.dentry->d_inode->i_size is zero
393  * so we compute the size by hand (just as in block_read/write above)
394  */
395 static loff_t block_llseek(struct file *file, loff_t offset, int origin)
396 {
397         struct inode *bd_inode = file->f_mapping->host;
398         loff_t size;
399         loff_t retval;
400
401         mutex_lock(&bd_inode->i_mutex);
402         size = i_size_read(bd_inode);
403
404         retval = -EINVAL;
405         switch (origin) {
406                 case SEEK_END:
407                         offset += size;
408                         break;
409                 case SEEK_CUR:
410                         offset += file->f_pos;
411                 case SEEK_SET:
412                         break;
413                 default:
414                         goto out;
415         }
416         if (offset >= 0 && offset <= size) {
417                 if (offset != file->f_pos) {
418                         file->f_pos = offset;
419                 }
420                 retval = offset;
421         }
422 out:
423         mutex_unlock(&bd_inode->i_mutex);
424         return retval;
425 }
426         
427 int blkdev_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
428 {
429         struct inode *bd_inode = filp->f_mapping->host;
430         struct block_device *bdev = I_BDEV(bd_inode);
431         int error;
432         
433         error = filemap_write_and_wait_range(filp->f_mapping, start, end);
434         if (error)
435                 return error;
436
437         /*
438          * There is no need to serialise calls to blkdev_issue_flush with
439          * i_mutex and doing so causes performance issues with concurrent
440          * O_SYNC writers to a block device.
441          */
442         error = blkdev_issue_flush(bdev, GFP_KERNEL, NULL);
443         if (error == -EOPNOTSUPP)
444                 error = 0;
445
446         return error;
447 }
448 EXPORT_SYMBOL(blkdev_fsync);
449
450 /*
451  * pseudo-fs
452  */
453
454 static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
455 static struct kmem_cache * bdev_cachep __read_mostly;
456
457 static struct inode *bdev_alloc_inode(struct super_block *sb)
458 {
459         struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
460         if (!ei)
461                 return NULL;
462
463         if (unlikely(percpu_init_rwsem(&ei->bdev.bd_block_size_semaphore))) {
464                 kmem_cache_free(bdev_cachep, ei);
465                 return NULL;
466         }
467
468         return &ei->vfs_inode;
469 }
470
471 static void bdev_i_callback(struct rcu_head *head)
472 {
473         struct inode *inode = container_of(head, struct inode, i_rcu);
474         struct bdev_inode *bdi = BDEV_I(inode);
475
476         percpu_free_rwsem(&bdi->bdev.bd_block_size_semaphore);
477
478         kmem_cache_free(bdev_cachep, bdi);
479 }
480
481 static void bdev_destroy_inode(struct inode *inode)
482 {
483         call_rcu(&inode->i_rcu, bdev_i_callback);
484 }
485
486 static void init_once(void *foo)
487 {
488         struct bdev_inode *ei = (struct bdev_inode *) foo;
489         struct block_device *bdev = &ei->bdev;
490
491         memset(bdev, 0, sizeof(*bdev));
492         mutex_init(&bdev->bd_mutex);
493         INIT_LIST_HEAD(&bdev->bd_inodes);
494         INIT_LIST_HEAD(&bdev->bd_list);
495 #ifdef CONFIG_SYSFS
496         INIT_LIST_HEAD(&bdev->bd_holder_disks);
497 #endif
498         inode_init_once(&ei->vfs_inode);
499         /* Initialize mutex for freeze. */
500         mutex_init(&bdev->bd_fsfreeze_mutex);
501 }
502
503 static inline void __bd_forget(struct inode *inode)
504 {
505         list_del_init(&inode->i_devices);
506         inode->i_bdev = NULL;
507         inode->i_mapping = &inode->i_data;
508 }
509
510 static void bdev_evict_inode(struct inode *inode)
511 {
512         struct block_device *bdev = &BDEV_I(inode)->bdev;
513         struct list_head *p;
514         truncate_inode_pages(&inode->i_data, 0);
515         invalidate_inode_buffers(inode); /* is it needed here? */
516         clear_inode(inode);
517         spin_lock(&bdev_lock);
518         while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
519                 __bd_forget(list_entry(p, struct inode, i_devices));
520         }
521         list_del_init(&bdev->bd_list);
522         spin_unlock(&bdev_lock);
523 }
524
525 static const struct super_operations bdev_sops = {
526         .statfs = simple_statfs,
527         .alloc_inode = bdev_alloc_inode,
528         .destroy_inode = bdev_destroy_inode,
529         .drop_inode = generic_delete_inode,
530         .evict_inode = bdev_evict_inode,
531 };
532
533 static struct dentry *bd_mount(struct file_system_type *fs_type,
534         int flags, const char *dev_name, void *data)
535 {
536         return mount_pseudo(fs_type, "bdev:", &bdev_sops, NULL, BDEVFS_MAGIC);
537 }
538
539 static struct file_system_type bd_type = {
540         .name           = "bdev",
541         .mount          = bd_mount,
542         .kill_sb        = kill_anon_super,
543 };
544
545 static struct super_block *blockdev_superblock __read_mostly;
546
547 void __init bdev_cache_init(void)
548 {
549         int err;
550         static struct vfsmount *bd_mnt;
551
552         bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
553                         0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
554                                 SLAB_MEM_SPREAD|SLAB_PANIC),
555                         init_once);
556         err = register_filesystem(&bd_type);
557         if (err)
558                 panic("Cannot register bdev pseudo-fs");
559         bd_mnt = kern_mount(&bd_type);
560         if (IS_ERR(bd_mnt))
561                 panic("Cannot create bdev pseudo-fs");
562         blockdev_superblock = bd_mnt->mnt_sb;   /* For writeback */
563 }
564
565 /*
566  * Most likely _very_ bad one - but then it's hardly critical for small
567  * /dev and can be fixed when somebody will need really large one.
568  * Keep in mind that it will be fed through icache hash function too.
569  */
570 static inline unsigned long hash(dev_t dev)
571 {
572         return MAJOR(dev)+MINOR(dev);
573 }
574
575 static int bdev_test(struct inode *inode, void *data)
576 {
577         return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
578 }
579
580 static int bdev_set(struct inode *inode, void *data)
581 {
582         BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
583         return 0;
584 }
585
586 static LIST_HEAD(all_bdevs);
587
588 struct block_device *bdget(dev_t dev)
589 {
590         struct block_device *bdev;
591         struct inode *inode;
592
593         inode = iget5_locked(blockdev_superblock, hash(dev),
594                         bdev_test, bdev_set, &dev);
595
596         if (!inode)
597                 return NULL;
598
599         bdev = &BDEV_I(inode)->bdev;
600
601         if (inode->i_state & I_NEW) {
602                 bdev->bd_contains = NULL;
603                 bdev->bd_super = NULL;
604                 bdev->bd_inode = inode;
605                 bdev->bd_block_size = (1 << inode->i_blkbits);
606                 bdev->bd_part_count = 0;
607                 bdev->bd_invalidated = 0;
608                 inode->i_mode = S_IFBLK;
609                 inode->i_rdev = dev;
610                 inode->i_bdev = bdev;
611                 inode->i_data.a_ops = &def_blk_aops;
612                 mapping_set_gfp_mask(&inode->i_data, GFP_USER);
613                 inode->i_data.backing_dev_info = &default_backing_dev_info;
614                 spin_lock(&bdev_lock);
615                 list_add(&bdev->bd_list, &all_bdevs);
616                 spin_unlock(&bdev_lock);
617                 unlock_new_inode(inode);
618         }
619         return bdev;
620 }
621
622 EXPORT_SYMBOL(bdget);
623
624 /**
625  * bdgrab -- Grab a reference to an already referenced block device
626  * @bdev:       Block device to grab a reference to.
627  */
628 struct block_device *bdgrab(struct block_device *bdev)
629 {
630         ihold(bdev->bd_inode);
631         return bdev;
632 }
633
634 long nr_blockdev_pages(void)
635 {
636         struct block_device *bdev;
637         long ret = 0;
638         spin_lock(&bdev_lock);
639         list_for_each_entry(bdev, &all_bdevs, bd_list) {
640                 ret += bdev->bd_inode->i_mapping->nrpages;
641         }
642         spin_unlock(&bdev_lock);
643         return ret;
644 }
645
646 void bdput(struct block_device *bdev)
647 {
648         iput(bdev->bd_inode);
649 }
650
651 EXPORT_SYMBOL(bdput);
652  
653 static struct block_device *bd_acquire(struct inode *inode)
654 {
655         struct block_device *bdev;
656
657         spin_lock(&bdev_lock);
658         bdev = inode->i_bdev;
659         if (bdev) {
660                 ihold(bdev->bd_inode);
661                 spin_unlock(&bdev_lock);
662                 return bdev;
663         }
664         spin_unlock(&bdev_lock);
665
666         bdev = bdget(inode->i_rdev);
667         if (bdev) {
668                 spin_lock(&bdev_lock);
669                 if (!inode->i_bdev) {
670                         /*
671                          * We take an additional reference to bd_inode,
672                          * and it's released in clear_inode() of inode.
673                          * So, we can access it via ->i_mapping always
674                          * without igrab().
675                          */
676                         ihold(bdev->bd_inode);
677                         inode->i_bdev = bdev;
678                         inode->i_mapping = bdev->bd_inode->i_mapping;
679                         list_add(&inode->i_devices, &bdev->bd_inodes);
680                 }
681                 spin_unlock(&bdev_lock);
682         }
683         return bdev;
684 }
685
686 static inline int sb_is_blkdev_sb(struct super_block *sb)
687 {
688         return sb == blockdev_superblock;
689 }
690
691 /* Call when you free inode */
692
693 void bd_forget(struct inode *inode)
694 {
695         struct block_device *bdev = NULL;
696
697         spin_lock(&bdev_lock);
698         if (inode->i_bdev) {
699                 if (!sb_is_blkdev_sb(inode->i_sb))
700                         bdev = inode->i_bdev;
701                 __bd_forget(inode);
702         }
703         spin_unlock(&bdev_lock);
704
705         if (bdev)
706                 iput(bdev->bd_inode);
707 }
708
709 /**
710  * bd_may_claim - test whether a block device can be claimed
711  * @bdev: block device of interest
712  * @whole: whole block device containing @bdev, may equal @bdev
713  * @holder: holder trying to claim @bdev
714  *
715  * Test whether @bdev can be claimed by @holder.
716  *
717  * CONTEXT:
718  * spin_lock(&bdev_lock).
719  *
720  * RETURNS:
721  * %true if @bdev can be claimed, %false otherwise.
722  */
723 static bool bd_may_claim(struct block_device *bdev, struct block_device *whole,
724                          void *holder)
725 {
726         if (bdev->bd_holder == holder)
727                 return true;     /* already a holder */
728         else if (bdev->bd_holder != NULL)
729                 return false;    /* held by someone else */
730         else if (bdev->bd_contains == bdev)
731                 return true;     /* is a whole device which isn't held */
732
733         else if (whole->bd_holder == bd_may_claim)
734                 return true;     /* is a partition of a device that is being partitioned */
735         else if (whole->bd_holder != NULL)
736                 return false;    /* is a partition of a held device */
737         else
738                 return true;     /* is a partition of an un-held device */
739 }
740
741 /**
742  * bd_prepare_to_claim - prepare to claim a block device
743  * @bdev: block device of interest
744  * @whole: the whole device containing @bdev, may equal @bdev
745  * @holder: holder trying to claim @bdev
746  *
747  * Prepare to claim @bdev.  This function fails if @bdev is already
748  * claimed by another holder and waits if another claiming is in
749  * progress.  This function doesn't actually claim.  On successful
750  * return, the caller has ownership of bd_claiming and bd_holder[s].
751  *
752  * CONTEXT:
753  * spin_lock(&bdev_lock).  Might release bdev_lock, sleep and regrab
754  * it multiple times.
755  *
756  * RETURNS:
757  * 0 if @bdev can be claimed, -EBUSY otherwise.
758  */
759 static int bd_prepare_to_claim(struct block_device *bdev,
760                                struct block_device *whole, void *holder)
761 {
762 retry:
763         /* if someone else claimed, fail */
764         if (!bd_may_claim(bdev, whole, holder))
765                 return -EBUSY;
766
767         /* if claiming is already in progress, wait for it to finish */
768         if (whole->bd_claiming) {
769                 wait_queue_head_t *wq = bit_waitqueue(&whole->bd_claiming, 0);
770                 DEFINE_WAIT(wait);
771
772                 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
773                 spin_unlock(&bdev_lock);
774                 schedule();
775                 finish_wait(wq, &wait);
776                 spin_lock(&bdev_lock);
777                 goto retry;
778         }
779
780         /* yay, all mine */
781         return 0;
782 }
783
784 /**
785  * bd_start_claiming - start claiming a block device
786  * @bdev: block device of interest
787  * @holder: holder trying to claim @bdev
788  *
789  * @bdev is about to be opened exclusively.  Check @bdev can be opened
790  * exclusively and mark that an exclusive open is in progress.  Each
791  * successful call to this function must be matched with a call to
792  * either bd_finish_claiming() or bd_abort_claiming() (which do not
793  * fail).
794  *
795  * This function is used to gain exclusive access to the block device
796  * without actually causing other exclusive open attempts to fail. It
797  * should be used when the open sequence itself requires exclusive
798  * access but may subsequently fail.
799  *
800  * CONTEXT:
801  * Might sleep.
802  *
803  * RETURNS:
804  * Pointer to the block device containing @bdev on success, ERR_PTR()
805  * value on failure.
806  */
807 static struct block_device *bd_start_claiming(struct block_device *bdev,
808                                               void *holder)
809 {
810         struct gendisk *disk;
811         struct block_device *whole;
812         int partno, err;
813
814         might_sleep();
815
816         /*
817          * @bdev might not have been initialized properly yet, look up
818          * and grab the outer block device the hard way.
819          */
820         disk = get_gendisk(bdev->bd_dev, &partno);
821         if (!disk)
822                 return ERR_PTR(-ENXIO);
823
824         /*
825          * Normally, @bdev should equal what's returned from bdget_disk()
826          * if partno is 0; however, some drivers (floppy) use multiple
827          * bdev's for the same physical device and @bdev may be one of the
828          * aliases.  Keep @bdev if partno is 0.  This means claimer
829          * tracking is broken for those devices but it has always been that
830          * way.
831          */
832         if (partno)
833                 whole = bdget_disk(disk, 0);
834         else
835                 whole = bdgrab(bdev);
836
837         module_put(disk->fops->owner);
838         put_disk(disk);
839         if (!whole)
840                 return ERR_PTR(-ENOMEM);
841
842         /* prepare to claim, if successful, mark claiming in progress */
843         spin_lock(&bdev_lock);
844
845         err = bd_prepare_to_claim(bdev, whole, holder);
846         if (err == 0) {
847                 whole->bd_claiming = holder;
848                 spin_unlock(&bdev_lock);
849                 return whole;
850         } else {
851                 spin_unlock(&bdev_lock);
852                 bdput(whole);
853                 return ERR_PTR(err);
854         }
855 }
856
857 #ifdef CONFIG_SYSFS
858 struct bd_holder_disk {
859         struct list_head        list;
860         struct gendisk          *disk;
861         int                     refcnt;
862 };
863
864 static struct bd_holder_disk *bd_find_holder_disk(struct block_device *bdev,
865                                                   struct gendisk *disk)
866 {
867         struct bd_holder_disk *holder;
868
869         list_for_each_entry(holder, &bdev->bd_holder_disks, list)
870                 if (holder->disk == disk)
871                         return holder;
872         return NULL;
873 }
874
875 static int add_symlink(struct kobject *from, struct kobject *to)
876 {
877         return sysfs_create_link(from, to, kobject_name(to));
878 }
879
880 static void del_symlink(struct kobject *from, struct kobject *to)
881 {
882         sysfs_remove_link(from, kobject_name(to));
883 }
884
885 /**
886  * bd_link_disk_holder - create symlinks between holding disk and slave bdev
887  * @bdev: the claimed slave bdev
888  * @disk: the holding disk
889  *
890  * DON'T USE THIS UNLESS YOU'RE ALREADY USING IT.
891  *
892  * This functions creates the following sysfs symlinks.
893  *
894  * - from "slaves" directory of the holder @disk to the claimed @bdev
895  * - from "holders" directory of the @bdev to the holder @disk
896  *
897  * For example, if /dev/dm-0 maps to /dev/sda and disk for dm-0 is
898  * passed to bd_link_disk_holder(), then:
899  *
900  *   /sys/block/dm-0/slaves/sda --> /sys/block/sda
901  *   /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
902  *
903  * The caller must have claimed @bdev before calling this function and
904  * ensure that both @bdev and @disk are valid during the creation and
905  * lifetime of these symlinks.
906  *
907  * CONTEXT:
908  * Might sleep.
909  *
910  * RETURNS:
911  * 0 on success, -errno on failure.
912  */
913 int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk)
914 {
915         struct bd_holder_disk *holder;
916         int ret = 0;
917
918         mutex_lock(&bdev->bd_mutex);
919
920         WARN_ON_ONCE(!bdev->bd_holder);
921
922         /* FIXME: remove the following once add_disk() handles errors */
923         if (WARN_ON(!disk->slave_dir || !bdev->bd_part->holder_dir))
924                 goto out_unlock;
925
926         holder = bd_find_holder_disk(bdev, disk);
927         if (holder) {
928                 holder->refcnt++;
929                 goto out_unlock;
930         }
931
932         holder = kzalloc(sizeof(*holder), GFP_KERNEL);
933         if (!holder) {
934                 ret = -ENOMEM;
935                 goto out_unlock;
936         }
937
938         INIT_LIST_HEAD(&holder->list);
939         holder->disk = disk;
940         holder->refcnt = 1;
941
942         ret = add_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
943         if (ret)
944                 goto out_free;
945
946         ret = add_symlink(bdev->bd_part->holder_dir, &disk_to_dev(disk)->kobj);
947         if (ret)
948                 goto out_del;
949         /*
950          * bdev could be deleted beneath us which would implicitly destroy
951          * the holder directory.  Hold on to it.
952          */
953         kobject_get(bdev->bd_part->holder_dir);
954
955         list_add(&holder->list, &bdev->bd_holder_disks);
956         goto out_unlock;
957
958 out_del:
959         del_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
960 out_free:
961         kfree(holder);
962 out_unlock:
963         mutex_unlock(&bdev->bd_mutex);
964         return ret;
965 }
966 EXPORT_SYMBOL_GPL(bd_link_disk_holder);
967
968 /**
969  * bd_unlink_disk_holder - destroy symlinks created by bd_link_disk_holder()
970  * @bdev: the calimed slave bdev
971  * @disk: the holding disk
972  *
973  * DON'T USE THIS UNLESS YOU'RE ALREADY USING IT.
974  *
975  * CONTEXT:
976  * Might sleep.
977  */
978 void bd_unlink_disk_holder(struct block_device *bdev, struct gendisk *disk)
979 {
980         struct bd_holder_disk *holder;
981
982         mutex_lock(&bdev->bd_mutex);
983
984         holder = bd_find_holder_disk(bdev, disk);
985
986         if (!WARN_ON_ONCE(holder == NULL) && !--holder->refcnt) {
987                 del_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
988                 del_symlink(bdev->bd_part->holder_dir,
989                             &disk_to_dev(disk)->kobj);
990                 kobject_put(bdev->bd_part->holder_dir);
991                 list_del_init(&holder->list);
992                 kfree(holder);
993         }
994
995         mutex_unlock(&bdev->bd_mutex);
996 }
997 EXPORT_SYMBOL_GPL(bd_unlink_disk_holder);
998 #endif
999
1000 /**
1001  * flush_disk - invalidates all buffer-cache entries on a disk
1002  *
1003  * @bdev:      struct block device to be flushed
1004  * @kill_dirty: flag to guide handling of dirty inodes
1005  *
1006  * Invalidates all buffer-cache entries on a disk. It should be called
1007  * when a disk has been changed -- either by a media change or online
1008  * resize.
1009  */
1010 static void flush_disk(struct block_device *bdev, bool kill_dirty)
1011 {
1012         if (__invalidate_device(bdev, kill_dirty)) {
1013                 char name[BDEVNAME_SIZE] = "";
1014
1015                 if (bdev->bd_disk)
1016                         disk_name(bdev->bd_disk, 0, name);
1017                 printk(KERN_WARNING "VFS: busy inodes on changed media or "
1018                        "resized disk %s\n", name);
1019         }
1020
1021         if (!bdev->bd_disk)
1022                 return;
1023         if (disk_part_scan_enabled(bdev->bd_disk))
1024                 bdev->bd_invalidated = 1;
1025 }
1026
1027 /**
1028  * check_disk_size_change - checks for disk size change and adjusts bdev size.
1029  * @disk: struct gendisk to check
1030  * @bdev: struct bdev to adjust.
1031  *
1032  * This routine checks to see if the bdev size does not match the disk size
1033  * and adjusts it if it differs.
1034  */
1035 void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
1036 {
1037         loff_t disk_size, bdev_size;
1038
1039         disk_size = (loff_t)get_capacity(disk) << 9;
1040         bdev_size = i_size_read(bdev->bd_inode);
1041         if (disk_size != bdev_size) {
1042                 char name[BDEVNAME_SIZE];
1043
1044                 disk_name(disk, 0, name);
1045                 printk(KERN_INFO
1046                        "%s: detected capacity change from %lld to %lld\n",
1047                        name, bdev_size, disk_size);
1048                 i_size_write(bdev->bd_inode, disk_size);
1049                 flush_disk(bdev, false);
1050         }
1051 }
1052 EXPORT_SYMBOL(check_disk_size_change);
1053
1054 /**
1055  * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
1056  * @disk: struct gendisk to be revalidated
1057  *
1058  * This routine is a wrapper for lower-level driver's revalidate_disk
1059  * call-backs.  It is used to do common pre and post operations needed
1060  * for all revalidate_disk operations.
1061  */
1062 int revalidate_disk(struct gendisk *disk)
1063 {
1064         struct block_device *bdev;
1065         int ret = 0;
1066
1067         if (disk->fops->revalidate_disk)
1068                 ret = disk->fops->revalidate_disk(disk);
1069
1070         bdev = bdget_disk(disk, 0);
1071         if (!bdev)
1072                 return ret;
1073
1074         mutex_lock(&bdev->bd_mutex);
1075         check_disk_size_change(disk, bdev);
1076         mutex_unlock(&bdev->bd_mutex);
1077         bdput(bdev);
1078         return ret;
1079 }
1080 EXPORT_SYMBOL(revalidate_disk);
1081
1082 /*
1083  * This routine checks whether a removable media has been changed,
1084  * and invalidates all buffer-cache-entries in that case. This
1085  * is a relatively slow routine, so we have to try to minimize using
1086  * it. Thus it is called only upon a 'mount' or 'open'. This
1087  * is the best way of combining speed and utility, I think.
1088  * People changing diskettes in the middle of an operation deserve
1089  * to lose :-)
1090  */
1091 int check_disk_change(struct block_device *bdev)
1092 {
1093         struct gendisk *disk = bdev->bd_disk;
1094         const struct block_device_operations *bdops = disk->fops;
1095         unsigned int events;
1096
1097         events = disk_clear_events(disk, DISK_EVENT_MEDIA_CHANGE |
1098                                    DISK_EVENT_EJECT_REQUEST);
1099         if (!(events & DISK_EVENT_MEDIA_CHANGE))
1100                 return 0;
1101
1102         flush_disk(bdev, true);
1103         if (bdops->revalidate_disk)
1104                 bdops->revalidate_disk(bdev->bd_disk);
1105         return 1;
1106 }
1107
1108 EXPORT_SYMBOL(check_disk_change);
1109
1110 void bd_set_size(struct block_device *bdev, loff_t size)
1111 {
1112         unsigned bsize = bdev_logical_block_size(bdev);
1113
1114         bdev->bd_inode->i_size = size;
1115         while (bsize < PAGE_CACHE_SIZE) {
1116                 if (size & bsize)
1117                         break;
1118                 bsize <<= 1;
1119         }
1120         bdev->bd_block_size = bsize;
1121         bdev->bd_inode->i_blkbits = blksize_bits(bsize);
1122 }
1123 EXPORT_SYMBOL(bd_set_size);
1124
1125 static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
1126
1127 /*
1128  * bd_mutex locking:
1129  *
1130  *  mutex_lock(part->bd_mutex)
1131  *    mutex_lock_nested(whole->bd_mutex, 1)
1132  */
1133
1134 static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
1135 {
1136         struct gendisk *disk;
1137         struct module *owner;
1138         int ret;
1139         int partno;
1140         int perm = 0;
1141
1142         if (mode & FMODE_READ)
1143                 perm |= MAY_READ;
1144         if (mode & FMODE_WRITE)
1145                 perm |= MAY_WRITE;
1146         /*
1147          * hooks: /n/, see "layering violations".
1148          */
1149         if (!for_part) {
1150                 ret = devcgroup_inode_permission(bdev->bd_inode, perm);
1151                 if (ret != 0) {
1152                         bdput(bdev);
1153                         return ret;
1154                 }
1155         }
1156
1157  restart:
1158
1159         ret = -ENXIO;
1160         disk = get_gendisk(bdev->bd_dev, &partno);
1161         if (!disk)
1162                 goto out;
1163         owner = disk->fops->owner;
1164
1165         disk_block_events(disk);
1166         mutex_lock_nested(&bdev->bd_mutex, for_part);
1167         if (!bdev->bd_openers) {
1168                 bdev->bd_disk = disk;
1169                 bdev->bd_queue = disk->queue;
1170                 bdev->bd_contains = bdev;
1171                 if (!partno) {
1172                         struct backing_dev_info *bdi;
1173
1174                         ret = -ENXIO;
1175                         bdev->bd_part = disk_get_part(disk, partno);
1176                         if (!bdev->bd_part)
1177                                 goto out_clear;
1178
1179                         ret = 0;
1180                         if (disk->fops->open) {
1181                                 ret = disk->fops->open(bdev, mode);
1182                                 if (ret == -ERESTARTSYS) {
1183                                         /* Lost a race with 'disk' being
1184                                          * deleted, try again.
1185                                          * See md.c
1186                                          */
1187                                         disk_put_part(bdev->bd_part);
1188                                         bdev->bd_part = NULL;
1189                                         bdev->bd_disk = NULL;
1190                                         bdev->bd_queue = NULL;
1191                                         mutex_unlock(&bdev->bd_mutex);
1192                                         disk_unblock_events(disk);
1193                                         put_disk(disk);
1194                                         module_put(owner);
1195                                         goto restart;
1196                                 }
1197                         }
1198
1199                         if (!ret && !bdev->bd_openers) {
1200                                 bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
1201                                 bdi = blk_get_backing_dev_info(bdev);
1202                                 if (bdi == NULL)
1203                                         bdi = &default_backing_dev_info;
1204                                 bdev_inode_switch_bdi(bdev->bd_inode, bdi);
1205                         }
1206
1207                         /*
1208                          * If the device is invalidated, rescan partition
1209                          * if open succeeded or failed with -ENOMEDIUM.
1210                          * The latter is necessary to prevent ghost
1211                          * partitions on a removed medium.
1212                          */
1213                         if (bdev->bd_invalidated) {
1214                                 if (!ret)
1215                                         rescan_partitions(disk, bdev);
1216                                 else if (ret == -ENOMEDIUM)
1217                                         invalidate_partitions(disk, bdev);
1218                         }
1219                         if (ret)
1220                                 goto out_clear;
1221                 } else {
1222                         struct block_device *whole;
1223                         whole = bdget_disk(disk, 0);
1224                         ret = -ENOMEM;
1225                         if (!whole)
1226                                 goto out_clear;
1227                         BUG_ON(for_part);
1228                         ret = __blkdev_get(whole, mode, 1);
1229                         if (ret)
1230                                 goto out_clear;
1231                         bdev->bd_contains = whole;
1232                         bdev_inode_switch_bdi(bdev->bd_inode,
1233                                 whole->bd_inode->i_data.backing_dev_info);
1234                         bdev->bd_part = disk_get_part(disk, partno);
1235                         if (!(disk->flags & GENHD_FL_UP) ||
1236                             !bdev->bd_part || !bdev->bd_part->nr_sects) {
1237                                 ret = -ENXIO;
1238                                 goto out_clear;
1239                         }
1240                         bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
1241                 }
1242         } else {
1243                 if (bdev->bd_contains == bdev) {
1244                         ret = 0;
1245                         if (bdev->bd_disk->fops->open)
1246                                 ret = bdev->bd_disk->fops->open(bdev, mode);
1247                         /* the same as first opener case, read comment there */
1248                         if (bdev->bd_invalidated) {
1249                                 if (!ret)
1250                                         rescan_partitions(bdev->bd_disk, bdev);
1251                                 else if (ret == -ENOMEDIUM)
1252                                         invalidate_partitions(bdev->bd_disk, bdev);
1253                         }
1254                         if (ret)
1255                                 goto out_unlock_bdev;
1256                 }
1257                 /* only one opener holds refs to the module and disk */
1258                 put_disk(disk);
1259                 module_put(owner);
1260         }
1261         bdev->bd_openers++;
1262         if (for_part)
1263                 bdev->bd_part_count++;
1264         mutex_unlock(&bdev->bd_mutex);
1265         disk_unblock_events(disk);
1266         return 0;
1267
1268  out_clear:
1269         disk_put_part(bdev->bd_part);
1270         bdev->bd_disk = NULL;
1271         bdev->bd_part = NULL;
1272         bdev->bd_queue = NULL;
1273         bdev_inode_switch_bdi(bdev->bd_inode, &default_backing_dev_info);
1274         if (bdev != bdev->bd_contains)
1275                 __blkdev_put(bdev->bd_contains, mode, 1);
1276         bdev->bd_contains = NULL;
1277  out_unlock_bdev:
1278         mutex_unlock(&bdev->bd_mutex);
1279         disk_unblock_events(disk);
1280         put_disk(disk);
1281         module_put(owner);
1282  out:
1283         bdput(bdev);
1284
1285         return ret;
1286 }
1287
1288 /**
1289  * blkdev_get - open a block device
1290  * @bdev: block_device to open
1291  * @mode: FMODE_* mask
1292  * @holder: exclusive holder identifier
1293  *
1294  * Open @bdev with @mode.  If @mode includes %FMODE_EXCL, @bdev is
1295  * open with exclusive access.  Specifying %FMODE_EXCL with %NULL
1296  * @holder is invalid.  Exclusive opens may nest for the same @holder.
1297  *
1298  * On success, the reference count of @bdev is unchanged.  On failure,
1299  * @bdev is put.
1300  *
1301  * CONTEXT:
1302  * Might sleep.
1303  *
1304  * RETURNS:
1305  * 0 on success, -errno on failure.
1306  */
1307 int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder)
1308 {
1309         struct block_device *whole = NULL;
1310         int res;
1311
1312         WARN_ON_ONCE((mode & FMODE_EXCL) && !holder);
1313
1314         if ((mode & FMODE_EXCL) && holder) {
1315                 whole = bd_start_claiming(bdev, holder);
1316                 if (IS_ERR(whole)) {
1317                         bdput(bdev);
1318                         return PTR_ERR(whole);
1319                 }
1320         }
1321
1322         res = __blkdev_get(bdev, mode, 0);
1323
1324         if (whole) {
1325                 struct gendisk *disk = whole->bd_disk;
1326
1327                 /* finish claiming */
1328                 mutex_lock(&bdev->bd_mutex);
1329                 spin_lock(&bdev_lock);
1330
1331                 if (!res) {
1332                         BUG_ON(!bd_may_claim(bdev, whole, holder));
1333                         /*
1334                          * Note that for a whole device bd_holders
1335                          * will be incremented twice, and bd_holder
1336                          * will be set to bd_may_claim before being
1337                          * set to holder
1338                          */
1339                         whole->bd_holders++;
1340                         whole->bd_holder = bd_may_claim;
1341                         bdev->bd_holders++;
1342                         bdev->bd_holder = holder;
1343                 }
1344
1345                 /* tell others that we're done */
1346                 BUG_ON(whole->bd_claiming != holder);
1347                 whole->bd_claiming = NULL;
1348                 wake_up_bit(&whole->bd_claiming, 0);
1349
1350                 spin_unlock(&bdev_lock);
1351
1352                 /*
1353                  * Block event polling for write claims if requested.  Any
1354                  * write holder makes the write_holder state stick until
1355                  * all are released.  This is good enough and tracking
1356                  * individual writeable reference is too fragile given the
1357                  * way @mode is used in blkdev_get/put().
1358                  */
1359                 if (!res && (mode & FMODE_WRITE) && !bdev->bd_write_holder &&
1360                     (disk->flags & GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE)) {
1361                         bdev->bd_write_holder = true;
1362                         disk_block_events(disk);
1363                 }
1364
1365                 mutex_unlock(&bdev->bd_mutex);
1366                 bdput(whole);
1367         }
1368
1369         return res;
1370 }
1371 EXPORT_SYMBOL(blkdev_get);
1372
1373 /**
1374  * blkdev_get_by_path - open a block device by name
1375  * @path: path to the block device to open
1376  * @mode: FMODE_* mask
1377  * @holder: exclusive holder identifier
1378  *
1379  * Open the blockdevice described by the device file at @path.  @mode
1380  * and @holder are identical to blkdev_get().
1381  *
1382  * On success, the returned block_device has reference count of one.
1383  *
1384  * CONTEXT:
1385  * Might sleep.
1386  *
1387  * RETURNS:
1388  * Pointer to block_device on success, ERR_PTR(-errno) on failure.
1389  */
1390 struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
1391                                         void *holder)
1392 {
1393         struct block_device *bdev;
1394         int err;
1395
1396         bdev = lookup_bdev(path);
1397         if (IS_ERR(bdev))
1398                 return bdev;
1399
1400         err = blkdev_get(bdev, mode, holder);
1401         if (err)
1402                 return ERR_PTR(err);
1403
1404         if ((mode & FMODE_WRITE) && bdev_read_only(bdev)) {
1405                 blkdev_put(bdev, mode);
1406                 return ERR_PTR(-EACCES);
1407         }
1408
1409         return bdev;
1410 }
1411 EXPORT_SYMBOL(blkdev_get_by_path);
1412
1413 /**
1414  * blkdev_get_by_dev - open a block device by device number
1415  * @dev: device number of block device to open
1416  * @mode: FMODE_* mask
1417  * @holder: exclusive holder identifier
1418  *
1419  * Open the blockdevice described by device number @dev.  @mode and
1420  * @holder are identical to blkdev_get().
1421  *
1422  * Use it ONLY if you really do not have anything better - i.e. when
1423  * you are behind a truly sucky interface and all you are given is a
1424  * device number.  _Never_ to be used for internal purposes.  If you
1425  * ever need it - reconsider your API.
1426  *
1427  * On success, the returned block_device has reference count of one.
1428  *
1429  * CONTEXT:
1430  * Might sleep.
1431  *
1432  * RETURNS:
1433  * Pointer to block_device on success, ERR_PTR(-errno) on failure.
1434  */
1435 struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder)
1436 {
1437         struct block_device *bdev;
1438         int err;
1439
1440         bdev = bdget(dev);
1441         if (!bdev)
1442                 return ERR_PTR(-ENOMEM);
1443
1444         err = blkdev_get(bdev, mode, holder);
1445         if (err)
1446                 return ERR_PTR(err);
1447
1448         return bdev;
1449 }
1450 EXPORT_SYMBOL(blkdev_get_by_dev);
1451
1452 static int blkdev_open(struct inode * inode, struct file * filp)
1453 {
1454         struct block_device *bdev;
1455
1456         /*
1457          * Preserve backwards compatibility and allow large file access
1458          * even if userspace doesn't ask for it explicitly. Some mkfs
1459          * binary needs it. We might want to drop this workaround
1460          * during an unstable branch.
1461          */
1462         filp->f_flags |= O_LARGEFILE;
1463
1464         if (filp->f_flags & O_NDELAY)
1465                 filp->f_mode |= FMODE_NDELAY;
1466         if (filp->f_flags & O_EXCL)
1467                 filp->f_mode |= FMODE_EXCL;
1468         if ((filp->f_flags & O_ACCMODE) == 3)
1469                 filp->f_mode |= FMODE_WRITE_IOCTL;
1470
1471         bdev = bd_acquire(inode);
1472         if (bdev == NULL)
1473                 return -ENOMEM;
1474
1475         filp->f_mapping = bdev->bd_inode->i_mapping;
1476
1477         return blkdev_get(bdev, filp->f_mode, filp);
1478 }
1479
1480 static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
1481 {
1482         int ret = 0;
1483         struct gendisk *disk = bdev->bd_disk;
1484         struct block_device *victim = NULL;
1485
1486         mutex_lock_nested(&bdev->bd_mutex, for_part);
1487         if (for_part)
1488                 bdev->bd_part_count--;
1489
1490         if (!--bdev->bd_openers) {
1491                 WARN_ON_ONCE(bdev->bd_holders);
1492                 sync_blockdev(bdev);
1493                 kill_bdev(bdev);
1494                 /* ->release can cause the old bdi to disappear,
1495                  * so must switch it out first
1496                  */
1497                 bdev_inode_switch_bdi(bdev->bd_inode,
1498                                         &default_backing_dev_info);
1499         }
1500         if (bdev->bd_contains == bdev) {
1501                 if (disk->fops->release)
1502                         ret = disk->fops->release(disk, mode);
1503         }
1504         if (!bdev->bd_openers) {
1505                 struct module *owner = disk->fops->owner;
1506
1507                 disk_put_part(bdev->bd_part);
1508                 bdev->bd_part = NULL;
1509                 bdev->bd_disk = NULL;
1510                 if (bdev != bdev->bd_contains)
1511                         victim = bdev->bd_contains;
1512                 bdev->bd_contains = NULL;
1513
1514                 put_disk(disk);
1515                 module_put(owner);
1516         }
1517         mutex_unlock(&bdev->bd_mutex);
1518         bdput(bdev);
1519         if (victim)
1520                 __blkdev_put(victim, mode, 1);
1521         return ret;
1522 }
1523
1524 int blkdev_put(struct block_device *bdev, fmode_t mode)
1525 {
1526         mutex_lock(&bdev->bd_mutex);
1527
1528         if (mode & FMODE_EXCL) {
1529                 bool bdev_free;
1530
1531                 /*
1532                  * Release a claim on the device.  The holder fields
1533                  * are protected with bdev_lock.  bd_mutex is to
1534                  * synchronize disk_holder unlinking.
1535                  */
1536                 spin_lock(&bdev_lock);
1537
1538                 WARN_ON_ONCE(--bdev->bd_holders < 0);
1539                 WARN_ON_ONCE(--bdev->bd_contains->bd_holders < 0);
1540
1541                 /* bd_contains might point to self, check in a separate step */
1542                 if ((bdev_free = !bdev->bd_holders))
1543                         bdev->bd_holder = NULL;
1544                 if (!bdev->bd_contains->bd_holders)
1545                         bdev->bd_contains->bd_holder = NULL;
1546
1547                 spin_unlock(&bdev_lock);
1548
1549                 /*
1550                  * If this was the last claim, remove holder link and
1551                  * unblock evpoll if it was a write holder.
1552                  */
1553                 if (bdev_free && bdev->bd_write_holder) {
1554                         disk_unblock_events(bdev->bd_disk);
1555                         bdev->bd_write_holder = false;
1556                 }
1557         }
1558
1559         /*
1560          * Trigger event checking and tell drivers to flush MEDIA_CHANGE
1561          * event.  This is to ensure detection of media removal commanded
1562          * from userland - e.g. eject(1).
1563          */
1564         disk_flush_events(bdev->bd_disk, DISK_EVENT_MEDIA_CHANGE);
1565
1566         mutex_unlock(&bdev->bd_mutex);
1567
1568         return __blkdev_put(bdev, mode, 0);
1569 }
1570 EXPORT_SYMBOL(blkdev_put);
1571
1572 static int blkdev_close(struct inode * inode, struct file * filp)
1573 {
1574         struct block_device *bdev = I_BDEV(filp->f_mapping->host);
1575
1576         return blkdev_put(bdev, filp->f_mode);
1577 }
1578
1579 static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1580 {
1581         struct block_device *bdev = I_BDEV(file->f_mapping->host);
1582         fmode_t mode = file->f_mode;
1583
1584         /*
1585          * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
1586          * to updated it before every ioctl.
1587          */
1588         if (file->f_flags & O_NDELAY)
1589                 mode |= FMODE_NDELAY;
1590         else
1591                 mode &= ~FMODE_NDELAY;
1592
1593         return blkdev_ioctl(bdev, mode, cmd, arg);
1594 }
1595
1596 ssize_t blkdev_aio_read(struct kiocb *iocb, const struct iovec *iov,
1597                         unsigned long nr_segs, loff_t pos)
1598 {
1599         ssize_t ret;
1600         struct block_device *bdev = I_BDEV(iocb->ki_filp->f_mapping->host);
1601
1602         percpu_down_read(&bdev->bd_block_size_semaphore);
1603
1604         ret = generic_file_aio_read(iocb, iov, nr_segs, pos);
1605
1606         percpu_up_read(&bdev->bd_block_size_semaphore);
1607
1608         return ret;
1609 }
1610 EXPORT_SYMBOL_GPL(blkdev_aio_read);
1611
1612 /*
1613  * Write data to the block device.  Only intended for the block device itself
1614  * and the raw driver which basically is a fake block device.
1615  *
1616  * Does not take i_mutex for the write and thus is not for general purpose
1617  * use.
1618  */
1619 ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
1620                          unsigned long nr_segs, loff_t pos)
1621 {
1622         struct file *file = iocb->ki_filp;
1623         struct block_device *bdev = I_BDEV(file->f_mapping->host);
1624         struct blk_plug plug;
1625         ssize_t ret;
1626
1627         BUG_ON(iocb->ki_pos != pos);
1628
1629         blk_start_plug(&plug);
1630
1631         percpu_down_read(&bdev->bd_block_size_semaphore);
1632
1633         ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
1634         if (ret > 0 || ret == -EIOCBQUEUED) {
1635                 ssize_t err;
1636
1637                 err = generic_write_sync(file, pos, ret);
1638                 if (err < 0 && ret > 0)
1639                         ret = err;
1640         }
1641
1642         percpu_up_read(&bdev->bd_block_size_semaphore);
1643
1644         blk_finish_plug(&plug);
1645
1646         return ret;
1647 }
1648 EXPORT_SYMBOL_GPL(blkdev_aio_write);
1649
1650 static int blkdev_mmap(struct file *file, struct vm_area_struct *vma)
1651 {
1652         int ret;
1653         struct block_device *bdev = I_BDEV(file->f_mapping->host);
1654
1655         percpu_down_read(&bdev->bd_block_size_semaphore);
1656
1657         ret = generic_file_mmap(file, vma);
1658
1659         percpu_up_read(&bdev->bd_block_size_semaphore);
1660
1661         return ret;
1662 }
1663
1664 /*
1665  * Try to release a page associated with block device when the system
1666  * is under memory pressure.
1667  */
1668 static int blkdev_releasepage(struct page *page, gfp_t wait)
1669 {
1670         struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
1671
1672         if (super && super->s_op->bdev_try_to_free_page)
1673                 return super->s_op->bdev_try_to_free_page(super, page, wait);
1674
1675         return try_to_free_buffers(page);
1676 }
1677
1678 static const struct address_space_operations def_blk_aops = {
1679         .readpage       = blkdev_readpage,
1680         .writepage      = blkdev_writepage,
1681         .write_begin    = blkdev_write_begin,
1682         .write_end      = blkdev_write_end,
1683         .writepages     = generic_writepages,
1684         .releasepage    = blkdev_releasepage,
1685         .direct_IO      = blkdev_direct_IO,
1686 };
1687
1688 const struct file_operations def_blk_fops = {
1689         .open           = blkdev_open,
1690         .release        = blkdev_close,
1691         .llseek         = block_llseek,
1692         .read           = do_sync_read,
1693         .write          = do_sync_write,
1694         .aio_read       = blkdev_aio_read,
1695         .aio_write      = blkdev_aio_write,
1696         .mmap           = blkdev_mmap,
1697         .fsync          = blkdev_fsync,
1698         .unlocked_ioctl = block_ioctl,
1699 #ifdef CONFIG_COMPAT
1700         .compat_ioctl   = compat_blkdev_ioctl,
1701 #endif
1702         .splice_read    = generic_file_splice_read,
1703         .splice_write   = generic_file_splice_write,
1704 };
1705
1706 int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
1707 {
1708         int res;
1709         mm_segment_t old_fs = get_fs();
1710         set_fs(KERNEL_DS);
1711         res = blkdev_ioctl(bdev, 0, cmd, arg);
1712         set_fs(old_fs);
1713         return res;
1714 }
1715
1716 EXPORT_SYMBOL(ioctl_by_bdev);
1717
1718 /**
1719  * lookup_bdev  - lookup a struct block_device by name
1720  * @pathname:   special file representing the block device
1721  *
1722  * Get a reference to the blockdevice at @pathname in the current
1723  * namespace if possible and return it.  Return ERR_PTR(error)
1724  * otherwise.
1725  */
1726 struct block_device *lookup_bdev(const char *pathname)
1727 {
1728         struct block_device *bdev;
1729         struct inode *inode;
1730         struct path path;
1731         int error;
1732
1733         if (!pathname || !*pathname)
1734                 return ERR_PTR(-EINVAL);
1735
1736         error = kern_path(pathname, LOOKUP_FOLLOW, &path);
1737         if (error)
1738                 return ERR_PTR(error);
1739
1740         inode = path.dentry->d_inode;
1741         error = -ENOTBLK;
1742         if (!S_ISBLK(inode->i_mode))
1743                 goto fail;
1744         error = -EACCES;
1745         if (path.mnt->mnt_flags & MNT_NODEV)
1746                 goto fail;
1747         error = -ENOMEM;
1748         bdev = bd_acquire(inode);
1749         if (!bdev)
1750                 goto fail;
1751 out:
1752         path_put(&path);
1753         return bdev;
1754 fail:
1755         bdev = ERR_PTR(error);
1756         goto out;
1757 }
1758 EXPORT_SYMBOL(lookup_bdev);
1759
1760 int __invalidate_device(struct block_device *bdev, bool kill_dirty)
1761 {
1762         struct super_block *sb = get_super(bdev);
1763         int res = 0;
1764
1765         if (sb) {
1766                 /*
1767                  * no need to lock the super, get_super holds the
1768                  * read mutex so the filesystem cannot go away
1769                  * under us (->put_super runs with the write lock
1770                  * hold).
1771                  */
1772                 shrink_dcache_sb(sb);
1773                 res = invalidate_inodes(sb, kill_dirty);
1774                 drop_super(sb);
1775         }
1776         invalidate_bdev(bdev);
1777         return res;
1778 }
1779 EXPORT_SYMBOL(__invalidate_device);
1780
1781 void iterate_bdevs(void (*func)(struct block_device *, void *), void *arg)
1782 {
1783         struct inode *inode, *old_inode = NULL;
1784
1785         spin_lock(&inode_sb_list_lock);
1786         list_for_each_entry(inode, &blockdev_superblock->s_inodes, i_sb_list) {
1787                 struct address_space *mapping = inode->i_mapping;
1788
1789                 spin_lock(&inode->i_lock);
1790                 if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW) ||
1791                     mapping->nrpages == 0) {
1792                         spin_unlock(&inode->i_lock);
1793                         continue;
1794                 }
1795                 __iget(inode);
1796                 spin_unlock(&inode->i_lock);
1797                 spin_unlock(&inode_sb_list_lock);
1798                 /*
1799                  * We hold a reference to 'inode' so it couldn't have been
1800                  * removed from s_inodes list while we dropped the
1801                  * inode_sb_list_lock.  We cannot iput the inode now as we can
1802                  * be holding the last reference and we cannot iput it under
1803                  * inode_sb_list_lock. So we keep the reference and iput it
1804                  * later.
1805                  */
1806                 iput(old_inode);
1807                 old_inode = inode;
1808
1809                 func(I_BDEV(inode), arg);
1810
1811                 spin_lock(&inode_sb_list_lock);
1812         }
1813         spin_unlock(&inode_sb_list_lock);
1814         iput(old_inode);
1815 }