blob: 63c9d60762051de9c5c91bcc7f00d81bc7172c87 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/smp_lock.h>
Pavel Emelyanov7db9cfd2008-06-05 22:46:27 -070015#include <linux/device_cgroup.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#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>
Nick Piggin585d3bc2009-02-25 10:44:19 +010021#include <linux/pagevec.h>
David Howells811d7362006-08-29 19:06:09 +010022#include <linux/writeback.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/mpage.h>
24#include <linux/mount.h>
25#include <linux/uio.h>
26#include <linux/namei.h>
Vignesh Babu BM1368c4f2007-05-08 00:24:32 -070027#include <linux/log2.h>
Catalin Marinas2e1483c2009-06-11 13:24:13 +010028#include <linux/kmemleak.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <asm/uaccess.h>
David Howells07f3f05c2006-09-30 20:52:18 +020030#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32struct bdev_inode {
33 struct block_device bdev;
34 struct inode vfs_inode;
35};
36
Adrian Bunk4c54ac62008-02-18 13:48:31 +010037static const struct address_space_operations def_blk_aops;
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039static 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
Peter Zijlstraf9a14392007-05-06 14:49:55 -070064/* Kill _all_ buffers and pagecache , dirty or not.. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070065static void kill_bdev(struct block_device *bdev)
66{
Peter Zijlstraf9a14392007-05-06 14:49:55 -070067 if (bdev->bd_inode->i_mapping->nrpages == 0)
68 return;
69 invalidate_bh_lrus();
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 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 */
Vignesh Babu BM1368c4f2007-05-08 00:24:32 -070076 if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 return -EINVAL;
78
79 /* Size cannot be smaller than the size supported by the device */
Martin K. Petersene1defc42009-05-22 17:17:49 -040080 if (size < bdev_logical_block_size(bdev))
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 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{
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 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;
Coywolf Qi Hunt38885bd2006-03-24 03:18:05 -0800102 sb->s_blocksize_bits = blksize_bits(size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 return sb->s_blocksize;
104}
105
106EXPORT_SYMBOL(sb_set_blocksize);
107
108int sb_min_blocksize(struct super_block *sb, int size)
109{
Martin K. Petersene1defc42009-05-22 17:17:49 -0400110 int minsize = bdev_logical_block_size(sb->s_bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 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
Andrew Mortonb2e895d2007-02-03 01:14:01 -0800140static 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
Christoph Hellwigeafdc7d2010-06-04 11:29:53 +0200175 return __blockdev_direct_IO(rw, iocb, inode, I_BDEV(inode), iov, offset,
176 nr_segs, blkdev_get_blocks, NULL, NULL, 0);
Andrew Mortonb2e895d2007-02-03 01:14:01 -0800177}
178
Jan Kara5cee5812009-04-27 16:43:51 +0200179int __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
Nick Piggin585d3bc2009-02-25 10:44:19 +0100188/*
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{
Jan Kara5cee5812009-04-27 16:43:51 +0200194 return __sync_blockdev(bdev, 1);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100195}
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) {
Jan Kara60b06802009-04-27 16:43:53 +0200207 int res = sync_filesystem(sb);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100208 drop_super(sb);
209 return res;
210 }
211 return sync_blockdev(bdev);
212}
Al Viro47e44912009-04-01 07:07:16 -0400213EXPORT_SYMBOL(fsync_bdev);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100214
215/**
216 * freeze_bdev -- lock a filesystem and force it into a consistent state
217 * @bdev: blockdevice to lock
218 *
Nick Piggin585d3bc2009-02-25 10:44:19 +0100219 * 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);
Christoph Hellwig45042302009-08-03 23:28:35 +0200233 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 */
Nick Piggin585d3bc2009-02-25 10:44:19 +0100239 sb = get_super(bdev);
Christoph Hellwig45042302009-08-03 23:28:35 +0200240 drop_super(sb);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100241 mutex_unlock(&bdev->bd_fsfreeze_mutex);
242 return sb;
243 }
Nick Piggin585d3bc2009-02-25 10:44:19 +0100244
Christoph Hellwig45042302009-08-03 23:28:35 +0200245 sb = get_active_super(bdev);
246 if (!sb)
247 goto out;
Josef Bacik18e9e512010-03-23 10:34:56 -0400248 error = freeze_super(sb);
249 if (error) {
250 deactivate_super(sb);
251 bdev->bd_fsfreeze_count--;
Christoph Hellwig45042302009-08-03 23:28:35 +0200252 mutex_unlock(&bdev->bd_fsfreeze_mutex);
Josef Bacik18e9e512010-03-23 10:34:56 -0400253 return ERR_PTR(error);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100254 }
Josef Bacik18e9e512010-03-23 10:34:56 -0400255 deactivate_super(sb);
Christoph Hellwig45042302009-08-03 23:28:35 +0200256 out:
Nick Piggin585d3bc2009-02-25 10:44:19 +0100257 sync_blockdev(bdev);
258 mutex_unlock(&bdev->bd_fsfreeze_mutex);
Christoph Hellwig4fadd7b2009-08-03 23:28:06 +0200259 return sb; /* thaw_bdev releases s->s_umount */
Nick Piggin585d3bc2009-02-25 10:44:19 +0100260}
261EXPORT_SYMBOL(freeze_bdev);
262
263/**
264 * thaw_bdev -- unlock filesystem
265 * @bdev: blockdevice to unlock
266 * @sb: associated superblock
267 *
268 * Unlocks the filesystem and marks it writeable again after freeze_bdev().
269 */
270int thaw_bdev(struct block_device *bdev, struct super_block *sb)
271{
Christoph Hellwig45042302009-08-03 23:28:35 +0200272 int error = -EINVAL;
Nick Piggin585d3bc2009-02-25 10:44:19 +0100273
274 mutex_lock(&bdev->bd_fsfreeze_mutex);
Christoph Hellwig45042302009-08-03 23:28:35 +0200275 if (!bdev->bd_fsfreeze_count)
Josef Bacik18e9e512010-03-23 10:34:56 -0400276 goto out;
Nick Piggin585d3bc2009-02-25 10:44:19 +0100277
Christoph Hellwig45042302009-08-03 23:28:35 +0200278 error = 0;
279 if (--bdev->bd_fsfreeze_count > 0)
Josef Bacik18e9e512010-03-23 10:34:56 -0400280 goto out;
Nick Piggin585d3bc2009-02-25 10:44:19 +0100281
Christoph Hellwig45042302009-08-03 23:28:35 +0200282 if (!sb)
Josef Bacik18e9e512010-03-23 10:34:56 -0400283 goto out;
Christoph Hellwig45042302009-08-03 23:28:35 +0200284
Josef Bacik18e9e512010-03-23 10:34:56 -0400285 error = thaw_super(sb);
286 if (error) {
287 bdev->bd_fsfreeze_count++;
288 mutex_unlock(&bdev->bd_fsfreeze_mutex);
289 return error;
Nick Piggin585d3bc2009-02-25 10:44:19 +0100290 }
Josef Bacik18e9e512010-03-23 10:34:56 -0400291out:
Nick Piggin585d3bc2009-02-25 10:44:19 +0100292 mutex_unlock(&bdev->bd_fsfreeze_mutex);
293 return 0;
294}
295EXPORT_SYMBOL(thaw_bdev);
296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
298{
299 return block_write_full_page(page, blkdev_get_block, wbc);
300}
301
302static int blkdev_readpage(struct file * file, struct page * page)
303{
304 return block_read_full_page(page, blkdev_get_block);
305}
306
Nick Piggin6272b5a2007-10-16 01:25:04 -0700307static int blkdev_write_begin(struct file *file, struct address_space *mapping,
308 loff_t pos, unsigned len, unsigned flags,
309 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310{
Christoph Hellwig155130a2010-06-04 11:29:58 +0200311 return block_write_begin(mapping, pos, len, flags, pagep,
312 blkdev_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
Nick Piggin6272b5a2007-10-16 01:25:04 -0700315static int blkdev_write_end(struct file *file, struct address_space *mapping,
316 loff_t pos, unsigned len, unsigned copied,
317 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
Nick Piggin6272b5a2007-10-16 01:25:04 -0700319 int ret;
320 ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
321
322 unlock_page(page);
323 page_cache_release(page);
324
325 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
328/*
329 * private llseek:
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800330 * for a block special file file->f_path.dentry->d_inode->i_size is zero
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 * so we compute the size by hand (just as in block_read/write above)
332 */
333static loff_t block_llseek(struct file *file, loff_t offset, int origin)
334{
335 struct inode *bd_inode = file->f_mapping->host;
336 loff_t size;
337 loff_t retval;
338
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800339 mutex_lock(&bd_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 size = i_size_read(bd_inode);
341
342 switch (origin) {
343 case 2:
344 offset += size;
345 break;
346 case 1:
347 offset += file->f_pos;
348 }
349 retval = -EINVAL;
350 if (offset >= 0 && offset <= size) {
351 if (offset != file->f_pos) {
352 file->f_pos = offset;
353 }
354 retval = offset;
355 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800356 mutex_unlock(&bd_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 return retval;
358}
359
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200360int blkdev_fsync(struct file *filp, int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361{
Anton Blanchardb8af67e2010-04-23 13:18:06 -0400362 struct inode *bd_inode = filp->f_mapping->host;
363 struct block_device *bdev = I_BDEV(bd_inode);
Christoph Hellwigab0a9732009-10-29 14:14:04 +0100364 int error;
365
Anton Blanchardb8af67e2010-04-23 13:18:06 -0400366 /*
367 * There is no need to serialise calls to blkdev_issue_flush with
368 * i_mutex and doing so causes performance issues with concurrent
369 * O_SYNC writers to a block device.
370 */
371 mutex_unlock(&bd_inode->i_mutex);
372
Jens Axboe7407cf32010-04-29 09:36:24 +0200373 error = blkdev_issue_flush(bdev, GFP_KERNEL, NULL, BLKDEV_IFL_WAIT);
Christoph Hellwigab0a9732009-10-29 14:14:04 +0100374 if (error == -EOPNOTSUPP)
375 error = 0;
Anton Blanchardb8af67e2010-04-23 13:18:06 -0400376
377 mutex_lock(&bd_inode->i_mutex);
378
Christoph Hellwigab0a9732009-10-29 14:14:04 +0100379 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380}
Andrew Mortonb1dd3b22010-04-06 14:35:00 -0700381EXPORT_SYMBOL(blkdev_fsync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383/*
384 * pseudo-fs
385 */
386
387static __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
Christoph Lametere18b8902006-12-06 20:33:20 -0800388static struct kmem_cache * bdev_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
390static struct inode *bdev_alloc_inode(struct super_block *sb)
391{
Christoph Lametere94b1762006-12-06 20:33:17 -0800392 struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 if (!ei)
394 return NULL;
395 return &ei->vfs_inode;
396}
397
398static void bdev_destroy_inode(struct inode *inode)
399{
400 struct bdev_inode *bdi = BDEV_I(inode);
401
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 kmem_cache_free(bdev_cachep, bdi);
403}
404
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700405static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 struct bdev_inode *ei = (struct bdev_inode *) foo;
408 struct block_device *bdev = &ei->bdev;
409
Christoph Lametera35afb82007-05-16 22:10:57 -0700410 memset(bdev, 0, sizeof(*bdev));
411 mutex_init(&bdev->bd_mutex);
Christoph Lametera35afb82007-05-16 22:10:57 -0700412 INIT_LIST_HEAD(&bdev->bd_inodes);
413 INIT_LIST_HEAD(&bdev->bd_list);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800414#ifdef CONFIG_SYSFS
Christoph Lametera35afb82007-05-16 22:10:57 -0700415 INIT_LIST_HEAD(&bdev->bd_holder_list);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800416#endif
Christoph Lametera35afb82007-05-16 22:10:57 -0700417 inode_init_once(&ei->vfs_inode);
Takashi Satofcccf502009-01-09 16:40:59 -0800418 /* Initialize mutex for freeze. */
419 mutex_init(&bdev->bd_fsfreeze_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420}
421
422static inline void __bd_forget(struct inode *inode)
423{
424 list_del_init(&inode->i_devices);
425 inode->i_bdev = NULL;
426 inode->i_mapping = &inode->i_data;
427}
428
429static void bdev_clear_inode(struct inode *inode)
430{
431 struct block_device *bdev = &BDEV_I(inode)->bdev;
432 struct list_head *p;
433 spin_lock(&bdev_lock);
434 while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
435 __bd_forget(list_entry(p, struct inode, i_devices));
436 }
437 list_del_init(&bdev->bd_list);
438 spin_unlock(&bdev_lock);
439}
440
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800441static const struct super_operations bdev_sops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 .statfs = simple_statfs,
443 .alloc_inode = bdev_alloc_inode,
444 .destroy_inode = bdev_destroy_inode,
445 .drop_inode = generic_delete_inode,
446 .clear_inode = bdev_clear_inode,
447};
448
David Howells454e2392006-06-23 02:02:57 -0700449static int bd_get_sb(struct file_system_type *fs_type,
450 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
David Howells454e2392006-06-23 02:02:57 -0700452 return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453}
454
455static struct file_system_type bd_type = {
456 .name = "bdev",
457 .get_sb = bd_get_sb,
458 .kill_sb = kill_anon_super,
459};
460
Denis ChengRqc2acf7b2008-12-01 14:34:56 -0800461struct super_block *blockdev_superblock __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
463void __init bdev_cache_init(void)
464{
465 int err;
Denis ChengRqc2acf7b2008-12-01 14:34:56 -0800466 struct vfsmount *bd_mnt;
467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800469 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
470 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +0900471 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 err = register_filesystem(&bd_type);
473 if (err)
474 panic("Cannot register bdev pseudo-fs");
475 bd_mnt = kern_mount(&bd_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 if (IS_ERR(bd_mnt))
477 panic("Cannot create bdev pseudo-fs");
Catalin Marinas2e1483c2009-06-11 13:24:13 +0100478 /*
479 * This vfsmount structure is only used to obtain the
480 * blockdev_superblock, so tell kmemleak not to report it.
481 */
482 kmemleak_not_leak(bd_mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 blockdev_superblock = bd_mnt->mnt_sb; /* For writeback */
484}
485
486/*
487 * Most likely _very_ bad one - but then it's hardly critical for small
488 * /dev and can be fixed when somebody will need really large one.
489 * Keep in mind that it will be fed through icache hash function too.
490 */
491static inline unsigned long hash(dev_t dev)
492{
493 return MAJOR(dev)+MINOR(dev);
494}
495
496static int bdev_test(struct inode *inode, void *data)
497{
498 return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
499}
500
501static int bdev_set(struct inode *inode, void *data)
502{
503 BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
504 return 0;
505}
506
507static LIST_HEAD(all_bdevs);
508
509struct block_device *bdget(dev_t dev)
510{
511 struct block_device *bdev;
512 struct inode *inode;
513
Denis ChengRqc2acf7b2008-12-01 14:34:56 -0800514 inode = iget5_locked(blockdev_superblock, hash(dev),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 bdev_test, bdev_set, &dev);
516
517 if (!inode)
518 return NULL;
519
520 bdev = &BDEV_I(inode)->bdev;
521
522 if (inode->i_state & I_NEW) {
523 bdev->bd_contains = NULL;
524 bdev->bd_inode = inode;
525 bdev->bd_block_size = (1 << inode->i_blkbits);
526 bdev->bd_part_count = 0;
527 bdev->bd_invalidated = 0;
528 inode->i_mode = S_IFBLK;
529 inode->i_rdev = dev;
530 inode->i_bdev = bdev;
531 inode->i_data.a_ops = &def_blk_aops;
532 mapping_set_gfp_mask(&inode->i_data, GFP_USER);
533 inode->i_data.backing_dev_info = &default_backing_dev_info;
534 spin_lock(&bdev_lock);
535 list_add(&bdev->bd_list, &all_bdevs);
536 spin_unlock(&bdev_lock);
537 unlock_new_inode(inode);
538 }
539 return bdev;
540}
541
542EXPORT_SYMBOL(bdget);
543
Alan Jenkinsdddac6a2009-07-29 21:07:55 +0200544/**
545 * bdgrab -- Grab a reference to an already referenced block device
546 * @bdev: Block device to grab a reference to.
547 */
548struct block_device *bdgrab(struct block_device *bdev)
549{
550 atomic_inc(&bdev->bd_inode->i_count);
551 return bdev;
552}
553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554long nr_blockdev_pages(void)
555{
Matthias Kaehlcke203a2932007-07-15 23:40:23 -0700556 struct block_device *bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 long ret = 0;
558 spin_lock(&bdev_lock);
Matthias Kaehlcke203a2932007-07-15 23:40:23 -0700559 list_for_each_entry(bdev, &all_bdevs, bd_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 ret += bdev->bd_inode->i_mapping->nrpages;
561 }
562 spin_unlock(&bdev_lock);
563 return ret;
564}
565
566void bdput(struct block_device *bdev)
567{
568 iput(bdev->bd_inode);
569}
570
571EXPORT_SYMBOL(bdput);
572
573static struct block_device *bd_acquire(struct inode *inode)
574{
575 struct block_device *bdev;
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 spin_lock(&bdev_lock);
578 bdev = inode->i_bdev;
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700579 if (bdev) {
580 atomic_inc(&bdev->bd_inode->i_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 spin_unlock(&bdev_lock);
582 return bdev;
583 }
584 spin_unlock(&bdev_lock);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 bdev = bdget(inode->i_rdev);
587 if (bdev) {
588 spin_lock(&bdev_lock);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700589 if (!inode->i_bdev) {
590 /*
591 * We take an additional bd_inode->i_count for inode,
592 * and it's released in clear_inode() of inode.
593 * So, we can access it via ->i_mapping always
594 * without igrab().
595 */
596 atomic_inc(&bdev->bd_inode->i_count);
597 inode->i_bdev = bdev;
598 inode->i_mapping = bdev->bd_inode->i_mapping;
599 list_add(&inode->i_devices, &bdev->bd_inodes);
600 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 spin_unlock(&bdev_lock);
602 }
603 return bdev;
604}
605
606/* Call when you free inode */
607
608void bd_forget(struct inode *inode)
609{
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700610 struct block_device *bdev = NULL;
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 spin_lock(&bdev_lock);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700613 if (inode->i_bdev) {
Denis ChengRqc2acf7b2008-12-01 14:34:56 -0800614 if (!sb_is_blkdev_sb(inode->i_sb))
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700615 bdev = inode->i_bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 __bd_forget(inode);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700617 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 spin_unlock(&bdev_lock);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700619
620 if (bdev)
621 iput(bdev->bd_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622}
623
Tejun Heo1a3cbbc2010-04-07 18:52:29 +0900624/**
625 * bd_may_claim - test whether a block device can be claimed
626 * @bdev: block device of interest
627 * @whole: whole block device containing @bdev, may equal @bdev
628 * @holder: holder trying to claim @bdev
629 *
630 * Test whther @bdev can be claimed by @holder.
631 *
632 * CONTEXT:
633 * spin_lock(&bdev_lock).
634 *
635 * RETURNS:
636 * %true if @bdev can be claimed, %false otherwise.
637 */
638static bool bd_may_claim(struct block_device *bdev, struct block_device *whole,
639 void *holder)
640{
641 if (bdev->bd_holder == holder)
642 return true; /* already a holder */
643 else if (bdev->bd_holder != NULL)
644 return false; /* held by someone else */
645 else if (bdev->bd_contains == bdev)
646 return true; /* is a whole device which isn't held */
647
648 else if (whole->bd_holder == bd_claim)
649 return true; /* is a partition of a device that is being partitioned */
650 else if (whole->bd_holder != NULL)
651 return false; /* is a partition of a held device */
652 else
653 return true; /* is a partition of an un-held device */
654}
655
656/**
Tejun Heo6b4517a2010-04-07 18:53:59 +0900657 * bd_prepare_to_claim - prepare to claim a block device
658 * @bdev: block device of interest
659 * @whole: the whole device containing @bdev, may equal @bdev
660 * @holder: holder trying to claim @bdev
661 *
662 * Prepare to claim @bdev. This function fails if @bdev is already
663 * claimed by another holder and waits if another claiming is in
664 * progress. This function doesn't actually claim. On successful
665 * return, the caller has ownership of bd_claiming and bd_holder[s].
666 *
667 * CONTEXT:
668 * spin_lock(&bdev_lock). Might release bdev_lock, sleep and regrab
669 * it multiple times.
670 *
671 * RETURNS:
672 * 0 if @bdev can be claimed, -EBUSY otherwise.
673 */
674static int bd_prepare_to_claim(struct block_device *bdev,
675 struct block_device *whole, void *holder)
676{
677retry:
678 /* if someone else claimed, fail */
679 if (!bd_may_claim(bdev, whole, holder))
680 return -EBUSY;
681
682 /* if someone else is claiming, wait for it to finish */
683 if (whole->bd_claiming && whole->bd_claiming != holder) {
684 wait_queue_head_t *wq = bit_waitqueue(&whole->bd_claiming, 0);
685 DEFINE_WAIT(wait);
686
687 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
688 spin_unlock(&bdev_lock);
689 schedule();
690 finish_wait(wq, &wait);
691 spin_lock(&bdev_lock);
692 goto retry;
693 }
694
695 /* yay, all mine */
696 return 0;
697}
698
699/**
700 * bd_start_claiming - start claiming a block device
701 * @bdev: block device of interest
702 * @holder: holder trying to claim @bdev
703 *
704 * @bdev is about to be opened exclusively. Check @bdev can be opened
705 * exclusively and mark that an exclusive open is in progress. Each
706 * successful call to this function must be matched with a call to
Nick Pigginb0018362010-05-26 01:51:19 +1000707 * either bd_finish_claiming() or bd_abort_claiming() (which do not
708 * fail).
709 *
710 * This function is used to gain exclusive access to the block device
711 * without actually causing other exclusive open attempts to fail. It
712 * should be used when the open sequence itself requires exclusive
713 * access but may subsequently fail.
Tejun Heo6b4517a2010-04-07 18:53:59 +0900714 *
715 * CONTEXT:
716 * Might sleep.
717 *
718 * RETURNS:
719 * Pointer to the block device containing @bdev on success, ERR_PTR()
720 * value on failure.
721 */
722static struct block_device *bd_start_claiming(struct block_device *bdev,
723 void *holder)
724{
725 struct gendisk *disk;
726 struct block_device *whole;
727 int partno, err;
728
729 might_sleep();
730
731 /*
732 * @bdev might not have been initialized properly yet, look up
733 * and grab the outer block device the hard way.
734 */
735 disk = get_gendisk(bdev->bd_dev, &partno);
736 if (!disk)
737 return ERR_PTR(-ENXIO);
738
739 whole = bdget_disk(disk, 0);
Nick Piggincf342572010-05-26 01:50:21 +1000740 module_put(disk->fops->owner);
Tejun Heo6b4517a2010-04-07 18:53:59 +0900741 put_disk(disk);
742 if (!whole)
743 return ERR_PTR(-ENOMEM);
744
745 /* prepare to claim, if successful, mark claiming in progress */
746 spin_lock(&bdev_lock);
747
748 err = bd_prepare_to_claim(bdev, whole, holder);
749 if (err == 0) {
750 whole->bd_claiming = holder;
751 spin_unlock(&bdev_lock);
752 return whole;
753 } else {
754 spin_unlock(&bdev_lock);
755 bdput(whole);
756 return ERR_PTR(err);
757 }
758}
759
760/* releases bdev_lock */
761static void __bd_abort_claiming(struct block_device *whole, void *holder)
762{
763 BUG_ON(whole->bd_claiming != holder);
764 whole->bd_claiming = NULL;
765 wake_up_bit(&whole->bd_claiming, 0);
766
767 spin_unlock(&bdev_lock);
768 bdput(whole);
769}
770
771/**
772 * bd_abort_claiming - abort claiming a block device
773 * @whole: whole block device returned by bd_start_claiming()
774 * @holder: holder trying to claim @bdev
775 *
776 * Abort a claiming block started by bd_start_claiming(). Note that
777 * @whole is not the block device to be claimed but the whole device
778 * returned by bd_start_claiming().
779 *
780 * CONTEXT:
781 * Grabs and releases bdev_lock.
782 */
783static void bd_abort_claiming(struct block_device *whole, void *holder)
784{
785 spin_lock(&bdev_lock);
786 __bd_abort_claiming(whole, holder); /* releases bdev_lock */
787}
788
Nick Pigginb0018362010-05-26 01:51:19 +1000789/* increment holders when we have a legitimate claim. requires bdev_lock */
790static void __bd_claim(struct block_device *bdev, struct block_device *whole,
791 void *holder)
792{
793 /* note that for a whole device bd_holders
794 * will be incremented twice, and bd_holder will
795 * be set to bd_claim before being set to holder
796 */
797 whole->bd_holders++;
798 whole->bd_holder = bd_claim;
799 bdev->bd_holders++;
800 bdev->bd_holder = holder;
801}
802
803/**
804 * bd_finish_claiming - finish claiming a block device
805 * @bdev: block device of interest (passed to bd_start_claiming())
806 * @whole: whole block device returned by bd_start_claiming()
807 * @holder: holder trying to claim @bdev
808 *
809 * Finish a claiming block started by bd_start_claiming().
810 *
811 * CONTEXT:
812 * Grabs and releases bdev_lock.
813 */
814static void bd_finish_claiming(struct block_device *bdev,
815 struct block_device *whole, void *holder)
816{
817 spin_lock(&bdev_lock);
Nick Pigginb0018362010-05-26 01:51:19 +1000818 BUG_ON(!bd_may_claim(bdev, whole, holder));
819 __bd_claim(bdev, whole, holder);
820 __bd_abort_claiming(whole, holder); /* not actually an abort */
821}
822
Tejun Heo6b4517a2010-04-07 18:53:59 +0900823/**
Tejun Heo1a3cbbc2010-04-07 18:52:29 +0900824 * bd_claim - claim a block device
825 * @bdev: block device to claim
826 * @holder: holder trying to claim @bdev
827 *
Nick Pigginb0018362010-05-26 01:51:19 +1000828 * Try to claim @bdev which must have been opened successfully.
Tejun Heo6b4517a2010-04-07 18:53:59 +0900829 *
830 * CONTEXT:
831 * Might sleep.
Tejun Heo1a3cbbc2010-04-07 18:52:29 +0900832 *
833 * RETURNS:
834 * 0 if successful, -EBUSY if @bdev is already claimed.
835 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836int bd_claim(struct block_device *bdev, void *holder)
837{
Tejun Heo1a3cbbc2010-04-07 18:52:29 +0900838 struct block_device *whole = bdev->bd_contains;
Tejun Heo6b4517a2010-04-07 18:53:59 +0900839 int res;
840
841 might_sleep();
Tejun Heo1a3cbbc2010-04-07 18:52:29 +0900842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 spin_lock(&bdev_lock);
Tejun Heo6b4517a2010-04-07 18:53:59 +0900844 res = bd_prepare_to_claim(bdev, whole, holder);
Nick Pigginb0018362010-05-26 01:51:19 +1000845 if (res == 0)
846 __bd_claim(bdev, whole, holder);
847 spin_unlock(&bdev_lock);
Tejun Heo6b4517a2010-04-07 18:53:59 +0900848
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 return res;
850}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851EXPORT_SYMBOL(bd_claim);
852
853void bd_release(struct block_device *bdev)
854{
855 spin_lock(&bdev_lock);
856 if (!--bdev->bd_contains->bd_holders)
857 bdev->bd_contains->bd_holder = NULL;
858 if (!--bdev->bd_holders)
859 bdev->bd_holder = NULL;
860 spin_unlock(&bdev_lock);
861}
862
863EXPORT_SYMBOL(bd_release);
864
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800865#ifdef CONFIG_SYSFS
866/*
867 * Functions for bd_claim_by_kobject / bd_release_from_kobject
868 *
869 * If a kobject is passed to bd_claim_by_kobject()
870 * and the kobject has a parent directory,
871 * following symlinks are created:
872 * o from the kobject to the claimed bdev
873 * o from "holders" directory of the bdev to the parent of the kobject
874 * bd_release_from_kobject() removes these symlinks.
875 *
876 * Example:
877 * If /dev/dm-0 maps to /dev/sda, kobject corresponding to
878 * /sys/block/dm-0/slaves is passed to bd_claim_by_kobject(), then:
879 * /sys/block/dm-0/slaves/sda --> /sys/block/sda
880 * /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
881 */
882
Andrew Morton4d7dd8fd2006-09-29 01:58:56 -0700883static int add_symlink(struct kobject *from, struct kobject *to)
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800884{
885 if (!from || !to)
Andrew Morton4d7dd8fd2006-09-29 01:58:56 -0700886 return 0;
887 return sysfs_create_link(from, to, kobject_name(to));
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800888}
889
890static void del_symlink(struct kobject *from, struct kobject *to)
891{
892 if (!from || !to)
893 return;
894 sysfs_remove_link(from, kobject_name(to));
895}
896
897/*
898 * 'struct bd_holder' contains pointers to kobjects symlinked by
899 * bd_claim_by_kobject.
900 * It's connected to bd_holder_list which is protected by bdev->bd_sem.
901 */
902struct bd_holder {
903 struct list_head list; /* chain of holders of the bdev */
904 int count; /* references from the holder */
905 struct kobject *sdir; /* holder object, e.g. "/block/dm-0/slaves" */
906 struct kobject *hdev; /* e.g. "/block/dm-0" */
907 struct kobject *hdir; /* e.g. "/block/sda/holders" */
908 struct kobject *sdev; /* e.g. "/block/sda" */
909};
910
911/*
912 * Get references of related kobjects at once.
913 * Returns 1 on success. 0 on failure.
914 *
915 * Should call bd_holder_release_dirs() after successful use.
916 */
917static int bd_holder_grab_dirs(struct block_device *bdev,
918 struct bd_holder *bo)
919{
920 if (!bdev || !bo)
921 return 0;
922
923 bo->sdir = kobject_get(bo->sdir);
924 if (!bo->sdir)
925 return 0;
926
927 bo->hdev = kobject_get(bo->sdir->parent);
928 if (!bo->hdev)
929 goto fail_put_sdir;
930
Tejun Heo0762b8b2008-08-25 19:56:12 +0900931 bo->sdev = kobject_get(&part_to_dev(bdev->bd_part)->kobj);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800932 if (!bo->sdev)
933 goto fail_put_hdev;
934
Tejun Heo4c465012008-08-25 19:56:11 +0900935 bo->hdir = kobject_get(bdev->bd_part->holder_dir);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800936 if (!bo->hdir)
937 goto fail_put_sdev;
938
939 return 1;
940
941fail_put_sdev:
942 kobject_put(bo->sdev);
943fail_put_hdev:
944 kobject_put(bo->hdev);
945fail_put_sdir:
946 kobject_put(bo->sdir);
947
948 return 0;
949}
950
951/* Put references of related kobjects at once. */
952static void bd_holder_release_dirs(struct bd_holder *bo)
953{
954 kobject_put(bo->hdir);
955 kobject_put(bo->sdev);
956 kobject_put(bo->hdev);
957 kobject_put(bo->sdir);
958}
959
960static struct bd_holder *alloc_bd_holder(struct kobject *kobj)
961{
962 struct bd_holder *bo;
963
964 bo = kzalloc(sizeof(*bo), GFP_KERNEL);
965 if (!bo)
966 return NULL;
967
968 bo->count = 1;
969 bo->sdir = kobj;
970
971 return bo;
972}
973
974static void free_bd_holder(struct bd_holder *bo)
975{
976 kfree(bo);
977}
978
979/**
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -0500980 * find_bd_holder - find matching struct bd_holder from the block device
981 *
982 * @bdev: struct block device to be searched
983 * @bo: target struct bd_holder
984 *
985 * Returns matching entry with @bo in @bdev->bd_holder_list.
986 * If found, increment the reference count and return the pointer.
987 * If not found, returns NULL.
988 */
Andrew Morton36a561d2006-10-30 22:07:03 -0800989static struct bd_holder *find_bd_holder(struct block_device *bdev,
990 struct bd_holder *bo)
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -0500991{
992 struct bd_holder *tmp;
993
994 list_for_each_entry(tmp, &bdev->bd_holder_list, list)
995 if (tmp->sdir == bo->sdir) {
996 tmp->count++;
997 return tmp;
998 }
999
1000 return NULL;
1001}
1002
1003/**
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001004 * add_bd_holder - create sysfs symlinks for bd_claim() relationship
1005 *
1006 * @bdev: block device to be bd_claimed
1007 * @bo: preallocated and initialized by alloc_bd_holder()
1008 *
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -05001009 * Add @bo to @bdev->bd_holder_list, create symlinks.
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001010 *
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -05001011 * Returns 0 if symlinks are created.
1012 * Returns -ve if something fails.
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001013 */
1014static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
1015{
Johannes Weiner4e916722007-07-15 23:41:25 -07001016 int err;
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001017
1018 if (!bo)
Andrew Morton4d7dd8fd2006-09-29 01:58:56 -07001019 return -EINVAL;
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001020
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001021 if (!bd_holder_grab_dirs(bdev, bo))
Andrew Morton4d7dd8fd2006-09-29 01:58:56 -07001022 return -EBUSY;
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001023
Johannes Weiner4e916722007-07-15 23:41:25 -07001024 err = add_symlink(bo->sdir, bo->sdev);
1025 if (err)
1026 return err;
1027
1028 err = add_symlink(bo->hdir, bo->hdev);
1029 if (err) {
1030 del_symlink(bo->sdir, bo->sdev);
1031 return err;
Andrew Morton4d7dd8fd2006-09-29 01:58:56 -07001032 }
Johannes Weiner4e916722007-07-15 23:41:25 -07001033
1034 list_add_tail(&bo->list, &bdev->bd_holder_list);
1035 return 0;
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001036}
1037
1038/**
1039 * del_bd_holder - delete sysfs symlinks for bd_claim() relationship
1040 *
1041 * @bdev: block device to be bd_claimed
1042 * @kobj: holder's kobject
1043 *
1044 * If there is matching entry with @kobj in @bdev->bd_holder_list
1045 * and no other bd_claim() from the same kobject,
1046 * remove the struct bd_holder from the list, delete symlinks for it.
1047 *
1048 * Returns a pointer to the struct bd_holder when it's removed from the list
1049 * and ready to be freed.
1050 * Returns NULL if matching claim isn't found or there is other bd_claim()
1051 * by the same kobject.
1052 */
1053static struct bd_holder *del_bd_holder(struct block_device *bdev,
1054 struct kobject *kobj)
1055{
1056 struct bd_holder *bo;
1057
1058 list_for_each_entry(bo, &bdev->bd_holder_list, list) {
1059 if (bo->sdir == kobj) {
1060 bo->count--;
1061 BUG_ON(bo->count < 0);
1062 if (!bo->count) {
1063 list_del(&bo->list);
1064 del_symlink(bo->sdir, bo->sdev);
1065 del_symlink(bo->hdir, bo->hdev);
1066 bd_holder_release_dirs(bo);
1067 return bo;
1068 }
1069 break;
1070 }
1071 }
1072
1073 return NULL;
1074}
1075
1076/**
1077 * bd_claim_by_kobject - bd_claim() with additional kobject signature
1078 *
1079 * @bdev: block device to be claimed
1080 * @holder: holder's signature
1081 * @kobj: holder's kobject
1082 *
1083 * Do bd_claim() and if it succeeds, create sysfs symlinks between
1084 * the bdev and the holder's kobject.
1085 * Use bd_release_from_kobject() when relesing the claimed bdev.
1086 *
1087 * Returns 0 on success. (same as bd_claim())
1088 * Returns errno on failure.
1089 */
1090static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
1091 struct kobject *kobj)
1092{
Johannes Weiner4e916722007-07-15 23:41:25 -07001093 int err;
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -05001094 struct bd_holder *bo, *found;
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001095
1096 if (!kobj)
1097 return -EINVAL;
1098
1099 bo = alloc_bd_holder(kobj);
1100 if (!bo)
1101 return -ENOMEM;
1102
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001103 mutex_lock(&bdev->bd_mutex);
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -05001104
Johannes Weiner4e916722007-07-15 23:41:25 -07001105 err = bd_claim(bdev, holder);
1106 if (err)
Andrew Morton4210df22007-07-15 23:41:28 -07001107 goto fail;
Johannes Weiner4e916722007-07-15 23:41:25 -07001108
1109 found = find_bd_holder(bdev, bo);
1110 if (found)
Andrew Morton4210df22007-07-15 23:41:28 -07001111 goto fail;
Johannes Weiner4e916722007-07-15 23:41:25 -07001112
1113 err = add_bd_holder(bdev, bo);
1114 if (err)
1115 bd_release(bdev);
Andrew Morton4210df22007-07-15 23:41:28 -07001116 else
1117 bo = NULL;
1118fail:
Jun'ichi Nomurab4cf1b72006-03-27 01:18:00 -08001119 mutex_unlock(&bdev->bd_mutex);
Andrew Morton4210df22007-07-15 23:41:28 -07001120 free_bd_holder(bo);
Johannes Weiner4e916722007-07-15 23:41:25 -07001121 return err;
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001122}
1123
1124/**
1125 * bd_release_from_kobject - bd_release() with additional kobject signature
1126 *
1127 * @bdev: block device to be released
1128 * @kobj: holder's kobject
1129 *
1130 * Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().
1131 */
1132static void bd_release_from_kobject(struct block_device *bdev,
1133 struct kobject *kobj)
1134{
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001135 if (!kobj)
1136 return;
1137
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001138 mutex_lock(&bdev->bd_mutex);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001139 bd_release(bdev);
Andrew Morton4210df22007-07-15 23:41:28 -07001140 free_bd_holder(del_bd_holder(bdev, kobj));
Jun'ichi Nomurab4cf1b72006-03-27 01:18:00 -08001141 mutex_unlock(&bdev->bd_mutex);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -08001142}
1143
1144/**
1145 * bd_claim_by_disk - wrapper function for bd_claim_by_kobject()
1146 *
1147 * @bdev: block device to be claimed
1148 * @holder: holder's signature
1149 * @disk: holder's gendisk
1150 *
1151 * Call bd_claim_by_kobject() with getting @disk->slave_dir.
1152 */
1153int bd_claim_by_disk(struct block_device *bdev, void *holder,
1154 struct gendisk *disk)
1155{
1156 return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));
1157}
1158EXPORT_SYMBOL_GPL(bd_claim_by_disk);
1159
1160/**
1161 * bd_release_from_disk - wrapper function for bd_release_from_kobject()
1162 *
1163 * @bdev: block device to be claimed
1164 * @disk: holder's gendisk
1165 *
1166 * Call bd_release_from_kobject() and put @disk->slave_dir.
1167 */
1168void bd_release_from_disk(struct block_device *bdev, struct gendisk *disk)
1169{
1170 bd_release_from_kobject(bdev, disk->slave_dir);
1171 kobject_put(disk->slave_dir);
1172}
1173EXPORT_SYMBOL_GPL(bd_release_from_disk);
1174#endif
1175
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176/*
1177 * Tries to open block device by device number. Use it ONLY if you
1178 * really do not have anything better - i.e. when you are behind a
1179 * truly sucky interface and all you are given is a device number. _Never_
1180 * to be used for internal purposes. If you ever need it - reconsider
1181 * your API.
1182 */
Al Viroaeb5d722008-09-02 15:28:45 -04001183struct block_device *open_by_devnum(dev_t dev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184{
1185 struct block_device *bdev = bdget(dev);
1186 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 if (bdev)
Al Viro572c4892007-10-08 13:24:05 -04001188 err = blkdev_get(bdev, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 return err ? ERR_PTR(err) : bdev;
1190}
1191
1192EXPORT_SYMBOL(open_by_devnum);
1193
Andrew Patterson0c002c22008-09-04 14:27:20 -06001194/**
Andrew Patterson56ade442008-09-04 14:27:40 -06001195 * flush_disk - invalidates all buffer-cache entries on a disk
1196 *
1197 * @bdev: struct block device to be flushed
1198 *
1199 * Invalidates all buffer-cache entries on a disk. It should be called
1200 * when a disk has been changed -- either by a media change or online
1201 * resize.
1202 */
1203static void flush_disk(struct block_device *bdev)
1204{
1205 if (__invalidate_device(bdev)) {
1206 char name[BDEVNAME_SIZE] = "";
1207
1208 if (bdev->bd_disk)
1209 disk_name(bdev->bd_disk, 0, name);
1210 printk(KERN_WARNING "VFS: busy inodes on changed media or "
1211 "resized disk %s\n", name);
1212 }
1213
1214 if (!bdev->bd_disk)
1215 return;
1216 if (disk_partitionable(bdev->bd_disk))
1217 bdev->bd_invalidated = 1;
1218}
1219
1220/**
Randy Dunlap57d1b532008-10-09 10:42:38 +02001221 * check_disk_size_change - checks for disk size change and adjusts bdev size.
Andrew Pattersonc3279d12008-09-04 14:27:25 -06001222 * @disk: struct gendisk to check
1223 * @bdev: struct bdev to adjust.
1224 *
1225 * This routine checks to see if the bdev size does not match the disk size
1226 * and adjusts it if it differs.
1227 */
1228void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
1229{
1230 loff_t disk_size, bdev_size;
1231
1232 disk_size = (loff_t)get_capacity(disk) << 9;
1233 bdev_size = i_size_read(bdev->bd_inode);
1234 if (disk_size != bdev_size) {
1235 char name[BDEVNAME_SIZE];
1236
1237 disk_name(disk, 0, name);
1238 printk(KERN_INFO
1239 "%s: detected capacity change from %lld to %lld\n",
1240 name, bdev_size, disk_size);
1241 i_size_write(bdev->bd_inode, disk_size);
Andrew Patterson608aeef2008-09-04 14:27:45 -06001242 flush_disk(bdev);
Andrew Pattersonc3279d12008-09-04 14:27:25 -06001243 }
1244}
1245EXPORT_SYMBOL(check_disk_size_change);
1246
1247/**
Randy Dunlap57d1b532008-10-09 10:42:38 +02001248 * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
Andrew Patterson0c002c22008-09-04 14:27:20 -06001249 * @disk: struct gendisk to be revalidated
1250 *
1251 * This routine is a wrapper for lower-level driver's revalidate_disk
1252 * call-backs. It is used to do common pre and post operations needed
1253 * for all revalidate_disk operations.
1254 */
1255int revalidate_disk(struct gendisk *disk)
1256{
Andrew Pattersonc3279d12008-09-04 14:27:25 -06001257 struct block_device *bdev;
Andrew Patterson0c002c22008-09-04 14:27:20 -06001258 int ret = 0;
1259
1260 if (disk->fops->revalidate_disk)
1261 ret = disk->fops->revalidate_disk(disk);
1262
Andrew Pattersonc3279d12008-09-04 14:27:25 -06001263 bdev = bdget_disk(disk, 0);
1264 if (!bdev)
1265 return ret;
1266
1267 mutex_lock(&bdev->bd_mutex);
1268 check_disk_size_change(disk, bdev);
1269 mutex_unlock(&bdev->bd_mutex);
1270 bdput(bdev);
Andrew Patterson0c002c22008-09-04 14:27:20 -06001271 return ret;
1272}
1273EXPORT_SYMBOL(revalidate_disk);
1274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275/*
1276 * This routine checks whether a removable media has been changed,
1277 * and invalidates all buffer-cache-entries in that case. This
1278 * is a relatively slow routine, so we have to try to minimize using
1279 * it. Thus it is called only upon a 'mount' or 'open'. This
1280 * is the best way of combining speed and utility, I think.
1281 * People changing diskettes in the middle of an operation deserve
1282 * to lose :-)
1283 */
1284int check_disk_change(struct block_device *bdev)
1285{
1286 struct gendisk *disk = bdev->bd_disk;
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -07001287 const struct block_device_operations *bdops = disk->fops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
1289 if (!bdops->media_changed)
1290 return 0;
1291 if (!bdops->media_changed(bdev->bd_disk))
1292 return 0;
1293
Andrew Patterson56ade442008-09-04 14:27:40 -06001294 flush_disk(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 if (bdops->revalidate_disk)
1296 bdops->revalidate_disk(bdev->bd_disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 return 1;
1298}
1299
1300EXPORT_SYMBOL(check_disk_change);
1301
1302void bd_set_size(struct block_device *bdev, loff_t size)
1303{
Martin K. Petersene1defc42009-05-22 17:17:49 -04001304 unsigned bsize = bdev_logical_block_size(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
1306 bdev->bd_inode->i_size = size;
1307 while (bsize < PAGE_CACHE_SIZE) {
1308 if (size & bsize)
1309 break;
1310 bsize <<= 1;
1311 }
1312 bdev->bd_block_size = bsize;
1313 bdev->bd_inode->i_blkbits = blksize_bits(bsize);
1314}
1315EXPORT_SYMBOL(bd_set_size);
1316
Al Viro9a1c3542008-02-22 20:40:24 -05001317static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
NeilBrown37be4122006-12-08 02:36:16 -08001318
Peter Zijlstra6d740cd2007-02-20 13:58:18 -08001319/*
1320 * bd_mutex locking:
1321 *
1322 * mutex_lock(part->bd_mutex)
1323 * mutex_lock_nested(whole->bd_mutex, 1)
1324 */
1325
Al Viro572c4892007-10-08 13:24:05 -04001326static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 struct gendisk *disk;
Pavel Emelyanov7db9cfd2008-06-05 22:46:27 -07001329 int ret;
Tejun Heocf771cb2008-09-03 09:01:09 +02001330 int partno;
Al Virofe6e9c12008-06-23 08:30:55 -04001331 int perm = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
Al Viro572c4892007-10-08 13:24:05 -04001333 if (mode & FMODE_READ)
Al Virofe6e9c12008-06-23 08:30:55 -04001334 perm |= MAY_READ;
Al Viro572c4892007-10-08 13:24:05 -04001335 if (mode & FMODE_WRITE)
Al Virofe6e9c12008-06-23 08:30:55 -04001336 perm |= MAY_WRITE;
1337 /*
1338 * hooks: /n/, see "layering violations".
1339 */
1340 ret = devcgroup_inode_permission(bdev->bd_inode, perm);
Al Viro82666022008-08-01 05:32:04 -04001341 if (ret != 0) {
1342 bdput(bdev);
Pavel Emelyanov7db9cfd2008-06-05 22:46:27 -07001343 return ret;
Al Viro82666022008-08-01 05:32:04 -04001344 }
Pavel Emelyanov7db9cfd2008-06-05 22:46:27 -07001345
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 lock_kernel();
NeilBrownd3374822009-01-09 08:31:10 +11001347 restart:
Tejun Heo0762b8b2008-08-25 19:56:12 +09001348
Tejun Heo89f97492008-11-05 10:21:06 +01001349 ret = -ENXIO;
Tejun Heocf771cb2008-09-03 09:01:09 +02001350 disk = get_gendisk(bdev->bd_dev, &partno);
Tejun Heo0762b8b2008-08-25 19:56:12 +09001351 if (!disk)
1352 goto out_unlock_kernel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
NeilBrown6796bf52006-12-08 02:36:16 -08001354 mutex_lock_nested(&bdev->bd_mutex, for_part);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 if (!bdev->bd_openers) {
1356 bdev->bd_disk = disk;
1357 bdev->bd_contains = bdev;
Tejun Heocf771cb2008-09-03 09:01:09 +02001358 if (!partno) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 struct backing_dev_info *bdi;
Tejun Heo89f97492008-11-05 10:21:06 +01001360
1361 ret = -ENXIO;
1362 bdev->bd_part = disk_get_part(disk, partno);
1363 if (!bdev->bd_part)
1364 goto out_clear;
1365
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 if (disk->fops->open) {
Al Viro572c4892007-10-08 13:24:05 -04001367 ret = disk->fops->open(bdev, mode);
NeilBrownd3374822009-01-09 08:31:10 +11001368 if (ret == -ERESTARTSYS) {
1369 /* Lost a race with 'disk' being
1370 * deleted, try again.
1371 * See md.c
1372 */
1373 disk_put_part(bdev->bd_part);
1374 bdev->bd_part = NULL;
1375 module_put(disk->fops->owner);
1376 put_disk(disk);
1377 bdev->bd_disk = NULL;
1378 mutex_unlock(&bdev->bd_mutex);
1379 goto restart;
1380 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 if (ret)
Tejun Heo0762b8b2008-08-25 19:56:12 +09001382 goto out_clear;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 }
1384 if (!bdev->bd_openers) {
1385 bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
1386 bdi = blk_get_backing_dev_info(bdev);
1387 if (bdi == NULL)
1388 bdi = &default_backing_dev_info;
1389 bdev->bd_inode->i_data.backing_dev_info = bdi;
1390 }
1391 if (bdev->bd_invalidated)
1392 rescan_partitions(disk, bdev);
1393 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 struct block_device *whole;
1395 whole = bdget_disk(disk, 0);
1396 ret = -ENOMEM;
1397 if (!whole)
Tejun Heo0762b8b2008-08-25 19:56:12 +09001398 goto out_clear;
NeilBrown37be4122006-12-08 02:36:16 -08001399 BUG_ON(for_part);
Al Viro572c4892007-10-08 13:24:05 -04001400 ret = __blkdev_get(whole, mode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 if (ret)
Tejun Heo0762b8b2008-08-25 19:56:12 +09001402 goto out_clear;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 bdev->bd_contains = whole;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 bdev->bd_inode->i_data.backing_dev_info =
1405 whole->bd_inode->i_data.backing_dev_info;
Tejun Heo89f97492008-11-05 10:21:06 +01001406 bdev->bd_part = disk_get_part(disk, partno);
Tejun Heoe71bf0d2008-09-03 09:03:02 +02001407 if (!(disk->flags & GENHD_FL_UP) ||
Tejun Heo89f97492008-11-05 10:21:06 +01001408 !bdev->bd_part || !bdev->bd_part->nr_sects) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 ret = -ENXIO;
Tejun Heo0762b8b2008-08-25 19:56:12 +09001410 goto out_clear;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 }
Tejun Heo89f97492008-11-05 10:21:06 +01001412 bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 }
1414 } else {
Tejun Heo0762b8b2008-08-25 19:56:12 +09001415 module_put(disk->fops->owner);
Neil Brown960cc0f2009-10-26 08:59:17 +01001416 put_disk(disk);
Tejun Heo0762b8b2008-08-25 19:56:12 +09001417 disk = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 if (bdev->bd_contains == bdev) {
1419 if (bdev->bd_disk->fops->open) {
Al Viro572c4892007-10-08 13:24:05 -04001420 ret = bdev->bd_disk->fops->open(bdev, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 if (ret)
Tejun Heo0762b8b2008-08-25 19:56:12 +09001422 goto out_unlock_bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 }
1424 if (bdev->bd_invalidated)
1425 rescan_partitions(bdev->bd_disk, bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 }
1427 }
1428 bdev->bd_openers++;
NeilBrown37be4122006-12-08 02:36:16 -08001429 if (for_part)
1430 bdev->bd_part_count++;
Arjan van de Venc039e312006-03-23 03:00:28 -08001431 mutex_unlock(&bdev->bd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 unlock_kernel();
1433 return 0;
1434
Tejun Heo0762b8b2008-08-25 19:56:12 +09001435 out_clear:
Tejun Heo89f97492008-11-05 10:21:06 +01001436 disk_put_part(bdev->bd_part);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 bdev->bd_disk = NULL;
Tejun Heo0762b8b2008-08-25 19:56:12 +09001438 bdev->bd_part = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
1440 if (bdev != bdev->bd_contains)
Al Viro572c4892007-10-08 13:24:05 -04001441 __blkdev_put(bdev->bd_contains, mode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 bdev->bd_contains = NULL;
Tejun Heo0762b8b2008-08-25 19:56:12 +09001443 out_unlock_bdev:
Arjan van de Venc039e312006-03-23 03:00:28 -08001444 mutex_unlock(&bdev->bd_mutex);
Tejun Heo0762b8b2008-08-25 19:56:12 +09001445 out_unlock_kernel:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 unlock_kernel();
Tejun Heo0762b8b2008-08-25 19:56:12 +09001447
Tejun Heo0762b8b2008-08-25 19:56:12 +09001448 if (disk)
1449 module_put(disk->fops->owner);
1450 put_disk(disk);
1451 bdput(bdev);
1452
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 return ret;
1454}
1455
Al Viro572c4892007-10-08 13:24:05 -04001456int blkdev_get(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457{
Al Viro572c4892007-10-08 13:24:05 -04001458 return __blkdev_get(bdev, mode, 0);
NeilBrown37be4122006-12-08 02:36:16 -08001459}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460EXPORT_SYMBOL(blkdev_get);
1461
1462static int blkdev_open(struct inode * inode, struct file * filp)
1463{
Tejun Heo6b4517a2010-04-07 18:53:59 +09001464 struct block_device *whole = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 struct block_device *bdev;
1466 int res;
1467
1468 /*
1469 * Preserve backwards compatibility and allow large file access
1470 * even if userspace doesn't ask for it explicitly. Some mkfs
1471 * binary needs it. We might want to drop this workaround
1472 * during an unstable branch.
1473 */
1474 filp->f_flags |= O_LARGEFILE;
1475
Al Viro572c4892007-10-08 13:24:05 -04001476 if (filp->f_flags & O_NDELAY)
1477 filp->f_mode |= FMODE_NDELAY;
1478 if (filp->f_flags & O_EXCL)
1479 filp->f_mode |= FMODE_EXCL;
1480 if ((filp->f_flags & O_ACCMODE) == 3)
1481 filp->f_mode |= FMODE_WRITE_IOCTL;
1482
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 bdev = bd_acquire(inode);
Pavel Emelianov6a2aae02006-10-28 10:38:33 -07001484 if (bdev == NULL)
1485 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486
Tejun Heo6b4517a2010-04-07 18:53:59 +09001487 if (filp->f_mode & FMODE_EXCL) {
1488 whole = bd_start_claiming(bdev, filp);
1489 if (IS_ERR(whole)) {
1490 bdput(bdev);
1491 return PTR_ERR(whole);
1492 }
1493 }
1494
Al Viro572c4892007-10-08 13:24:05 -04001495 filp->f_mapping = bdev->bd_inode->i_mapping;
1496
1497 res = blkdev_get(bdev, filp->f_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
Tejun Heo6b4517a2010-04-07 18:53:59 +09001499 if (whole) {
1500 if (res == 0)
Nick Pigginb0018362010-05-26 01:51:19 +10001501 bd_finish_claiming(bdev, whole, filp);
Tejun Heo6b4517a2010-04-07 18:53:59 +09001502 else
1503 bd_abort_claiming(whole, filp);
Christoph Hellwigebbefc02008-11-05 14:54:41 +01001504 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 return res;
1507}
1508
Al Viro9a1c3542008-02-22 20:40:24 -05001509static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001510{
1511 int ret = 0;
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001512 struct gendisk *disk = bdev->bd_disk;
NeilBrown37be4122006-12-08 02:36:16 -08001513 struct block_device *victim = NULL;
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001514
NeilBrown6796bf52006-12-08 02:36:16 -08001515 mutex_lock_nested(&bdev->bd_mutex, for_part);
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001516 lock_kernel();
NeilBrown37be4122006-12-08 02:36:16 -08001517 if (for_part)
1518 bdev->bd_part_count--;
1519
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001520 if (!--bdev->bd_openers) {
1521 sync_blockdev(bdev);
1522 kill_bdev(bdev);
1523 }
1524 if (bdev->bd_contains == bdev) {
1525 if (disk->fops->release)
Al Viro9a1c3542008-02-22 20:40:24 -05001526 ret = disk->fops->release(disk, mode);
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001527 }
1528 if (!bdev->bd_openers) {
1529 struct module *owner = disk->fops->owner;
1530
1531 put_disk(disk);
1532 module_put(owner);
Tejun Heo0762b8b2008-08-25 19:56:12 +09001533 disk_put_part(bdev->bd_part);
1534 bdev->bd_part = NULL;
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001535 bdev->bd_disk = NULL;
1536 bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
NeilBrown37be4122006-12-08 02:36:16 -08001537 if (bdev != bdev->bd_contains)
1538 victim = bdev->bd_contains;
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001539 bdev->bd_contains = NULL;
1540 }
1541 unlock_kernel();
1542 mutex_unlock(&bdev->bd_mutex);
1543 bdput(bdev);
NeilBrown37be4122006-12-08 02:36:16 -08001544 if (victim)
Al Viro9a1c3542008-02-22 20:40:24 -05001545 __blkdev_put(victim, mode, 1);
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001546 return ret;
1547}
1548
Al Viro9a1c3542008-02-22 20:40:24 -05001549int blkdev_put(struct block_device *bdev, fmode_t mode)
NeilBrown37be4122006-12-08 02:36:16 -08001550{
Al Viro9a1c3542008-02-22 20:40:24 -05001551 return __blkdev_put(bdev, mode, 0);
NeilBrown37be4122006-12-08 02:36:16 -08001552}
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001553EXPORT_SYMBOL(blkdev_put);
1554
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555static int blkdev_close(struct inode * inode, struct file * filp)
1556{
1557 struct block_device *bdev = I_BDEV(filp->f_mapping->host);
1558 if (bdev->bd_holder == filp)
1559 bd_release(bdev);
Al Viro9a1c3542008-02-22 20:40:24 -05001560 return blkdev_put(bdev, filp->f_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561}
1562
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -07001563static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564{
Al Viro56b26ad2008-09-19 03:17:36 -04001565 struct block_device *bdev = I_BDEV(file->f_mapping->host);
1566 fmode_t mode = file->f_mode;
Christoph Hellwigfd4ce1a2008-11-05 14:58:42 +01001567
1568 /*
1569 * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
1570 * to updated it before every ioctl.
1571 */
Al Viro56b26ad2008-09-19 03:17:36 -04001572 if (file->f_flags & O_NDELAY)
Christoph Hellwigfd4ce1a2008-11-05 14:58:42 +01001573 mode |= FMODE_NDELAY;
1574 else
1575 mode &= ~FMODE_NDELAY;
1576
Al Viro56b26ad2008-09-19 03:17:36 -04001577 return blkdev_ioctl(bdev, mode, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578}
1579
Theodore Ts'o87d8fe12009-01-03 09:47:09 -05001580/*
Christoph Hellwigeef99382009-08-20 17:43:41 +02001581 * Write data to the block device. Only intended for the block device itself
1582 * and the raw driver which basically is a fake block device.
1583 *
1584 * Does not take i_mutex for the write and thus is not for general purpose
1585 * use.
1586 */
1587ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
1588 unsigned long nr_segs, loff_t pos)
1589{
1590 struct file *file = iocb->ki_filp;
1591 ssize_t ret;
1592
1593 BUG_ON(iocb->ki_pos != pos);
1594
1595 ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
1596 if (ret > 0 || ret == -EIOCBQUEUED) {
1597 ssize_t err;
1598
1599 err = generic_write_sync(file, pos, ret);
1600 if (err < 0 && ret > 0)
1601 ret = err;
1602 }
1603 return ret;
1604}
1605EXPORT_SYMBOL_GPL(blkdev_aio_write);
1606
1607/*
Theodore Ts'o87d8fe12009-01-03 09:47:09 -05001608 * Try to release a page associated with block device when the system
1609 * is under memory pressure.
1610 */
1611static int blkdev_releasepage(struct page *page, gfp_t wait)
1612{
1613 struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
1614
1615 if (super && super->s_op->bdev_try_to_free_page)
1616 return super->s_op->bdev_try_to_free_page(super, page, wait);
1617
1618 return try_to_free_buffers(page);
1619}
1620
Adrian Bunk4c54ac62008-02-18 13:48:31 +01001621static const struct address_space_operations def_blk_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 .readpage = blkdev_readpage,
1623 .writepage = blkdev_writepage,
1624 .sync_page = block_sync_page,
Nick Piggin6272b5a2007-10-16 01:25:04 -07001625 .write_begin = blkdev_write_begin,
1626 .write_end = blkdev_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 .writepages = generic_writepages,
Theodore Ts'o87d8fe12009-01-03 09:47:09 -05001628 .releasepage = blkdev_releasepage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 .direct_IO = blkdev_direct_IO,
1630};
1631
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001632const struct file_operations def_blk_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 .open = blkdev_open,
1634 .release = blkdev_close,
1635 .llseek = block_llseek,
Badari Pulavarty543ade12006-09-30 23:28:48 -07001636 .read = do_sync_read,
1637 .write = do_sync_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 .aio_read = generic_file_aio_read,
Christoph Hellwigeef99382009-08-20 17:43:41 +02001639 .aio_write = blkdev_aio_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 .mmap = generic_file_mmap,
Andrew Mortonb1dd3b22010-04-06 14:35:00 -07001641 .fsync = blkdev_fsync,
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -07001642 .unlocked_ioctl = block_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643#ifdef CONFIG_COMPAT
1644 .compat_ioctl = compat_blkdev_ioctl,
1645#endif
Jens Axboe7f9c51f2006-05-01 19:59:32 +02001646 .splice_read = generic_file_splice_read,
1647 .splice_write = generic_file_splice_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648};
1649
1650int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
1651{
1652 int res;
1653 mm_segment_t old_fs = get_fs();
1654 set_fs(KERNEL_DS);
Al Viro56b26ad2008-09-19 03:17:36 -04001655 res = blkdev_ioctl(bdev, 0, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 set_fs(old_fs);
1657 return res;
1658}
1659
1660EXPORT_SYMBOL(ioctl_by_bdev);
1661
1662/**
1663 * lookup_bdev - lookup a struct block_device by name
Randy Dunlap94e29592009-01-06 14:41:15 -08001664 * @pathname: special file representing the block device
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 *
Randy Dunlap57d1b532008-10-09 10:42:38 +02001666 * Get a reference to the blockdevice at @pathname in the current
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 * namespace if possible and return it. Return ERR_PTR(error)
1668 * otherwise.
1669 */
Al Viro421748e2008-08-02 01:04:36 -04001670struct block_device *lookup_bdev(const char *pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671{
1672 struct block_device *bdev;
1673 struct inode *inode;
Al Viro421748e2008-08-02 01:04:36 -04001674 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 int error;
1676
Al Viro421748e2008-08-02 01:04:36 -04001677 if (!pathname || !*pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 return ERR_PTR(-EINVAL);
1679
Al Viro421748e2008-08-02 01:04:36 -04001680 error = kern_path(pathname, LOOKUP_FOLLOW, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 if (error)
1682 return ERR_PTR(error);
1683
Al Viro421748e2008-08-02 01:04:36 -04001684 inode = path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 error = -ENOTBLK;
1686 if (!S_ISBLK(inode->i_mode))
1687 goto fail;
1688 error = -EACCES;
Al Viro421748e2008-08-02 01:04:36 -04001689 if (path.mnt->mnt_flags & MNT_NODEV)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 goto fail;
1691 error = -ENOMEM;
1692 bdev = bd_acquire(inode);
1693 if (!bdev)
1694 goto fail;
1695out:
Al Viro421748e2008-08-02 01:04:36 -04001696 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 return bdev;
1698fail:
1699 bdev = ERR_PTR(error);
1700 goto out;
1701}
Al Virod5686b42008-08-01 05:00:11 -04001702EXPORT_SYMBOL(lookup_bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
1704/**
Al Viro30c40d22008-02-22 19:50:45 -05001705 * open_bdev_exclusive - open a block device by name and set it up for use
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 *
1707 * @path: special file representing the block device
Al Viro30c40d22008-02-22 19:50:45 -05001708 * @mode: FMODE_... combination to pass be used
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 * @holder: owner for exclusion
1710 *
1711 * Open the blockdevice described by the special file at @path, claim it
1712 * for the @holder.
1713 */
Al Viro30c40d22008-02-22 19:50:45 -05001714struct block_device *open_bdev_exclusive(const char *path, fmode_t mode, void *holder)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715{
Tejun Heo6b4517a2010-04-07 18:53:59 +09001716 struct block_device *bdev, *whole;
1717 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
1719 bdev = lookup_bdev(path);
1720 if (IS_ERR(bdev))
1721 return bdev;
1722
Tejun Heo6b4517a2010-04-07 18:53:59 +09001723 whole = bd_start_claiming(bdev, holder);
1724 if (IS_ERR(whole)) {
1725 bdput(bdev);
1726 return whole;
1727 }
1728
Al Viro572c4892007-10-08 13:24:05 -04001729 error = blkdev_get(bdev, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 if (error)
Tejun Heo6b4517a2010-04-07 18:53:59 +09001731 goto out_abort_claiming;
1732
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 error = -EACCES;
Al Viro30c40d22008-02-22 19:50:45 -05001734 if ((mode & FMODE_WRITE) && bdev_read_only(bdev))
Tejun Heo6b4517a2010-04-07 18:53:59 +09001735 goto out_blkdev_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
Nick Pigginb0018362010-05-26 01:51:19 +10001737 bd_finish_claiming(bdev, whole, holder);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 return bdev;
Tejun Heo6b4517a2010-04-07 18:53:59 +09001739
1740out_blkdev_put:
Al Viro9a1c3542008-02-22 20:40:24 -05001741 blkdev_put(bdev, mode);
Tejun Heo6b4517a2010-04-07 18:53:59 +09001742out_abort_claiming:
1743 bd_abort_claiming(whole, holder);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 return ERR_PTR(error);
1745}
1746
Al Viro30c40d22008-02-22 19:50:45 -05001747EXPORT_SYMBOL(open_bdev_exclusive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748
1749/**
Al Viro30c40d22008-02-22 19:50:45 -05001750 * close_bdev_exclusive - close a blockdevice opened by open_bdev_exclusive()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 *
1752 * @bdev: blockdevice to close
Al Viro30c40d22008-02-22 19:50:45 -05001753 * @mode: mode, must match that used to open.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 *
Al Viro30c40d22008-02-22 19:50:45 -05001755 * This is the counterpart to open_bdev_exclusive().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 */
Al Viro30c40d22008-02-22 19:50:45 -05001757void close_bdev_exclusive(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758{
1759 bd_release(bdev);
Al Viro30c40d22008-02-22 19:50:45 -05001760 blkdev_put(bdev, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761}
1762
Al Viro30c40d22008-02-22 19:50:45 -05001763EXPORT_SYMBOL(close_bdev_exclusive);
David Howellsb71e8a42006-08-29 19:06:11 +01001764
1765int __invalidate_device(struct block_device *bdev)
1766{
1767 struct super_block *sb = get_super(bdev);
1768 int res = 0;
1769
1770 if (sb) {
1771 /*
1772 * no need to lock the super, get_super holds the
1773 * read mutex so the filesystem cannot go away
1774 * under us (->put_super runs with the write lock
1775 * hold).
1776 */
1777 shrink_dcache_sb(sb);
1778 res = invalidate_inodes(sb);
1779 drop_super(sb);
1780 }
Peter Zijlstraf98393a2007-05-06 14:49:54 -07001781 invalidate_bdev(bdev);
David Howellsb71e8a42006-08-29 19:06:11 +01001782 return res;
1783}
1784EXPORT_SYMBOL(__invalidate_device);