radix_tree_tag_get() is not as safe as the docs make out [ver #2]
[linux-2.6/cjktty.git] / fs / block_dev.c
blob2a6d0193f13971877913283092b4363d44b9c60f
1 /*
2 * linux/fs/block_dev.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 2001 Andrea Arcangeli <andrea@suse.de> SuSE
6 */
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/smp_lock.h>
15 #include <linux/device_cgroup.h>
16 #include <linux/highmem.h>
17 #include <linux/blkdev.h>
18 #include <linux/module.h>
19 #include <linux/blkpg.h>
20 #include <linux/buffer_head.h>
21 #include <linux/pagevec.h>
22 #include <linux/writeback.h>
23 #include <linux/mpage.h>
24 #include <linux/mount.h>
25 #include <linux/uio.h>
26 #include <linux/namei.h>
27 #include <linux/log2.h>
28 #include <linux/kmemleak.h>
29 #include <asm/uaccess.h>
30 #include "internal.h"
32 struct bdev_inode {
33 struct block_device bdev;
34 struct inode vfs_inode;
37 static const struct address_space_operations def_blk_aops;
39 static inline struct bdev_inode *BDEV_I(struct inode *inode)
41 return container_of(inode, struct bdev_inode, vfs_inode);
44 inline struct block_device *I_BDEV(struct inode *inode)
46 return &BDEV_I(inode)->bdev;
49 EXPORT_SYMBOL(I_BDEV);
51 static sector_t max_block(struct block_device *bdev)
53 sector_t retval = ~((sector_t)0);
54 loff_t sz = i_size_read(bdev->bd_inode);
56 if (sz) {
57 unsigned int size = block_size(bdev);
58 unsigned int sizebits = blksize_bits(size);
59 retval = (sz >> sizebits);
61 return retval;
64 /* Kill _all_ buffers and pagecache , dirty or not.. */
65 static void kill_bdev(struct block_device *bdev)
67 if (bdev->bd_inode->i_mapping->nrpages == 0)
68 return;
69 invalidate_bh_lrus();
70 truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
73 int set_blocksize(struct block_device *bdev, int size)
75 /* Size must be a power of two, and between 512 and PAGE_SIZE */
76 if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
77 return -EINVAL;
79 /* Size cannot be smaller than the size supported by the device */
80 if (size < bdev_logical_block_size(bdev))
81 return -EINVAL;
83 /* Don't change the size if it is same as current */
84 if (bdev->bd_block_size != size) {
85 sync_blockdev(bdev);
86 bdev->bd_block_size = size;
87 bdev->bd_inode->i_blkbits = blksize_bits(size);
88 kill_bdev(bdev);
90 return 0;
93 EXPORT_SYMBOL(set_blocksize);
95 int sb_set_blocksize(struct super_block *sb, int size)
97 if (set_blocksize(sb->s_bdev, size))
98 return 0;
99 /* If we get here, we know size is power of two
100 * and it's value is between 512 and PAGE_SIZE */
101 sb->s_blocksize = size;
102 sb->s_blocksize_bits = blksize_bits(size);
103 return sb->s_blocksize;
106 EXPORT_SYMBOL(sb_set_blocksize);
108 int sb_min_blocksize(struct super_block *sb, int size)
110 int minsize = bdev_logical_block_size(sb->s_bdev);
111 if (size < minsize)
112 size = minsize;
113 return sb_set_blocksize(sb, size);
116 EXPORT_SYMBOL(sb_min_blocksize);
118 static int
119 blkdev_get_block(struct inode *inode, sector_t iblock,
120 struct buffer_head *bh, int create)
122 if (iblock >= max_block(I_BDEV(inode))) {
123 if (create)
124 return -EIO;
127 * for reads, we're just trying to fill a partial page.
128 * return a hole, they will have to call get_block again
129 * before they can fill it, and they will get -EIO at that
130 * time
132 return 0;
134 bh->b_bdev = I_BDEV(inode);
135 bh->b_blocknr = iblock;
136 set_buffer_mapped(bh);
137 return 0;
140 static int
141 blkdev_get_blocks(struct inode *inode, sector_t iblock,
142 struct buffer_head *bh, int create)
144 sector_t end_block = max_block(I_BDEV(inode));
145 unsigned long max_blocks = bh->b_size >> inode->i_blkbits;
147 if ((iblock + max_blocks) > end_block) {
148 max_blocks = end_block - iblock;
149 if ((long)max_blocks <= 0) {
150 if (create)
151 return -EIO; /* write fully beyond EOF */
153 * It is a read which is fully beyond EOF. We return
154 * a !buffer_mapped buffer
156 max_blocks = 0;
160 bh->b_bdev = I_BDEV(inode);
161 bh->b_blocknr = iblock;
162 bh->b_size = max_blocks << inode->i_blkbits;
163 if (max_blocks)
164 set_buffer_mapped(bh);
165 return 0;
168 static ssize_t
169 blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
170 loff_t offset, unsigned long nr_segs)
172 struct file *file = iocb->ki_filp;
173 struct inode *inode = file->f_mapping->host;
175 return blockdev_direct_IO_no_locking(rw, iocb, inode, I_BDEV(inode),
176 iov, offset, nr_segs, blkdev_get_blocks, NULL);
179 int __sync_blockdev(struct block_device *bdev, int wait)
181 if (!bdev)
182 return 0;
183 if (!wait)
184 return filemap_flush(bdev->bd_inode->i_mapping);
185 return filemap_write_and_wait(bdev->bd_inode->i_mapping);
189 * Write out and wait upon all the dirty data associated with a block
190 * device via its mapping. Does not take the superblock lock.
192 int sync_blockdev(struct block_device *bdev)
194 return __sync_blockdev(bdev, 1);
196 EXPORT_SYMBOL(sync_blockdev);
199 * Write out and wait upon all dirty data associated with this
200 * device. Filesystem data as well as the underlying block
201 * device. Takes the superblock lock.
203 int fsync_bdev(struct block_device *bdev)
205 struct super_block *sb = get_super(bdev);
206 if (sb) {
207 int res = sync_filesystem(sb);
208 drop_super(sb);
209 return res;
211 return sync_blockdev(bdev);
213 EXPORT_SYMBOL(fsync_bdev);
216 * freeze_bdev -- lock a filesystem and force it into a consistent state
217 * @bdev: blockdevice to lock
219 * If a superblock is found on this device, we take the s_umount semaphore
220 * on it to make sure nobody unmounts until the snapshot creation is done.
221 * The reference counter (bd_fsfreeze_count) guarantees that only the last
222 * unfreeze process can unfreeze the frozen filesystem actually when multiple
223 * freeze requests arrive simultaneously. It counts up in freeze_bdev() and
224 * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
225 * actually.
227 struct super_block *freeze_bdev(struct block_device *bdev)
229 struct super_block *sb;
230 int error = 0;
232 mutex_lock(&bdev->bd_fsfreeze_mutex);
233 if (++bdev->bd_fsfreeze_count > 1) {
235 * We don't even need to grab a reference - the first call
236 * to freeze_bdev grab an active reference and only the last
237 * thaw_bdev drops it.
239 sb = get_super(bdev);
240 drop_super(sb);
241 mutex_unlock(&bdev->bd_fsfreeze_mutex);
242 return sb;
245 sb = get_active_super(bdev);
246 if (!sb)
247 goto out;
248 if (sb->s_flags & MS_RDONLY) {
249 sb->s_frozen = SB_FREEZE_TRANS;
250 up_write(&sb->s_umount);
251 mutex_unlock(&bdev->bd_fsfreeze_mutex);
252 return sb;
255 sb->s_frozen = SB_FREEZE_WRITE;
256 smp_wmb();
258 sync_filesystem(sb);
260 sb->s_frozen = SB_FREEZE_TRANS;
261 smp_wmb();
263 sync_blockdev(sb->s_bdev);
265 if (sb->s_op->freeze_fs) {
266 error = sb->s_op->freeze_fs(sb);
267 if (error) {
268 printk(KERN_ERR
269 "VFS:Filesystem freeze failed\n");
270 sb->s_frozen = SB_UNFROZEN;
271 deactivate_locked_super(sb);
272 bdev->bd_fsfreeze_count--;
273 mutex_unlock(&bdev->bd_fsfreeze_mutex);
274 return ERR_PTR(error);
277 up_write(&sb->s_umount);
279 out:
280 sync_blockdev(bdev);
281 mutex_unlock(&bdev->bd_fsfreeze_mutex);
282 return sb; /* thaw_bdev releases s->s_umount */
284 EXPORT_SYMBOL(freeze_bdev);
287 * thaw_bdev -- unlock filesystem
288 * @bdev: blockdevice to unlock
289 * @sb: associated superblock
291 * Unlocks the filesystem and marks it writeable again after freeze_bdev().
293 int thaw_bdev(struct block_device *bdev, struct super_block *sb)
295 int error = -EINVAL;
297 mutex_lock(&bdev->bd_fsfreeze_mutex);
298 if (!bdev->bd_fsfreeze_count)
299 goto out_unlock;
301 error = 0;
302 if (--bdev->bd_fsfreeze_count > 0)
303 goto out_unlock;
305 if (!sb)
306 goto out_unlock;
308 BUG_ON(sb->s_bdev != bdev);
309 down_write(&sb->s_umount);
310 if (sb->s_flags & MS_RDONLY)
311 goto out_unfrozen;
313 if (sb->s_op->unfreeze_fs) {
314 error = sb->s_op->unfreeze_fs(sb);
315 if (error) {
316 printk(KERN_ERR
317 "VFS:Filesystem thaw failed\n");
318 sb->s_frozen = SB_FREEZE_TRANS;
319 bdev->bd_fsfreeze_count++;
320 mutex_unlock(&bdev->bd_fsfreeze_mutex);
321 return error;
325 out_unfrozen:
326 sb->s_frozen = SB_UNFROZEN;
327 smp_wmb();
328 wake_up(&sb->s_wait_unfrozen);
330 if (sb)
331 deactivate_locked_super(sb);
332 out_unlock:
333 mutex_unlock(&bdev->bd_fsfreeze_mutex);
334 return 0;
336 EXPORT_SYMBOL(thaw_bdev);
338 static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
340 return block_write_full_page(page, blkdev_get_block, wbc);
343 static int blkdev_readpage(struct file * file, struct page * page)
345 return block_read_full_page(page, blkdev_get_block);
348 static int blkdev_write_begin(struct file *file, struct address_space *mapping,
349 loff_t pos, unsigned len, unsigned flags,
350 struct page **pagep, void **fsdata)
352 *pagep = NULL;
353 return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
354 blkdev_get_block);
357 static int blkdev_write_end(struct file *file, struct address_space *mapping,
358 loff_t pos, unsigned len, unsigned copied,
359 struct page *page, void *fsdata)
361 int ret;
362 ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
364 unlock_page(page);
365 page_cache_release(page);
367 return ret;
371 * private llseek:
372 * for a block special file file->f_path.dentry->d_inode->i_size is zero
373 * so we compute the size by hand (just as in block_read/write above)
375 static loff_t block_llseek(struct file *file, loff_t offset, int origin)
377 struct inode *bd_inode = file->f_mapping->host;
378 loff_t size;
379 loff_t retval;
381 mutex_lock(&bd_inode->i_mutex);
382 size = i_size_read(bd_inode);
384 switch (origin) {
385 case 2:
386 offset += size;
387 break;
388 case 1:
389 offset += file->f_pos;
391 retval = -EINVAL;
392 if (offset >= 0 && offset <= size) {
393 if (offset != file->f_pos) {
394 file->f_pos = offset;
396 retval = offset;
398 mutex_unlock(&bd_inode->i_mutex);
399 return retval;
403 * Filp is never NULL; the only case when ->fsync() is called with
404 * NULL first argument is nfsd_sync_dir() and that's not a directory.
407 int blkdev_fsync(struct file *filp, struct dentry *dentry, int datasync)
409 struct block_device *bdev = I_BDEV(filp->f_mapping->host);
410 int error;
412 error = sync_blockdev(bdev);
413 if (error)
414 return error;
416 error = blkdev_issue_flush(bdev, NULL);
417 if (error == -EOPNOTSUPP)
418 error = 0;
419 return error;
421 EXPORT_SYMBOL(blkdev_fsync);
424 * pseudo-fs
427 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
428 static struct kmem_cache * bdev_cachep __read_mostly;
430 static struct inode *bdev_alloc_inode(struct super_block *sb)
432 struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
433 if (!ei)
434 return NULL;
435 return &ei->vfs_inode;
438 static void bdev_destroy_inode(struct inode *inode)
440 struct bdev_inode *bdi = BDEV_I(inode);
442 kmem_cache_free(bdev_cachep, bdi);
445 static void init_once(void *foo)
447 struct bdev_inode *ei = (struct bdev_inode *) foo;
448 struct block_device *bdev = &ei->bdev;
450 memset(bdev, 0, sizeof(*bdev));
451 mutex_init(&bdev->bd_mutex);
452 INIT_LIST_HEAD(&bdev->bd_inodes);
453 INIT_LIST_HEAD(&bdev->bd_list);
454 #ifdef CONFIG_SYSFS
455 INIT_LIST_HEAD(&bdev->bd_holder_list);
456 #endif
457 inode_init_once(&ei->vfs_inode);
458 /* Initialize mutex for freeze. */
459 mutex_init(&bdev->bd_fsfreeze_mutex);
462 static inline void __bd_forget(struct inode *inode)
464 list_del_init(&inode->i_devices);
465 inode->i_bdev = NULL;
466 inode->i_mapping = &inode->i_data;
469 static void bdev_clear_inode(struct inode *inode)
471 struct block_device *bdev = &BDEV_I(inode)->bdev;
472 struct list_head *p;
473 spin_lock(&bdev_lock);
474 while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
475 __bd_forget(list_entry(p, struct inode, i_devices));
477 list_del_init(&bdev->bd_list);
478 spin_unlock(&bdev_lock);
481 static const struct super_operations bdev_sops = {
482 .statfs = simple_statfs,
483 .alloc_inode = bdev_alloc_inode,
484 .destroy_inode = bdev_destroy_inode,
485 .drop_inode = generic_delete_inode,
486 .clear_inode = bdev_clear_inode,
489 static int bd_get_sb(struct file_system_type *fs_type,
490 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
492 return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
495 static struct file_system_type bd_type = {
496 .name = "bdev",
497 .get_sb = bd_get_sb,
498 .kill_sb = kill_anon_super,
501 struct super_block *blockdev_superblock __read_mostly;
503 void __init bdev_cache_init(void)
505 int err;
506 struct vfsmount *bd_mnt;
508 bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
509 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
510 SLAB_MEM_SPREAD|SLAB_PANIC),
511 init_once);
512 err = register_filesystem(&bd_type);
513 if (err)
514 panic("Cannot register bdev pseudo-fs");
515 bd_mnt = kern_mount(&bd_type);
516 if (IS_ERR(bd_mnt))
517 panic("Cannot create bdev pseudo-fs");
519 * This vfsmount structure is only used to obtain the
520 * blockdev_superblock, so tell kmemleak not to report it.
522 kmemleak_not_leak(bd_mnt);
523 blockdev_superblock = bd_mnt->mnt_sb; /* For writeback */
527 * Most likely _very_ bad one - but then it's hardly critical for small
528 * /dev and can be fixed when somebody will need really large one.
529 * Keep in mind that it will be fed through icache hash function too.
531 static inline unsigned long hash(dev_t dev)
533 return MAJOR(dev)+MINOR(dev);
536 static int bdev_test(struct inode *inode, void *data)
538 return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
541 static int bdev_set(struct inode *inode, void *data)
543 BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
544 return 0;
547 static LIST_HEAD(all_bdevs);
549 struct block_device *bdget(dev_t dev)
551 struct block_device *bdev;
552 struct inode *inode;
554 inode = iget5_locked(blockdev_superblock, hash(dev),
555 bdev_test, bdev_set, &dev);
557 if (!inode)
558 return NULL;
560 bdev = &BDEV_I(inode)->bdev;
562 if (inode->i_state & I_NEW) {
563 bdev->bd_contains = NULL;
564 bdev->bd_inode = inode;
565 bdev->bd_block_size = (1 << inode->i_blkbits);
566 bdev->bd_part_count = 0;
567 bdev->bd_invalidated = 0;
568 inode->i_mode = S_IFBLK;
569 inode->i_rdev = dev;
570 inode->i_bdev = bdev;
571 inode->i_data.a_ops = &def_blk_aops;
572 mapping_set_gfp_mask(&inode->i_data, GFP_USER);
573 inode->i_data.backing_dev_info = &default_backing_dev_info;
574 spin_lock(&bdev_lock);
575 list_add(&bdev->bd_list, &all_bdevs);
576 spin_unlock(&bdev_lock);
577 unlock_new_inode(inode);
579 return bdev;
582 EXPORT_SYMBOL(bdget);
585 * bdgrab -- Grab a reference to an already referenced block device
586 * @bdev: Block device to grab a reference to.
588 struct block_device *bdgrab(struct block_device *bdev)
590 atomic_inc(&bdev->bd_inode->i_count);
591 return bdev;
594 long nr_blockdev_pages(void)
596 struct block_device *bdev;
597 long ret = 0;
598 spin_lock(&bdev_lock);
599 list_for_each_entry(bdev, &all_bdevs, bd_list) {
600 ret += bdev->bd_inode->i_mapping->nrpages;
602 spin_unlock(&bdev_lock);
603 return ret;
606 void bdput(struct block_device *bdev)
608 iput(bdev->bd_inode);
611 EXPORT_SYMBOL(bdput);
613 static struct block_device *bd_acquire(struct inode *inode)
615 struct block_device *bdev;
617 spin_lock(&bdev_lock);
618 bdev = inode->i_bdev;
619 if (bdev) {
620 atomic_inc(&bdev->bd_inode->i_count);
621 spin_unlock(&bdev_lock);
622 return bdev;
624 spin_unlock(&bdev_lock);
626 bdev = bdget(inode->i_rdev);
627 if (bdev) {
628 spin_lock(&bdev_lock);
629 if (!inode->i_bdev) {
631 * We take an additional bd_inode->i_count for inode,
632 * and it's released in clear_inode() of inode.
633 * So, we can access it via ->i_mapping always
634 * without igrab().
636 atomic_inc(&bdev->bd_inode->i_count);
637 inode->i_bdev = bdev;
638 inode->i_mapping = bdev->bd_inode->i_mapping;
639 list_add(&inode->i_devices, &bdev->bd_inodes);
641 spin_unlock(&bdev_lock);
643 return bdev;
646 /* Call when you free inode */
648 void bd_forget(struct inode *inode)
650 struct block_device *bdev = NULL;
652 spin_lock(&bdev_lock);
653 if (inode->i_bdev) {
654 if (!sb_is_blkdev_sb(inode->i_sb))
655 bdev = inode->i_bdev;
656 __bd_forget(inode);
658 spin_unlock(&bdev_lock);
660 if (bdev)
661 iput(bdev->bd_inode);
664 int bd_claim(struct block_device *bdev, void *holder)
666 int res;
667 spin_lock(&bdev_lock);
669 /* first decide result */
670 if (bdev->bd_holder == holder)
671 res = 0; /* already a holder */
672 else if (bdev->bd_holder != NULL)
673 res = -EBUSY; /* held by someone else */
674 else if (bdev->bd_contains == bdev)
675 res = 0; /* is a whole device which isn't held */
677 else if (bdev->bd_contains->bd_holder == bd_claim)
678 res = 0; /* is a partition of a device that is being partitioned */
679 else if (bdev->bd_contains->bd_holder != NULL)
680 res = -EBUSY; /* is a partition of a held device */
681 else
682 res = 0; /* is a partition of an un-held device */
684 /* now impose change */
685 if (res==0) {
686 /* note that for a whole device bd_holders
687 * will be incremented twice, and bd_holder will
688 * be set to bd_claim before being set to holder
690 bdev->bd_contains->bd_holders ++;
691 bdev->bd_contains->bd_holder = bd_claim;
692 bdev->bd_holders++;
693 bdev->bd_holder = holder;
695 spin_unlock(&bdev_lock);
696 return res;
699 EXPORT_SYMBOL(bd_claim);
701 void bd_release(struct block_device *bdev)
703 spin_lock(&bdev_lock);
704 if (!--bdev->bd_contains->bd_holders)
705 bdev->bd_contains->bd_holder = NULL;
706 if (!--bdev->bd_holders)
707 bdev->bd_holder = NULL;
708 spin_unlock(&bdev_lock);
711 EXPORT_SYMBOL(bd_release);
713 #ifdef CONFIG_SYSFS
715 * Functions for bd_claim_by_kobject / bd_release_from_kobject
717 * If a kobject is passed to bd_claim_by_kobject()
718 * and the kobject has a parent directory,
719 * following symlinks are created:
720 * o from the kobject to the claimed bdev
721 * o from "holders" directory of the bdev to the parent of the kobject
722 * bd_release_from_kobject() removes these symlinks.
724 * Example:
725 * If /dev/dm-0 maps to /dev/sda, kobject corresponding to
726 * /sys/block/dm-0/slaves is passed to bd_claim_by_kobject(), then:
727 * /sys/block/dm-0/slaves/sda --> /sys/block/sda
728 * /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
731 static int add_symlink(struct kobject *from, struct kobject *to)
733 if (!from || !to)
734 return 0;
735 return sysfs_create_link(from, to, kobject_name(to));
738 static void del_symlink(struct kobject *from, struct kobject *to)
740 if (!from || !to)
741 return;
742 sysfs_remove_link(from, kobject_name(to));
746 * 'struct bd_holder' contains pointers to kobjects symlinked by
747 * bd_claim_by_kobject.
748 * It's connected to bd_holder_list which is protected by bdev->bd_sem.
750 struct bd_holder {
751 struct list_head list; /* chain of holders of the bdev */
752 int count; /* references from the holder */
753 struct kobject *sdir; /* holder object, e.g. "/block/dm-0/slaves" */
754 struct kobject *hdev; /* e.g. "/block/dm-0" */
755 struct kobject *hdir; /* e.g. "/block/sda/holders" */
756 struct kobject *sdev; /* e.g. "/block/sda" */
760 * Get references of related kobjects at once.
761 * Returns 1 on success. 0 on failure.
763 * Should call bd_holder_release_dirs() after successful use.
765 static int bd_holder_grab_dirs(struct block_device *bdev,
766 struct bd_holder *bo)
768 if (!bdev || !bo)
769 return 0;
771 bo->sdir = kobject_get(bo->sdir);
772 if (!bo->sdir)
773 return 0;
775 bo->hdev = kobject_get(bo->sdir->parent);
776 if (!bo->hdev)
777 goto fail_put_sdir;
779 bo->sdev = kobject_get(&part_to_dev(bdev->bd_part)->kobj);
780 if (!bo->sdev)
781 goto fail_put_hdev;
783 bo->hdir = kobject_get(bdev->bd_part->holder_dir);
784 if (!bo->hdir)
785 goto fail_put_sdev;
787 return 1;
789 fail_put_sdev:
790 kobject_put(bo->sdev);
791 fail_put_hdev:
792 kobject_put(bo->hdev);
793 fail_put_sdir:
794 kobject_put(bo->sdir);
796 return 0;
799 /* Put references of related kobjects at once. */
800 static void bd_holder_release_dirs(struct bd_holder *bo)
802 kobject_put(bo->hdir);
803 kobject_put(bo->sdev);
804 kobject_put(bo->hdev);
805 kobject_put(bo->sdir);
808 static struct bd_holder *alloc_bd_holder(struct kobject *kobj)
810 struct bd_holder *bo;
812 bo = kzalloc(sizeof(*bo), GFP_KERNEL);
813 if (!bo)
814 return NULL;
816 bo->count = 1;
817 bo->sdir = kobj;
819 return bo;
822 static void free_bd_holder(struct bd_holder *bo)
824 kfree(bo);
828 * find_bd_holder - find matching struct bd_holder from the block device
830 * @bdev: struct block device to be searched
831 * @bo: target struct bd_holder
833 * Returns matching entry with @bo in @bdev->bd_holder_list.
834 * If found, increment the reference count and return the pointer.
835 * If not found, returns NULL.
837 static struct bd_holder *find_bd_holder(struct block_device *bdev,
838 struct bd_holder *bo)
840 struct bd_holder *tmp;
842 list_for_each_entry(tmp, &bdev->bd_holder_list, list)
843 if (tmp->sdir == bo->sdir) {
844 tmp->count++;
845 return tmp;
848 return NULL;
852 * add_bd_holder - create sysfs symlinks for bd_claim() relationship
854 * @bdev: block device to be bd_claimed
855 * @bo: preallocated and initialized by alloc_bd_holder()
857 * Add @bo to @bdev->bd_holder_list, create symlinks.
859 * Returns 0 if symlinks are created.
860 * Returns -ve if something fails.
862 static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
864 int err;
866 if (!bo)
867 return -EINVAL;
869 if (!bd_holder_grab_dirs(bdev, bo))
870 return -EBUSY;
872 err = add_symlink(bo->sdir, bo->sdev);
873 if (err)
874 return err;
876 err = add_symlink(bo->hdir, bo->hdev);
877 if (err) {
878 del_symlink(bo->sdir, bo->sdev);
879 return err;
882 list_add_tail(&bo->list, &bdev->bd_holder_list);
883 return 0;
887 * del_bd_holder - delete sysfs symlinks for bd_claim() relationship
889 * @bdev: block device to be bd_claimed
890 * @kobj: holder's kobject
892 * If there is matching entry with @kobj in @bdev->bd_holder_list
893 * and no other bd_claim() from the same kobject,
894 * remove the struct bd_holder from the list, delete symlinks for it.
896 * Returns a pointer to the struct bd_holder when it's removed from the list
897 * and ready to be freed.
898 * Returns NULL if matching claim isn't found or there is other bd_claim()
899 * by the same kobject.
901 static struct bd_holder *del_bd_holder(struct block_device *bdev,
902 struct kobject *kobj)
904 struct bd_holder *bo;
906 list_for_each_entry(bo, &bdev->bd_holder_list, list) {
907 if (bo->sdir == kobj) {
908 bo->count--;
909 BUG_ON(bo->count < 0);
910 if (!bo->count) {
911 list_del(&bo->list);
912 del_symlink(bo->sdir, bo->sdev);
913 del_symlink(bo->hdir, bo->hdev);
914 bd_holder_release_dirs(bo);
915 return bo;
917 break;
921 return NULL;
925 * bd_claim_by_kobject - bd_claim() with additional kobject signature
927 * @bdev: block device to be claimed
928 * @holder: holder's signature
929 * @kobj: holder's kobject
931 * Do bd_claim() and if it succeeds, create sysfs symlinks between
932 * the bdev and the holder's kobject.
933 * Use bd_release_from_kobject() when relesing the claimed bdev.
935 * Returns 0 on success. (same as bd_claim())
936 * Returns errno on failure.
938 static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
939 struct kobject *kobj)
941 int err;
942 struct bd_holder *bo, *found;
944 if (!kobj)
945 return -EINVAL;
947 bo = alloc_bd_holder(kobj);
948 if (!bo)
949 return -ENOMEM;
951 mutex_lock(&bdev->bd_mutex);
953 err = bd_claim(bdev, holder);
954 if (err)
955 goto fail;
957 found = find_bd_holder(bdev, bo);
958 if (found)
959 goto fail;
961 err = add_bd_holder(bdev, bo);
962 if (err)
963 bd_release(bdev);
964 else
965 bo = NULL;
966 fail:
967 mutex_unlock(&bdev->bd_mutex);
968 free_bd_holder(bo);
969 return err;
973 * bd_release_from_kobject - bd_release() with additional kobject signature
975 * @bdev: block device to be released
976 * @kobj: holder's kobject
978 * Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().
980 static void bd_release_from_kobject(struct block_device *bdev,
981 struct kobject *kobj)
983 if (!kobj)
984 return;
986 mutex_lock(&bdev->bd_mutex);
987 bd_release(bdev);
988 free_bd_holder(del_bd_holder(bdev, kobj));
989 mutex_unlock(&bdev->bd_mutex);
993 * bd_claim_by_disk - wrapper function for bd_claim_by_kobject()
995 * @bdev: block device to be claimed
996 * @holder: holder's signature
997 * @disk: holder's gendisk
999 * Call bd_claim_by_kobject() with getting @disk->slave_dir.
1001 int bd_claim_by_disk(struct block_device *bdev, void *holder,
1002 struct gendisk *disk)
1004 return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));
1006 EXPORT_SYMBOL_GPL(bd_claim_by_disk);
1009 * bd_release_from_disk - wrapper function for bd_release_from_kobject()
1011 * @bdev: block device to be claimed
1012 * @disk: holder's gendisk
1014 * Call bd_release_from_kobject() and put @disk->slave_dir.
1016 void bd_release_from_disk(struct block_device *bdev, struct gendisk *disk)
1018 bd_release_from_kobject(bdev, disk->slave_dir);
1019 kobject_put(disk->slave_dir);
1021 EXPORT_SYMBOL_GPL(bd_release_from_disk);
1022 #endif
1025 * Tries to open block device by device number. Use it ONLY if you
1026 * really do not have anything better - i.e. when you are behind a
1027 * truly sucky interface and all you are given is a device number. _Never_
1028 * to be used for internal purposes. If you ever need it - reconsider
1029 * your API.
1031 struct block_device *open_by_devnum(dev_t dev, fmode_t mode)
1033 struct block_device *bdev = bdget(dev);
1034 int err = -ENOMEM;
1035 if (bdev)
1036 err = blkdev_get(bdev, mode);
1037 return err ? ERR_PTR(err) : bdev;
1040 EXPORT_SYMBOL(open_by_devnum);
1043 * flush_disk - invalidates all buffer-cache entries on a disk
1045 * @bdev: struct block device to be flushed
1047 * Invalidates all buffer-cache entries on a disk. It should be called
1048 * when a disk has been changed -- either by a media change or online
1049 * resize.
1051 static void flush_disk(struct block_device *bdev)
1053 if (__invalidate_device(bdev)) {
1054 char name[BDEVNAME_SIZE] = "";
1056 if (bdev->bd_disk)
1057 disk_name(bdev->bd_disk, 0, name);
1058 printk(KERN_WARNING "VFS: busy inodes on changed media or "
1059 "resized disk %s\n", name);
1062 if (!bdev->bd_disk)
1063 return;
1064 if (disk_partitionable(bdev->bd_disk))
1065 bdev->bd_invalidated = 1;
1069 * check_disk_size_change - checks for disk size change and adjusts bdev size.
1070 * @disk: struct gendisk to check
1071 * @bdev: struct bdev to adjust.
1073 * This routine checks to see if the bdev size does not match the disk size
1074 * and adjusts it if it differs.
1076 void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
1078 loff_t disk_size, bdev_size;
1080 disk_size = (loff_t)get_capacity(disk) << 9;
1081 bdev_size = i_size_read(bdev->bd_inode);
1082 if (disk_size != bdev_size) {
1083 char name[BDEVNAME_SIZE];
1085 disk_name(disk, 0, name);
1086 printk(KERN_INFO
1087 "%s: detected capacity change from %lld to %lld\n",
1088 name, bdev_size, disk_size);
1089 i_size_write(bdev->bd_inode, disk_size);
1090 flush_disk(bdev);
1093 EXPORT_SYMBOL(check_disk_size_change);
1096 * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
1097 * @disk: struct gendisk to be revalidated
1099 * This routine is a wrapper for lower-level driver's revalidate_disk
1100 * call-backs. It is used to do common pre and post operations needed
1101 * for all revalidate_disk operations.
1103 int revalidate_disk(struct gendisk *disk)
1105 struct block_device *bdev;
1106 int ret = 0;
1108 if (disk->fops->revalidate_disk)
1109 ret = disk->fops->revalidate_disk(disk);
1111 bdev = bdget_disk(disk, 0);
1112 if (!bdev)
1113 return ret;
1115 mutex_lock(&bdev->bd_mutex);
1116 check_disk_size_change(disk, bdev);
1117 mutex_unlock(&bdev->bd_mutex);
1118 bdput(bdev);
1119 return ret;
1121 EXPORT_SYMBOL(revalidate_disk);
1124 * This routine checks whether a removable media has been changed,
1125 * and invalidates all buffer-cache-entries in that case. This
1126 * is a relatively slow routine, so we have to try to minimize using
1127 * it. Thus it is called only upon a 'mount' or 'open'. This
1128 * is the best way of combining speed and utility, I think.
1129 * People changing diskettes in the middle of an operation deserve
1130 * to lose :-)
1132 int check_disk_change(struct block_device *bdev)
1134 struct gendisk *disk = bdev->bd_disk;
1135 const struct block_device_operations *bdops = disk->fops;
1137 if (!bdops->media_changed)
1138 return 0;
1139 if (!bdops->media_changed(bdev->bd_disk))
1140 return 0;
1142 flush_disk(bdev);
1143 if (bdops->revalidate_disk)
1144 bdops->revalidate_disk(bdev->bd_disk);
1145 return 1;
1148 EXPORT_SYMBOL(check_disk_change);
1150 void bd_set_size(struct block_device *bdev, loff_t size)
1152 unsigned bsize = bdev_logical_block_size(bdev);
1154 bdev->bd_inode->i_size = size;
1155 while (bsize < PAGE_CACHE_SIZE) {
1156 if (size & bsize)
1157 break;
1158 bsize <<= 1;
1160 bdev->bd_block_size = bsize;
1161 bdev->bd_inode->i_blkbits = blksize_bits(bsize);
1163 EXPORT_SYMBOL(bd_set_size);
1165 static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
1168 * bd_mutex locking:
1170 * mutex_lock(part->bd_mutex)
1171 * mutex_lock_nested(whole->bd_mutex, 1)
1174 static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
1176 struct gendisk *disk;
1177 int ret;
1178 int partno;
1179 int perm = 0;
1181 if (mode & FMODE_READ)
1182 perm |= MAY_READ;
1183 if (mode & FMODE_WRITE)
1184 perm |= MAY_WRITE;
1186 * hooks: /n/, see "layering violations".
1188 ret = devcgroup_inode_permission(bdev->bd_inode, perm);
1189 if (ret != 0) {
1190 bdput(bdev);
1191 return ret;
1194 lock_kernel();
1195 restart:
1197 ret = -ENXIO;
1198 disk = get_gendisk(bdev->bd_dev, &partno);
1199 if (!disk)
1200 goto out_unlock_kernel;
1202 mutex_lock_nested(&bdev->bd_mutex, for_part);
1203 if (!bdev->bd_openers) {
1204 bdev->bd_disk = disk;
1205 bdev->bd_contains = bdev;
1206 if (!partno) {
1207 struct backing_dev_info *bdi;
1209 ret = -ENXIO;
1210 bdev->bd_part = disk_get_part(disk, partno);
1211 if (!bdev->bd_part)
1212 goto out_clear;
1214 if (disk->fops->open) {
1215 ret = disk->fops->open(bdev, mode);
1216 if (ret == -ERESTARTSYS) {
1217 /* Lost a race with 'disk' being
1218 * deleted, try again.
1219 * See md.c
1221 disk_put_part(bdev->bd_part);
1222 bdev->bd_part = NULL;
1223 module_put(disk->fops->owner);
1224 put_disk(disk);
1225 bdev->bd_disk = NULL;
1226 mutex_unlock(&bdev->bd_mutex);
1227 goto restart;
1229 if (ret)
1230 goto out_clear;
1232 if (!bdev->bd_openers) {
1233 bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
1234 bdi = blk_get_backing_dev_info(bdev);
1235 if (bdi == NULL)
1236 bdi = &default_backing_dev_info;
1237 bdev->bd_inode->i_data.backing_dev_info = bdi;
1239 if (bdev->bd_invalidated)
1240 rescan_partitions(disk, bdev);
1241 } else {
1242 struct block_device *whole;
1243 whole = bdget_disk(disk, 0);
1244 ret = -ENOMEM;
1245 if (!whole)
1246 goto out_clear;
1247 BUG_ON(for_part);
1248 ret = __blkdev_get(whole, mode, 1);
1249 if (ret)
1250 goto out_clear;
1251 bdev->bd_contains = whole;
1252 bdev->bd_inode->i_data.backing_dev_info =
1253 whole->bd_inode->i_data.backing_dev_info;
1254 bdev->bd_part = disk_get_part(disk, partno);
1255 if (!(disk->flags & GENHD_FL_UP) ||
1256 !bdev->bd_part || !bdev->bd_part->nr_sects) {
1257 ret = -ENXIO;
1258 goto out_clear;
1260 bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
1262 } else {
1263 module_put(disk->fops->owner);
1264 put_disk(disk);
1265 disk = NULL;
1266 if (bdev->bd_contains == bdev) {
1267 if (bdev->bd_disk->fops->open) {
1268 ret = bdev->bd_disk->fops->open(bdev, mode);
1269 if (ret)
1270 goto out_unlock_bdev;
1272 if (bdev->bd_invalidated)
1273 rescan_partitions(bdev->bd_disk, bdev);
1276 bdev->bd_openers++;
1277 if (for_part)
1278 bdev->bd_part_count++;
1279 mutex_unlock(&bdev->bd_mutex);
1280 unlock_kernel();
1281 return 0;
1283 out_clear:
1284 disk_put_part(bdev->bd_part);
1285 bdev->bd_disk = NULL;
1286 bdev->bd_part = NULL;
1287 bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
1288 if (bdev != bdev->bd_contains)
1289 __blkdev_put(bdev->bd_contains, mode, 1);
1290 bdev->bd_contains = NULL;
1291 out_unlock_bdev:
1292 mutex_unlock(&bdev->bd_mutex);
1293 out_unlock_kernel:
1294 unlock_kernel();
1296 if (disk)
1297 module_put(disk->fops->owner);
1298 put_disk(disk);
1299 bdput(bdev);
1301 return ret;
1304 int blkdev_get(struct block_device *bdev, fmode_t mode)
1306 return __blkdev_get(bdev, mode, 0);
1308 EXPORT_SYMBOL(blkdev_get);
1310 static int blkdev_open(struct inode * inode, struct file * filp)
1312 struct block_device *bdev;
1313 int res;
1316 * Preserve backwards compatibility and allow large file access
1317 * even if userspace doesn't ask for it explicitly. Some mkfs
1318 * binary needs it. We might want to drop this workaround
1319 * during an unstable branch.
1321 filp->f_flags |= O_LARGEFILE;
1323 if (filp->f_flags & O_NDELAY)
1324 filp->f_mode |= FMODE_NDELAY;
1325 if (filp->f_flags & O_EXCL)
1326 filp->f_mode |= FMODE_EXCL;
1327 if ((filp->f_flags & O_ACCMODE) == 3)
1328 filp->f_mode |= FMODE_WRITE_IOCTL;
1330 bdev = bd_acquire(inode);
1331 if (bdev == NULL)
1332 return -ENOMEM;
1334 filp->f_mapping = bdev->bd_inode->i_mapping;
1336 res = blkdev_get(bdev, filp->f_mode);
1337 if (res)
1338 return res;
1340 if (filp->f_mode & FMODE_EXCL) {
1341 res = bd_claim(bdev, filp);
1342 if (res)
1343 goto out_blkdev_put;
1346 return 0;
1348 out_blkdev_put:
1349 blkdev_put(bdev, filp->f_mode);
1350 return res;
1353 static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
1355 int ret = 0;
1356 struct gendisk *disk = bdev->bd_disk;
1357 struct block_device *victim = NULL;
1359 mutex_lock_nested(&bdev->bd_mutex, for_part);
1360 lock_kernel();
1361 if (for_part)
1362 bdev->bd_part_count--;
1364 if (!--bdev->bd_openers) {
1365 sync_blockdev(bdev);
1366 kill_bdev(bdev);
1368 if (bdev->bd_contains == bdev) {
1369 if (disk->fops->release)
1370 ret = disk->fops->release(disk, mode);
1372 if (!bdev->bd_openers) {
1373 struct module *owner = disk->fops->owner;
1375 put_disk(disk);
1376 module_put(owner);
1377 disk_put_part(bdev->bd_part);
1378 bdev->bd_part = NULL;
1379 bdev->bd_disk = NULL;
1380 bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
1381 if (bdev != bdev->bd_contains)
1382 victim = bdev->bd_contains;
1383 bdev->bd_contains = NULL;
1385 unlock_kernel();
1386 mutex_unlock(&bdev->bd_mutex);
1387 bdput(bdev);
1388 if (victim)
1389 __blkdev_put(victim, mode, 1);
1390 return ret;
1393 int blkdev_put(struct block_device *bdev, fmode_t mode)
1395 return __blkdev_put(bdev, mode, 0);
1397 EXPORT_SYMBOL(blkdev_put);
1399 static int blkdev_close(struct inode * inode, struct file * filp)
1401 struct block_device *bdev = I_BDEV(filp->f_mapping->host);
1402 if (bdev->bd_holder == filp)
1403 bd_release(bdev);
1404 return blkdev_put(bdev, filp->f_mode);
1407 static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1409 struct block_device *bdev = I_BDEV(file->f_mapping->host);
1410 fmode_t mode = file->f_mode;
1413 * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
1414 * to updated it before every ioctl.
1416 if (file->f_flags & O_NDELAY)
1417 mode |= FMODE_NDELAY;
1418 else
1419 mode &= ~FMODE_NDELAY;
1421 return blkdev_ioctl(bdev, mode, cmd, arg);
1425 * Write data to the block device. Only intended for the block device itself
1426 * and the raw driver which basically is a fake block device.
1428 * Does not take i_mutex for the write and thus is not for general purpose
1429 * use.
1431 ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
1432 unsigned long nr_segs, loff_t pos)
1434 struct file *file = iocb->ki_filp;
1435 ssize_t ret;
1437 BUG_ON(iocb->ki_pos != pos);
1439 ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
1440 if (ret > 0 || ret == -EIOCBQUEUED) {
1441 ssize_t err;
1443 err = generic_write_sync(file, pos, ret);
1444 if (err < 0 && ret > 0)
1445 ret = err;
1447 return ret;
1449 EXPORT_SYMBOL_GPL(blkdev_aio_write);
1452 * Try to release a page associated with block device when the system
1453 * is under memory pressure.
1455 static int blkdev_releasepage(struct page *page, gfp_t wait)
1457 struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
1459 if (super && super->s_op->bdev_try_to_free_page)
1460 return super->s_op->bdev_try_to_free_page(super, page, wait);
1462 return try_to_free_buffers(page);
1465 static const struct address_space_operations def_blk_aops = {
1466 .readpage = blkdev_readpage,
1467 .writepage = blkdev_writepage,
1468 .sync_page = block_sync_page,
1469 .write_begin = blkdev_write_begin,
1470 .write_end = blkdev_write_end,
1471 .writepages = generic_writepages,
1472 .releasepage = blkdev_releasepage,
1473 .direct_IO = blkdev_direct_IO,
1476 const struct file_operations def_blk_fops = {
1477 .open = blkdev_open,
1478 .release = blkdev_close,
1479 .llseek = block_llseek,
1480 .read = do_sync_read,
1481 .write = do_sync_write,
1482 .aio_read = generic_file_aio_read,
1483 .aio_write = blkdev_aio_write,
1484 .mmap = generic_file_mmap,
1485 .fsync = blkdev_fsync,
1486 .unlocked_ioctl = block_ioctl,
1487 #ifdef CONFIG_COMPAT
1488 .compat_ioctl = compat_blkdev_ioctl,
1489 #endif
1490 .splice_read = generic_file_splice_read,
1491 .splice_write = generic_file_splice_write,
1494 int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
1496 int res;
1497 mm_segment_t old_fs = get_fs();
1498 set_fs(KERNEL_DS);
1499 res = blkdev_ioctl(bdev, 0, cmd, arg);
1500 set_fs(old_fs);
1501 return res;
1504 EXPORT_SYMBOL(ioctl_by_bdev);
1507 * lookup_bdev - lookup a struct block_device by name
1508 * @pathname: special file representing the block device
1510 * Get a reference to the blockdevice at @pathname in the current
1511 * namespace if possible and return it. Return ERR_PTR(error)
1512 * otherwise.
1514 struct block_device *lookup_bdev(const char *pathname)
1516 struct block_device *bdev;
1517 struct inode *inode;
1518 struct path path;
1519 int error;
1521 if (!pathname || !*pathname)
1522 return ERR_PTR(-EINVAL);
1524 error = kern_path(pathname, LOOKUP_FOLLOW, &path);
1525 if (error)
1526 return ERR_PTR(error);
1528 inode = path.dentry->d_inode;
1529 error = -ENOTBLK;
1530 if (!S_ISBLK(inode->i_mode))
1531 goto fail;
1532 error = -EACCES;
1533 if (path.mnt->mnt_flags & MNT_NODEV)
1534 goto fail;
1535 error = -ENOMEM;
1536 bdev = bd_acquire(inode);
1537 if (!bdev)
1538 goto fail;
1539 out:
1540 path_put(&path);
1541 return bdev;
1542 fail:
1543 bdev = ERR_PTR(error);
1544 goto out;
1546 EXPORT_SYMBOL(lookup_bdev);
1549 * open_bdev_exclusive - open a block device by name and set it up for use
1551 * @path: special file representing the block device
1552 * @mode: FMODE_... combination to pass be used
1553 * @holder: owner for exclusion
1555 * Open the blockdevice described by the special file at @path, claim it
1556 * for the @holder.
1558 struct block_device *open_bdev_exclusive(const char *path, fmode_t mode, void *holder)
1560 struct block_device *bdev;
1561 int error = 0;
1563 bdev = lookup_bdev(path);
1564 if (IS_ERR(bdev))
1565 return bdev;
1567 error = blkdev_get(bdev, mode);
1568 if (error)
1569 return ERR_PTR(error);
1570 error = -EACCES;
1571 if ((mode & FMODE_WRITE) && bdev_read_only(bdev))
1572 goto blkdev_put;
1573 error = bd_claim(bdev, holder);
1574 if (error)
1575 goto blkdev_put;
1577 return bdev;
1579 blkdev_put:
1580 blkdev_put(bdev, mode);
1581 return ERR_PTR(error);
1584 EXPORT_SYMBOL(open_bdev_exclusive);
1587 * close_bdev_exclusive - close a blockdevice opened by open_bdev_exclusive()
1589 * @bdev: blockdevice to close
1590 * @mode: mode, must match that used to open.
1592 * This is the counterpart to open_bdev_exclusive().
1594 void close_bdev_exclusive(struct block_device *bdev, fmode_t mode)
1596 bd_release(bdev);
1597 blkdev_put(bdev, mode);
1600 EXPORT_SYMBOL(close_bdev_exclusive);
1602 int __invalidate_device(struct block_device *bdev)
1604 struct super_block *sb = get_super(bdev);
1605 int res = 0;
1607 if (sb) {
1609 * no need to lock the super, get_super holds the
1610 * read mutex so the filesystem cannot go away
1611 * under us (->put_super runs with the write lock
1612 * hold).
1614 shrink_dcache_sb(sb);
1615 res = invalidate_inodes(sb);
1616 drop_super(sb);
1618 invalidate_bdev(bdev);
1619 return res;
1621 EXPORT_SYMBOL(__invalidate_device);