Root/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/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"
31
32struct bdev_inode {
33    struct block_device bdev;
34    struct inode vfs_inode;
35};
36
37static const struct address_space_operations def_blk_aops;
38
39static inline struct bdev_inode *BDEV_I(struct inode *inode)
40{
41    return container_of(inode, struct bdev_inode, vfs_inode);
42}
43
44inline struct block_device *I_BDEV(struct inode *inode)
45{
46    return &BDEV_I(inode)->bdev;
47}
48
49EXPORT_SYMBOL(I_BDEV);
50
51static sector_t max_block(struct block_device *bdev)
52{
53    sector_t retval = ~((sector_t)0);
54    loff_t sz = i_size_read(bdev->bd_inode);
55
56    if (sz) {
57        unsigned int size = block_size(bdev);
58        unsigned int sizebits = blksize_bits(size);
59        retval = (sz >> sizebits);
60    }
61    return retval;
62}
63
64/* Kill _all_ buffers and pagecache , dirty or not.. */
65static void kill_bdev(struct block_device *bdev)
66{
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);
71}
72
73int set_blocksize(struct block_device *bdev, int size)
74{
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;
78
79    /* Size cannot be smaller than the size supported by the device */
80    if (size < bdev_logical_block_size(bdev))
81        return -EINVAL;
82
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);
89    }
90    return 0;
91}
92
93EXPORT_SYMBOL(set_blocksize);
94
95int sb_set_blocksize(struct super_block *sb, int size)
96{
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;
104}
105
106EXPORT_SYMBOL(sb_set_blocksize);
107
108int sb_min_blocksize(struct super_block *sb, int size)
109{
110    int minsize = bdev_logical_block_size(sb->s_bdev);
111    if (size < minsize)
112        size = minsize;
113    return sb_set_blocksize(sb, size);
114}
115
116EXPORT_SYMBOL(sb_min_blocksize);
117
118static int
119blkdev_get_block(struct inode *inode, sector_t iblock,
120        struct buffer_head *bh, int create)
121{
122    if (iblock >= max_block(I_BDEV(inode))) {
123        if (create)
124            return -EIO;
125
126        /*
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
131         */
132        return 0;
133    }
134    bh->b_bdev = I_BDEV(inode);
135    bh->b_blocknr = iblock;
136    set_buffer_mapped(bh);
137    return 0;
138}
139
140static int
141blkdev_get_blocks(struct inode *inode, sector_t iblock,
142        struct buffer_head *bh, int create)
143{
144    sector_t end_block = max_block(I_BDEV(inode));
145    unsigned long max_blocks = bh->b_size >> inode->i_blkbits;
146
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 */
152            /*
153             * It is a read which is fully beyond EOF. We return
154             * a !buffer_mapped buffer
155             */
156            max_blocks = 0;
157        }
158    }
159
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;
166}
167
168static ssize_t
169blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
170            loff_t offset, unsigned long nr_segs)
171{
172    struct file *file = iocb->ki_filp;
173    struct inode *inode = file->f_mapping->host;
174
175    return blockdev_direct_IO_no_locking(rw, iocb, inode, I_BDEV(inode),
176                iov, offset, nr_segs, blkdev_get_blocks, NULL);
177}
178
179int __sync_blockdev(struct block_device *bdev, int wait)
180{
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);
186}
187
188/*
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.
191 */
192int sync_blockdev(struct block_device *bdev)
193{
194    return __sync_blockdev(bdev, 1);
195}
196EXPORT_SYMBOL(sync_blockdev);
197
198/*
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.
202 */
203int fsync_bdev(struct block_device *bdev)
204{
205    struct super_block *sb = get_super(bdev);
206    if (sb) {
207        int res = sync_filesystem(sb);
208        drop_super(sb);
209        return res;
210    }
211    return sync_blockdev(bdev);
212}
213EXPORT_SYMBOL(fsync_bdev);
214
215/**
216 * freeze_bdev -- lock a filesystem and force it into a consistent state
217 * @bdev: blockdevice to lock
218 *
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.
226 */
227struct super_block *freeze_bdev(struct block_device *bdev)
228{
229    struct super_block *sb;
230    int error = 0;
231
232    mutex_lock(&bdev->bd_fsfreeze_mutex);
233    if (++bdev->bd_fsfreeze_count > 1) {
234        /*
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.
238         */
239        sb = get_super(bdev);
240        drop_super(sb);
241        mutex_unlock(&bdev->bd_fsfreeze_mutex);
242        return sb;
243    }
244
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;
253    }
254
255    sb->s_frozen = SB_FREEZE_WRITE;
256    smp_wmb();
257
258    sync_filesystem(sb);
259
260    sb->s_frozen = SB_FREEZE_TRANS;
261    smp_wmb();
262
263    sync_blockdev(sb->s_bdev);
264
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);
275        }
276    }
277    up_write(&sb->s_umount);
278
279 out:
280    sync_blockdev(bdev);
281    mutex_unlock(&bdev->bd_fsfreeze_mutex);
282    return sb; /* thaw_bdev releases s->s_umount */
283}
284EXPORT_SYMBOL(freeze_bdev);
285
286/**
287 * thaw_bdev -- unlock filesystem
288 * @bdev: blockdevice to unlock
289 * @sb: associated superblock
290 *
291 * Unlocks the filesystem and marks it writeable again after freeze_bdev().
292 */
293int thaw_bdev(struct block_device *bdev, struct super_block *sb)
294{
295    int error = -EINVAL;
296
297    mutex_lock(&bdev->bd_fsfreeze_mutex);
298    if (!bdev->bd_fsfreeze_count)
299        goto out_unlock;
300
301    error = 0;
302    if (--bdev->bd_fsfreeze_count > 0)
303        goto out_unlock;
304
305    if (!sb)
306        goto out_unlock;
307
308    BUG_ON(sb->s_bdev != bdev);
309    down_write(&sb->s_umount);
310    if (sb->s_flags & MS_RDONLY)
311        goto out_unfrozen;
312
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;
322        }
323    }
324
325out_unfrozen:
326    sb->s_frozen = SB_UNFROZEN;
327    smp_wmb();
328    wake_up(&sb->s_wait_unfrozen);
329
330    if (sb)
331        deactivate_locked_super(sb);
332out_unlock:
333    mutex_unlock(&bdev->bd_fsfreeze_mutex);
334    return 0;
335}
336EXPORT_SYMBOL(thaw_bdev);
337
338static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
339{
340    return block_write_full_page(page, blkdev_get_block, wbc);
341}
342
343static int blkdev_readpage(struct file * file, struct page * page)
344{
345    return block_read_full_page(page, blkdev_get_block);
346}
347
348static 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)
351{
352    *pagep = NULL;
353    return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
354                blkdev_get_block);
355}
356
357static 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)
360{
361    int ret;
362    ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
363
364    unlock_page(page);
365    page_cache_release(page);
366
367    return ret;
368}
369
370/*
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)
374 */
375static loff_t block_llseek(struct file *file, loff_t offset, int origin)
376{
377    struct inode *bd_inode = file->f_mapping->host;
378    loff_t size;
379    loff_t retval;
380
381    mutex_lock(&bd_inode->i_mutex);
382    size = i_size_read(bd_inode);
383
384    switch (origin) {
385        case 2:
386            offset += size;
387            break;
388        case 1:
389            offset += file->f_pos;
390    }
391    retval = -EINVAL;
392    if (offset >= 0 && offset <= size) {
393        if (offset != file->f_pos) {
394            file->f_pos = offset;
395        }
396        retval = offset;
397    }
398    mutex_unlock(&bd_inode->i_mutex);
399    return retval;
400}
401    
402/*
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.
405 */
406 
407int blkdev_fsync(struct file *filp, struct dentry *dentry, int datasync)
408{
409    struct block_device *bdev = I_BDEV(filp->f_mapping->host);
410    int error;
411
412    error = sync_blockdev(bdev);
413    if (error)
414        return error;
415    
416    error = blkdev_issue_flush(bdev, NULL);
417    if (error == -EOPNOTSUPP)
418        error = 0;
419    return error;
420}
421EXPORT_SYMBOL(blkdev_fsync);
422
423/*
424 * pseudo-fs
425 */
426
427static __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
428static struct kmem_cache * bdev_cachep __read_mostly;
429
430static struct inode *bdev_alloc_inode(struct super_block *sb)
431{
432    struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
433    if (!ei)
434        return NULL;
435    return &ei->vfs_inode;
436}
437
438static void bdev_destroy_inode(struct inode *inode)
439{
440    struct bdev_inode *bdi = BDEV_I(inode);
441
442    kmem_cache_free(bdev_cachep, bdi);
443}
444
445static void init_once(void *foo)
446{
447    struct bdev_inode *ei = (struct bdev_inode *) foo;
448    struct block_device *bdev = &ei->bdev;
449
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);
460}
461
462static inline void __bd_forget(struct inode *inode)
463{
464    list_del_init(&inode->i_devices);
465    inode->i_bdev = NULL;
466    inode->i_mapping = &inode->i_data;
467}
468
469static void bdev_clear_inode(struct inode *inode)
470{
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));
476    }
477    list_del_init(&bdev->bd_list);
478    spin_unlock(&bdev_lock);
479}
480
481static 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,
487};
488
489static int bd_get_sb(struct file_system_type *fs_type,
490    int flags, const char *dev_name, void *data, struct vfsmount *mnt)
491{
492    return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
493}
494
495static struct file_system_type bd_type = {
496    .name = "bdev",
497    .get_sb = bd_get_sb,
498    .kill_sb = kill_anon_super,
499};
500
501struct super_block *blockdev_superblock __read_mostly;
502
503void __init bdev_cache_init(void)
504{
505    int err;
506    struct vfsmount *bd_mnt;
507
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");
518    /*
519     * This vfsmount structure is only used to obtain the
520     * blockdev_superblock, so tell kmemleak not to report it.
521     */
522    kmemleak_not_leak(bd_mnt);
523    blockdev_superblock = bd_mnt->mnt_sb; /* For writeback */
524}
525
526/*
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.
530 */
531static inline unsigned long hash(dev_t dev)
532{
533    return MAJOR(dev)+MINOR(dev);
534}
535
536static int bdev_test(struct inode *inode, void *data)
537{
538    return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
539}
540
541static int bdev_set(struct inode *inode, void *data)
542{
543    BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
544    return 0;
545}
546
547static LIST_HEAD(all_bdevs);
548
549struct block_device *bdget(dev_t dev)
550{
551    struct block_device *bdev;
552    struct inode *inode;
553
554    inode = iget5_locked(blockdev_superblock, hash(dev),
555            bdev_test, bdev_set, &dev);
556
557    if (!inode)
558        return NULL;
559
560    bdev = &BDEV_I(inode)->bdev;
561
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);
578    }
579    return bdev;
580}
581
582EXPORT_SYMBOL(bdget);
583
584/**
585 * bdgrab -- Grab a reference to an already referenced block device
586 * @bdev: Block device to grab a reference to.
587 */
588struct block_device *bdgrab(struct block_device *bdev)
589{
590    atomic_inc(&bdev->bd_inode->i_count);
591    return bdev;
592}
593
594long nr_blockdev_pages(void)
595{
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;
601    }
602    spin_unlock(&bdev_lock);
603    return ret;
604}
605
606void bdput(struct block_device *bdev)
607{
608    iput(bdev->bd_inode);
609}
610
611EXPORT_SYMBOL(bdput);
612 
613static struct block_device *bd_acquire(struct inode *inode)
614{
615    struct block_device *bdev;
616
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;
623    }
624    spin_unlock(&bdev_lock);
625
626    bdev = bdget(inode->i_rdev);
627    if (bdev) {
628        spin_lock(&bdev_lock);
629        if (!inode->i_bdev) {
630            /*
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().
635             */
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);
640        }
641        spin_unlock(&bdev_lock);
642    }
643    return bdev;
644}
645
646/* Call when you free inode */
647
648void bd_forget(struct inode *inode)
649{
650    struct block_device *bdev = NULL;
651
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);
657    }
658    spin_unlock(&bdev_lock);
659
660    if (bdev)
661        iput(bdev->bd_inode);
662}
663
664int bd_claim(struct block_device *bdev, void *holder)
665{
666    int res;
667    spin_lock(&bdev_lock);
668
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 */
676
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 */
683
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
689         */
690        bdev->bd_contains->bd_holders ++;
691        bdev->bd_contains->bd_holder = bd_claim;
692        bdev->bd_holders++;
693        bdev->bd_holder = holder;
694    }
695    spin_unlock(&bdev_lock);
696    return res;
697}
698
699EXPORT_SYMBOL(bd_claim);
700
701void bd_release(struct block_device *bdev)
702{
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);
709}
710
711EXPORT_SYMBOL(bd_release);
712
713#ifdef CONFIG_SYSFS
714/*
715 * Functions for bd_claim_by_kobject / bd_release_from_kobject
716 *
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.
723 *
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
729 */
730
731static int add_symlink(struct kobject *from, struct kobject *to)
732{
733    if (!from || !to)
734        return 0;
735    return sysfs_create_link(from, to, kobject_name(to));
736}
737
738static void del_symlink(struct kobject *from, struct kobject *to)
739{
740    if (!from || !to)
741        return;
742    sysfs_remove_link(from, kobject_name(to));
743}
744
745/*
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.
749 */
750struct 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" */
757};
758
759/*
760 * Get references of related kobjects at once.
761 * Returns 1 on success. 0 on failure.
762 *
763 * Should call bd_holder_release_dirs() after successful use.
764 */
765static int bd_holder_grab_dirs(struct block_device *bdev,
766            struct bd_holder *bo)
767{
768    if (!bdev || !bo)
769        return 0;
770
771    bo->sdir = kobject_get(bo->sdir);
772    if (!bo->sdir)
773        return 0;
774
775    bo->hdev = kobject_get(bo->sdir->parent);
776    if (!bo->hdev)
777        goto fail_put_sdir;
778
779    bo->sdev = kobject_get(&part_to_dev(bdev->bd_part)->kobj);
780    if (!bo->sdev)
781        goto fail_put_hdev;
782
783    bo->hdir = kobject_get(bdev->bd_part->holder_dir);
784    if (!bo->hdir)
785        goto fail_put_sdev;
786
787    return 1;
788
789fail_put_sdev:
790    kobject_put(bo->sdev);
791fail_put_hdev:
792    kobject_put(bo->hdev);
793fail_put_sdir:
794    kobject_put(bo->sdir);
795
796    return 0;
797}
798
799/* Put references of related kobjects at once. */
800static void bd_holder_release_dirs(struct bd_holder *bo)
801{
802    kobject_put(bo->hdir);
803    kobject_put(bo->sdev);
804    kobject_put(bo->hdev);
805    kobject_put(bo->sdir);
806}
807
808static struct bd_holder *alloc_bd_holder(struct kobject *kobj)
809{
810    struct bd_holder *bo;
811
812    bo = kzalloc(sizeof(*bo), GFP_KERNEL);
813    if (!bo)
814        return NULL;
815
816    bo->count = 1;
817    bo->sdir = kobj;
818
819    return bo;
820}
821
822static void free_bd_holder(struct bd_holder *bo)
823{
824    kfree(bo);
825}
826
827/**
828 * find_bd_holder - find matching struct bd_holder from the block device
829 *
830 * @bdev: struct block device to be searched
831 * @bo: target struct bd_holder
832 *
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.
836 */
837static struct bd_holder *find_bd_holder(struct block_device *bdev,
838                    struct bd_holder *bo)
839{
840    struct bd_holder *tmp;
841
842    list_for_each_entry(tmp, &bdev->bd_holder_list, list)
843        if (tmp->sdir == bo->sdir) {
844            tmp->count++;
845            return tmp;
846        }
847
848    return NULL;
849}
850
851/**
852 * add_bd_holder - create sysfs symlinks for bd_claim() relationship
853 *
854 * @bdev: block device to be bd_claimed
855 * @bo: preallocated and initialized by alloc_bd_holder()
856 *
857 * Add @bo to @bdev->bd_holder_list, create symlinks.
858 *
859 * Returns 0 if symlinks are created.
860 * Returns -ve if something fails.
861 */
862static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
863{
864    int err;
865
866    if (!bo)
867        return -EINVAL;
868
869    if (!bd_holder_grab_dirs(bdev, bo))
870        return -EBUSY;
871
872    err = add_symlink(bo->sdir, bo->sdev);
873    if (err)
874        return err;
875
876    err = add_symlink(bo->hdir, bo->hdev);
877    if (err) {
878        del_symlink(bo->sdir, bo->sdev);
879        return err;
880    }
881
882    list_add_tail(&bo->list, &bdev->bd_holder_list);
883    return 0;
884}
885
886/**
887 * del_bd_holder - delete sysfs symlinks for bd_claim() relationship
888 *
889 * @bdev: block device to be bd_claimed
890 * @kobj: holder's kobject
891 *
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.
895 *
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.
900 */
901static struct bd_holder *del_bd_holder(struct block_device *bdev,
902                    struct kobject *kobj)
903{
904    struct bd_holder *bo;
905
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;
916            }
917            break;
918        }
919    }
920
921    return NULL;
922}
923
924/**
925 * bd_claim_by_kobject - bd_claim() with additional kobject signature
926 *
927 * @bdev: block device to be claimed
928 * @holder: holder's signature
929 * @kobj: holder's kobject
930 *
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.
934 *
935 * Returns 0 on success. (same as bd_claim())
936 * Returns errno on failure.
937 */
938static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
939                struct kobject *kobj)
940{
941    int err;
942    struct bd_holder *bo, *found;
943
944    if (!kobj)
945        return -EINVAL;
946
947    bo = alloc_bd_holder(kobj);
948    if (!bo)
949        return -ENOMEM;
950
951    mutex_lock(&bdev->bd_mutex);
952
953    err = bd_claim(bdev, holder);
954    if (err)
955        goto fail;
956
957    found = find_bd_holder(bdev, bo);
958    if (found)
959        goto fail;
960
961    err = add_bd_holder(bdev, bo);
962    if (err)
963        bd_release(bdev);
964    else
965        bo = NULL;
966fail:
967    mutex_unlock(&bdev->bd_mutex);
968    free_bd_holder(bo);
969    return err;
970}
971
972/**
973 * bd_release_from_kobject - bd_release() with additional kobject signature
974 *
975 * @bdev: block device to be released
976 * @kobj: holder's kobject
977 *
978 * Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().
979 */
980static void bd_release_from_kobject(struct block_device *bdev,
981                    struct kobject *kobj)
982{
983    if (!kobj)
984        return;
985
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);
990}
991
992/**
993 * bd_claim_by_disk - wrapper function for bd_claim_by_kobject()
994 *
995 * @bdev: block device to be claimed
996 * @holder: holder's signature
997 * @disk: holder's gendisk
998 *
999 * Call bd_claim_by_kobject() with getting @disk->slave_dir.
1000 */
1001int bd_claim_by_disk(struct block_device *bdev, void *holder,
1002            struct gendisk *disk)
1003{
1004    return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));
1005}
1006EXPORT_SYMBOL_GPL(bd_claim_by_disk);
1007
1008/**
1009 * bd_release_from_disk - wrapper function for bd_release_from_kobject()
1010 *
1011 * @bdev: block device to be claimed
1012 * @disk: holder's gendisk
1013 *
1014 * Call bd_release_from_kobject() and put @disk->slave_dir.
1015 */
1016void bd_release_from_disk(struct block_device *bdev, struct gendisk *disk)
1017{
1018    bd_release_from_kobject(bdev, disk->slave_dir);
1019    kobject_put(disk->slave_dir);
1020}
1021EXPORT_SYMBOL_GPL(bd_release_from_disk);
1022#endif
1023
1024/*
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.
1030 */
1031struct block_device *open_by_devnum(dev_t dev, fmode_t mode)
1032{
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;
1038}
1039
1040EXPORT_SYMBOL(open_by_devnum);
1041
1042/**
1043 * flush_disk - invalidates all buffer-cache entries on a disk
1044 *
1045 * @bdev: struct block device to be flushed
1046 *
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.
1050 */
1051static void flush_disk(struct block_device *bdev)
1052{
1053    if (__invalidate_device(bdev)) {
1054        char name[BDEVNAME_SIZE] = "";
1055
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);
1060    }
1061
1062    if (!bdev->bd_disk)
1063        return;
1064    if (disk_partitionable(bdev->bd_disk))
1065        bdev->bd_invalidated = 1;
1066}
1067
1068/**
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.
1072 *
1073 * This routine checks to see if the bdev size does not match the disk size
1074 * and adjusts it if it differs.
1075 */
1076void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
1077{
1078    loff_t disk_size, bdev_size;
1079
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];
1084
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);
1091    }
1092}
1093EXPORT_SYMBOL(check_disk_size_change);
1094
1095/**
1096 * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
1097 * @disk: struct gendisk to be revalidated
1098 *
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.
1102 */
1103int revalidate_disk(struct gendisk *disk)
1104{
1105    struct block_device *bdev;
1106    int ret = 0;
1107
1108    if (disk->fops->revalidate_disk)
1109        ret = disk->fops->revalidate_disk(disk);
1110
1111    bdev = bdget_disk(disk, 0);
1112    if (!bdev)
1113        return ret;
1114
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;
1120}
1121EXPORT_SYMBOL(revalidate_disk);
1122
1123/*
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 :-)
1131 */
1132int check_disk_change(struct block_device *bdev)
1133{
1134    struct gendisk *disk = bdev->bd_disk;
1135    const struct block_device_operations *bdops = disk->fops;
1136
1137    if (!bdops->media_changed)
1138        return 0;
1139    if (!bdops->media_changed(bdev->bd_disk))
1140        return 0;
1141
1142    flush_disk(bdev);
1143    if (bdops->revalidate_disk)
1144        bdops->revalidate_disk(bdev->bd_disk);
1145    return 1;
1146}
1147
1148EXPORT_SYMBOL(check_disk_change);
1149
1150void bd_set_size(struct block_device *bdev, loff_t size)
1151{
1152    unsigned bsize = bdev_logical_block_size(bdev);
1153
1154    bdev->bd_inode->i_size = size;
1155    while (bsize < PAGE_CACHE_SIZE) {
1156        if (size & bsize)
1157            break;
1158        bsize <<= 1;
1159    }
1160    bdev->bd_block_size = bsize;
1161    bdev->bd_inode->i_blkbits = blksize_bits(bsize);
1162}
1163EXPORT_SYMBOL(bd_set_size);
1164
1165static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
1166
1167/*
1168 * bd_mutex locking:
1169 *
1170 * mutex_lock(part->bd_mutex)
1171 * mutex_lock_nested(whole->bd_mutex, 1)
1172 */
1173
1174static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
1175{
1176    struct gendisk *disk;
1177    int ret;
1178    int partno;
1179    int perm = 0;
1180
1181    if (mode & FMODE_READ)
1182        perm |= MAY_READ;
1183    if (mode & FMODE_WRITE)
1184        perm |= MAY_WRITE;
1185    /*
1186     * hooks: /n/, see "layering violations".
1187     */
1188    ret = devcgroup_inode_permission(bdev->bd_inode, perm);
1189    if (ret != 0) {
1190        bdput(bdev);
1191        return ret;
1192    }
1193
1194    lock_kernel();
1195 restart:
1196
1197    ret = -ENXIO;
1198    disk = get_gendisk(bdev->bd_dev, &partno);
1199    if (!disk)
1200        goto out_unlock_kernel;
1201
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;
1208
1209            ret = -ENXIO;
1210            bdev->bd_part = disk_get_part(disk, partno);
1211            if (!bdev->bd_part)
1212                goto out_clear;
1213
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
1220                     */
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;
1228                }
1229                if (ret)
1230                    goto out_clear;
1231            }
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;
1238            }
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;
1259            }
1260            bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
1261        }
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;
1271            }
1272            if (bdev->bd_invalidated)
1273                rescan_partitions(bdev->bd_disk, bdev);
1274        }
1275    }
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;
1282
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();
1295
1296    if (disk)
1297        module_put(disk->fops->owner);
1298    put_disk(disk);
1299    bdput(bdev);
1300
1301    return ret;
1302}
1303
1304int blkdev_get(struct block_device *bdev, fmode_t mode)
1305{
1306    return __blkdev_get(bdev, mode, 0);
1307}
1308EXPORT_SYMBOL(blkdev_get);
1309
1310static int blkdev_open(struct inode * inode, struct file * filp)
1311{
1312    struct block_device *bdev;
1313    int res;
1314
1315    /*
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.
1320     */
1321    filp->f_flags |= O_LARGEFILE;
1322
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;
1329
1330    bdev = bd_acquire(inode);
1331    if (bdev == NULL)
1332        return -ENOMEM;
1333
1334    filp->f_mapping = bdev->bd_inode->i_mapping;
1335
1336    res = blkdev_get(bdev, filp->f_mode);
1337    if (res)
1338        return res;
1339
1340    if (filp->f_mode & FMODE_EXCL) {
1341        res = bd_claim(bdev, filp);
1342        if (res)
1343            goto out_blkdev_put;
1344    }
1345
1346    return 0;
1347
1348 out_blkdev_put:
1349    blkdev_put(bdev, filp->f_mode);
1350    return res;
1351}
1352
1353static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
1354{
1355    int ret = 0;
1356    struct gendisk *disk = bdev->bd_disk;
1357    struct block_device *victim = NULL;
1358
1359    mutex_lock_nested(&bdev->bd_mutex, for_part);
1360    lock_kernel();
1361    if (for_part)
1362        bdev->bd_part_count--;
1363
1364    if (!--bdev->bd_openers) {
1365        sync_blockdev(bdev);
1366        kill_bdev(bdev);
1367    }
1368    if (bdev->bd_contains == bdev) {
1369        if (disk->fops->release)
1370            ret = disk->fops->release(disk, mode);
1371    }
1372    if (!bdev->bd_openers) {
1373        struct module *owner = disk->fops->owner;
1374
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;
1384    }
1385    unlock_kernel();
1386    mutex_unlock(&bdev->bd_mutex);
1387    bdput(bdev);
1388    if (victim)
1389        __blkdev_put(victim, mode, 1);
1390    return ret;
1391}
1392
1393int blkdev_put(struct block_device *bdev, fmode_t mode)
1394{
1395    return __blkdev_put(bdev, mode, 0);
1396}
1397EXPORT_SYMBOL(blkdev_put);
1398
1399static int blkdev_close(struct inode * inode, struct file * filp)
1400{
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);
1405}
1406
1407static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1408{
1409    struct block_device *bdev = I_BDEV(file->f_mapping->host);
1410    fmode_t mode = file->f_mode;
1411
1412    /*
1413     * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
1414     * to updated it before every ioctl.
1415     */
1416    if (file->f_flags & O_NDELAY)
1417        mode |= FMODE_NDELAY;
1418    else
1419        mode &= ~FMODE_NDELAY;
1420
1421    return blkdev_ioctl(bdev, mode, cmd, arg);
1422}
1423
1424/*
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.
1427 *
1428 * Does not take i_mutex for the write and thus is not for general purpose
1429 * use.
1430 */
1431ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
1432             unsigned long nr_segs, loff_t pos)
1433{
1434    struct file *file = iocb->ki_filp;
1435    ssize_t ret;
1436
1437    BUG_ON(iocb->ki_pos != pos);
1438
1439    ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
1440    if (ret > 0 || ret == -EIOCBQUEUED) {
1441        ssize_t err;
1442
1443        err = generic_write_sync(file, pos, ret);
1444        if (err < 0 && ret > 0)
1445            ret = err;
1446    }
1447    return ret;
1448}
1449EXPORT_SYMBOL_GPL(blkdev_aio_write);
1450
1451/*
1452 * Try to release a page associated with block device when the system
1453 * is under memory pressure.
1454 */
1455static int blkdev_releasepage(struct page *page, gfp_t wait)
1456{
1457    struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
1458
1459    if (super && super->s_op->bdev_try_to_free_page)
1460        return super->s_op->bdev_try_to_free_page(super, page, wait);
1461
1462    return try_to_free_buffers(page);
1463}
1464
1465static 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,
1474};
1475
1476const 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,
1492};
1493
1494int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
1495{
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;
1502}
1503
1504EXPORT_SYMBOL(ioctl_by_bdev);
1505
1506/**
1507 * lookup_bdev - lookup a struct block_device by name
1508 * @pathname: special file representing the block device
1509 *
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.
1513 */
1514struct block_device *lookup_bdev(const char *pathname)
1515{
1516    struct block_device *bdev;
1517    struct inode *inode;
1518    struct path path;
1519    int error;
1520
1521    if (!pathname || !*pathname)
1522        return ERR_PTR(-EINVAL);
1523
1524    error = kern_path(pathname, LOOKUP_FOLLOW, &path);
1525    if (error)
1526        return ERR_PTR(error);
1527
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;
1539out:
1540    path_put(&path);
1541    return bdev;
1542fail:
1543    bdev = ERR_PTR(error);
1544    goto out;
1545}
1546EXPORT_SYMBOL(lookup_bdev);
1547
1548/**
1549 * open_bdev_exclusive - open a block device by name and set it up for use
1550 *
1551 * @path: special file representing the block device
1552 * @mode: FMODE_... combination to pass be used
1553 * @holder: owner for exclusion
1554 *
1555 * Open the blockdevice described by the special file at @path, claim it
1556 * for the @holder.
1557 */
1558struct block_device *open_bdev_exclusive(const char *path, fmode_t mode, void *holder)
1559{
1560    struct block_device *bdev;
1561    int error = 0;
1562
1563    bdev = lookup_bdev(path);
1564    if (IS_ERR(bdev))
1565        return bdev;
1566
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;
1576
1577    return bdev;
1578    
1579blkdev_put:
1580    blkdev_put(bdev, mode);
1581    return ERR_PTR(error);
1582}
1583
1584EXPORT_SYMBOL(open_bdev_exclusive);
1585
1586/**
1587 * close_bdev_exclusive - close a blockdevice opened by open_bdev_exclusive()
1588 *
1589 * @bdev: blockdevice to close
1590 * @mode: mode, must match that used to open.
1591 *
1592 * This is the counterpart to open_bdev_exclusive().
1593 */
1594void close_bdev_exclusive(struct block_device *bdev, fmode_t mode)
1595{
1596    bd_release(bdev);
1597    blkdev_put(bdev, mode);
1598}
1599
1600EXPORT_SYMBOL(close_bdev_exclusive);
1601
1602int __invalidate_device(struct block_device *bdev)
1603{
1604    struct super_block *sb = get_super(bdev);
1605    int res = 0;
1606
1607    if (sb) {
1608        /*
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).
1613         */
1614        shrink_dcache_sb(sb);
1615        res = invalidate_inodes(sb);
1616        drop_super(sb);
1617    }
1618    invalidate_bdev(bdev);
1619    return res;
1620}
1621EXPORT_SYMBOL(__invalidate_device);
1622

Archive Download this file



interactive