blob: b3c1d3dae77d06fcde3fa3ecf36b2af9e2b25d85 [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>
Pavel Emelyanov7db9cfd2008-06-05 22:46:27 -070014#include <linux/device_cgroup.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/highmem.h>
16#include <linux/blkdev.h>
17#include <linux/module.h>
18#include <linux/blkpg.h>
Muthu Kumarb502bd12012-03-23 15:01:50 -070019#include <linux/magic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/buffer_head.h>
Al Viroff01bb42011-09-16 02:31:11 -040021#include <linux/swap.h>
Nick Piggin585d3bc2009-02-25 10:44:19 +010022#include <linux/pagevec.h>
David Howells811d7362006-08-29 19:06:09 +010023#include <linux/writeback.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/mpage.h>
25#include <linux/mount.h>
26#include <linux/uio.h>
27#include <linux/namei.h>
Vignesh Babu BM1368c4f2007-05-08 00:24:32 -070028#include <linux/log2.h>
Al Viroff01bb42011-09-16 02:31:11 -040029#include <linux/cleancache.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/uaccess.h>
David Howells07f3f05c2006-09-30 20:52:18 +020031#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33struct bdev_inode {
34 struct block_device bdev;
35 struct inode vfs_inode;
36};
37
Adrian Bunk4c54ac62008-02-18 13:48:31 +010038static const struct address_space_operations def_blk_aops;
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040static inline struct bdev_inode *BDEV_I(struct inode *inode)
41{
42 return container_of(inode, struct bdev_inode, vfs_inode);
43}
44
45inline struct block_device *I_BDEV(struct inode *inode)
46{
47 return &BDEV_I(inode)->bdev;
48}
Linus Torvalds1da177e2005-04-16 15:20:36 -070049EXPORT_SYMBOL(I_BDEV);
50
Dave Chinnera5491e02010-10-21 11:49:26 +110051/*
Christoph Hellwigf758eea2011-04-21 18:19:44 -060052 * Move the inode from its current bdi to a new bdi. If the inode is dirty we
53 * need to move it onto the dirty list of @dst so that the inode is always on
54 * the right list.
Dave Chinnera5491e02010-10-21 11:49:26 +110055 */
56static void bdev_inode_switch_bdi(struct inode *inode,
57 struct backing_dev_info *dst)
58{
Christoph Hellwigf758eea2011-04-21 18:19:44 -060059 struct backing_dev_info *old = inode->i_data.backing_dev_info;
60
61 if (unlikely(dst == old)) /* deadlock avoidance */
62 return;
63 bdi_lock_two(&old->wb, &dst->wb);
Dave Chinner250df6e2011-03-22 22:23:36 +110064 spin_lock(&inode->i_lock);
Dave Chinnera5491e02010-10-21 11:49:26 +110065 inode->i_data.backing_dev_info = dst;
66 if (inode->i_state & I_DIRTY)
Nick Piggin7ccf19a2010-10-21 11:49:30 +110067 list_move(&inode->i_wb_list, &dst->wb.b_dirty);
Dave Chinner250df6e2011-03-22 22:23:36 +110068 spin_unlock(&inode->i_lock);
Christoph Hellwigf758eea2011-04-21 18:19:44 -060069 spin_unlock(&old->wb.list_lock);
70 spin_unlock(&dst->wb.list_lock);
Dave Chinnera5491e02010-10-21 11:49:26 +110071}
72
Jeff Moyer080399a2012-05-11 16:34:10 +020073sector_t blkdev_max_block(struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
75 sector_t retval = ~((sector_t)0);
76 loff_t sz = i_size_read(bdev->bd_inode);
77
78 if (sz) {
79 unsigned int size = block_size(bdev);
80 unsigned int sizebits = blksize_bits(size);
81 retval = (sz >> sizebits);
82 }
83 return retval;
84}
85
Peter Zijlstraf9a14392007-05-06 14:49:55 -070086/* Kill _all_ buffers and pagecache , dirty or not.. */
Al Viroff01bb42011-09-16 02:31:11 -040087void kill_bdev(struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
Al Viroff01bb42011-09-16 02:31:11 -040089 struct address_space *mapping = bdev->bd_inode->i_mapping;
90
91 if (mapping->nrpages == 0)
Peter Zijlstraf9a14392007-05-06 14:49:55 -070092 return;
Al Viroff01bb42011-09-16 02:31:11 -040093
Peter Zijlstraf9a14392007-05-06 14:49:55 -070094 invalidate_bh_lrus();
Al Viroff01bb42011-09-16 02:31:11 -040095 truncate_inode_pages(mapping, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096}
Al Viroff01bb42011-09-16 02:31:11 -040097EXPORT_SYMBOL(kill_bdev);
98
99/* Invalidate clean unused buffers and pagecache. */
100void invalidate_bdev(struct block_device *bdev)
101{
102 struct address_space *mapping = bdev->bd_inode->i_mapping;
103
104 if (mapping->nrpages == 0)
105 return;
106
107 invalidate_bh_lrus();
108 lru_add_drain_all(); /* make sure all lru add caches are flushed */
109 invalidate_mapping_pages(mapping, 0, -1);
110 /* 99% of the time, we don't need to flush the cleancache on the bdev.
111 * But, for the strange corners, lets be cautious
112 */
Dan Magenheimer31677602011-09-21 11:56:28 -0400113 cleancache_invalidate_inode(mapping);
Al Viroff01bb42011-09-16 02:31:11 -0400114}
115EXPORT_SYMBOL(invalidate_bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117int set_blocksize(struct block_device *bdev, int size)
118{
Mikulas Patockab87570f2012-09-26 07:46:40 +0200119 struct address_space *mapping;
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 /* Size must be a power of two, and between 512 and PAGE_SIZE */
Vignesh Babu BM1368c4f2007-05-08 00:24:32 -0700122 if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 return -EINVAL;
124
125 /* Size cannot be smaller than the size supported by the device */
Martin K. Petersene1defc42009-05-22 17:17:49 -0400126 if (size < bdev_logical_block_size(bdev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 return -EINVAL;
128
Mikulas Patockab87570f2012-09-26 07:46:40 +0200129 /* Prevent starting I/O or mapping the device */
Mikulas Patocka62ac6652012-09-26 07:46:43 +0200130 percpu_down_write(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +0200131
132 /* Check that the block device is not memory mapped */
133 mapping = bdev->bd_inode->i_mapping;
134 mutex_lock(&mapping->i_mmap_mutex);
Linus Torvaldsce40be72012-10-11 09:04:23 +0900135 if (mapping_mapped(mapping)) {
Mikulas Patockab87570f2012-09-26 07:46:40 +0200136 mutex_unlock(&mapping->i_mmap_mutex);
Mikulas Patocka62ac6652012-09-26 07:46:43 +0200137 percpu_up_write(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +0200138 return -EBUSY;
139 }
140 mutex_unlock(&mapping->i_mmap_mutex);
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 /* Don't change the size if it is same as current */
143 if (bdev->bd_block_size != size) {
144 sync_blockdev(bdev);
145 bdev->bd_block_size = size;
146 bdev->bd_inode->i_blkbits = blksize_bits(size);
147 kill_bdev(bdev);
148 }
Mikulas Patockab87570f2012-09-26 07:46:40 +0200149
Mikulas Patocka62ac6652012-09-26 07:46:43 +0200150 percpu_up_write(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +0200151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 return 0;
153}
154
155EXPORT_SYMBOL(set_blocksize);
156
157int sb_set_blocksize(struct super_block *sb, int size)
158{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 if (set_blocksize(sb->s_bdev, size))
160 return 0;
161 /* If we get here, we know size is power of two
162 * and it's value is between 512 and PAGE_SIZE */
163 sb->s_blocksize = size;
Coywolf Qi Hunt38885bd2006-03-24 03:18:05 -0800164 sb->s_blocksize_bits = blksize_bits(size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 return sb->s_blocksize;
166}
167
168EXPORT_SYMBOL(sb_set_blocksize);
169
170int sb_min_blocksize(struct super_block *sb, int size)
171{
Martin K. Petersene1defc42009-05-22 17:17:49 -0400172 int minsize = bdev_logical_block_size(sb->s_bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 if (size < minsize)
174 size = minsize;
175 return sb_set_blocksize(sb, size);
176}
177
178EXPORT_SYMBOL(sb_min_blocksize);
179
180static int
181blkdev_get_block(struct inode *inode, sector_t iblock,
182 struct buffer_head *bh, int create)
183{
Jeff Moyer080399a2012-05-11 16:34:10 +0200184 if (iblock >= blkdev_max_block(I_BDEV(inode))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 if (create)
186 return -EIO;
187
188 /*
189 * for reads, we're just trying to fill a partial page.
190 * return a hole, they will have to call get_block again
191 * before they can fill it, and they will get -EIO at that
192 * time
193 */
194 return 0;
195 }
196 bh->b_bdev = I_BDEV(inode);
197 bh->b_blocknr = iblock;
198 set_buffer_mapped(bh);
199 return 0;
200}
201
Andrew Mortonb2e895d2007-02-03 01:14:01 -0800202static int
203blkdev_get_blocks(struct inode *inode, sector_t iblock,
204 struct buffer_head *bh, int create)
205{
Jeff Moyer080399a2012-05-11 16:34:10 +0200206 sector_t end_block = blkdev_max_block(I_BDEV(inode));
Andrew Mortonb2e895d2007-02-03 01:14:01 -0800207 unsigned long max_blocks = bh->b_size >> inode->i_blkbits;
208
209 if ((iblock + max_blocks) > end_block) {
210 max_blocks = end_block - iblock;
211 if ((long)max_blocks <= 0) {
212 if (create)
213 return -EIO; /* write fully beyond EOF */
214 /*
215 * It is a read which is fully beyond EOF. We return
216 * a !buffer_mapped buffer
217 */
218 max_blocks = 0;
219 }
220 }
221
222 bh->b_bdev = I_BDEV(inode);
223 bh->b_blocknr = iblock;
224 bh->b_size = max_blocks << inode->i_blkbits;
225 if (max_blocks)
226 set_buffer_mapped(bh);
227 return 0;
228}
229
230static ssize_t
231blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
232 loff_t offset, unsigned long nr_segs)
233{
234 struct file *file = iocb->ki_filp;
235 struct inode *inode = file->f_mapping->host;
236
Christoph Hellwigeafdc7d2010-06-04 11:29:53 +0200237 return __blockdev_direct_IO(rw, iocb, inode, I_BDEV(inode), iov, offset,
238 nr_segs, blkdev_get_blocks, NULL, NULL, 0);
Andrew Mortonb2e895d2007-02-03 01:14:01 -0800239}
240
Jan Kara5cee5812009-04-27 16:43:51 +0200241int __sync_blockdev(struct block_device *bdev, int wait)
242{
243 if (!bdev)
244 return 0;
245 if (!wait)
246 return filemap_flush(bdev->bd_inode->i_mapping);
247 return filemap_write_and_wait(bdev->bd_inode->i_mapping);
248}
249
Nick Piggin585d3bc2009-02-25 10:44:19 +0100250/*
251 * Write out and wait upon all the dirty data associated with a block
252 * device via its mapping. Does not take the superblock lock.
253 */
254int sync_blockdev(struct block_device *bdev)
255{
Jan Kara5cee5812009-04-27 16:43:51 +0200256 return __sync_blockdev(bdev, 1);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100257}
258EXPORT_SYMBOL(sync_blockdev);
259
260/*
261 * Write out and wait upon all dirty data associated with this
262 * device. Filesystem data as well as the underlying block
263 * device. Takes the superblock lock.
264 */
265int fsync_bdev(struct block_device *bdev)
266{
267 struct super_block *sb = get_super(bdev);
268 if (sb) {
Jan Kara60b06802009-04-27 16:43:53 +0200269 int res = sync_filesystem(sb);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100270 drop_super(sb);
271 return res;
272 }
273 return sync_blockdev(bdev);
274}
Al Viro47e44912009-04-01 07:07:16 -0400275EXPORT_SYMBOL(fsync_bdev);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100276
277/**
278 * freeze_bdev -- lock a filesystem and force it into a consistent state
279 * @bdev: blockdevice to lock
280 *
Nick Piggin585d3bc2009-02-25 10:44:19 +0100281 * If a superblock is found on this device, we take the s_umount semaphore
282 * on it to make sure nobody unmounts until the snapshot creation is done.
283 * The reference counter (bd_fsfreeze_count) guarantees that only the last
284 * unfreeze process can unfreeze the frozen filesystem actually when multiple
285 * freeze requests arrive simultaneously. It counts up in freeze_bdev() and
286 * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
287 * actually.
288 */
289struct super_block *freeze_bdev(struct block_device *bdev)
290{
291 struct super_block *sb;
292 int error = 0;
293
294 mutex_lock(&bdev->bd_fsfreeze_mutex);
Christoph Hellwig45042302009-08-03 23:28:35 +0200295 if (++bdev->bd_fsfreeze_count > 1) {
296 /*
297 * We don't even need to grab a reference - the first call
298 * to freeze_bdev grab an active reference and only the last
299 * thaw_bdev drops it.
300 */
Nick Piggin585d3bc2009-02-25 10:44:19 +0100301 sb = get_super(bdev);
Christoph Hellwig45042302009-08-03 23:28:35 +0200302 drop_super(sb);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100303 mutex_unlock(&bdev->bd_fsfreeze_mutex);
304 return sb;
305 }
Nick Piggin585d3bc2009-02-25 10:44:19 +0100306
Christoph Hellwig45042302009-08-03 23:28:35 +0200307 sb = get_active_super(bdev);
308 if (!sb)
309 goto out;
Josef Bacik18e9e512010-03-23 10:34:56 -0400310 error = freeze_super(sb);
311 if (error) {
312 deactivate_super(sb);
313 bdev->bd_fsfreeze_count--;
Christoph Hellwig45042302009-08-03 23:28:35 +0200314 mutex_unlock(&bdev->bd_fsfreeze_mutex);
Josef Bacik18e9e512010-03-23 10:34:56 -0400315 return ERR_PTR(error);
Nick Piggin585d3bc2009-02-25 10:44:19 +0100316 }
Josef Bacik18e9e512010-03-23 10:34:56 -0400317 deactivate_super(sb);
Christoph Hellwig45042302009-08-03 23:28:35 +0200318 out:
Nick Piggin585d3bc2009-02-25 10:44:19 +0100319 sync_blockdev(bdev);
320 mutex_unlock(&bdev->bd_fsfreeze_mutex);
Christoph Hellwig4fadd7b2009-08-03 23:28:06 +0200321 return sb; /* thaw_bdev releases s->s_umount */
Nick Piggin585d3bc2009-02-25 10:44:19 +0100322}
323EXPORT_SYMBOL(freeze_bdev);
324
325/**
326 * thaw_bdev -- unlock filesystem
327 * @bdev: blockdevice to unlock
328 * @sb: associated superblock
329 *
330 * Unlocks the filesystem and marks it writeable again after freeze_bdev().
331 */
332int thaw_bdev(struct block_device *bdev, struct super_block *sb)
333{
Christoph Hellwig45042302009-08-03 23:28:35 +0200334 int error = -EINVAL;
Nick Piggin585d3bc2009-02-25 10:44:19 +0100335
336 mutex_lock(&bdev->bd_fsfreeze_mutex);
Christoph Hellwig45042302009-08-03 23:28:35 +0200337 if (!bdev->bd_fsfreeze_count)
Josef Bacik18e9e512010-03-23 10:34:56 -0400338 goto out;
Nick Piggin585d3bc2009-02-25 10:44:19 +0100339
Christoph Hellwig45042302009-08-03 23:28:35 +0200340 error = 0;
341 if (--bdev->bd_fsfreeze_count > 0)
Josef Bacik18e9e512010-03-23 10:34:56 -0400342 goto out;
Nick Piggin585d3bc2009-02-25 10:44:19 +0100343
Christoph Hellwig45042302009-08-03 23:28:35 +0200344 if (!sb)
Josef Bacik18e9e512010-03-23 10:34:56 -0400345 goto out;
Christoph Hellwig45042302009-08-03 23:28:35 +0200346
Josef Bacik18e9e512010-03-23 10:34:56 -0400347 error = thaw_super(sb);
348 if (error) {
349 bdev->bd_fsfreeze_count++;
350 mutex_unlock(&bdev->bd_fsfreeze_mutex);
351 return error;
Nick Piggin585d3bc2009-02-25 10:44:19 +0100352 }
Josef Bacik18e9e512010-03-23 10:34:56 -0400353out:
Nick Piggin585d3bc2009-02-25 10:44:19 +0100354 mutex_unlock(&bdev->bd_fsfreeze_mutex);
355 return 0;
356}
357EXPORT_SYMBOL(thaw_bdev);
358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
360{
361 return block_write_full_page(page, blkdev_get_block, wbc);
362}
363
364static int blkdev_readpage(struct file * file, struct page * page)
365{
366 return block_read_full_page(page, blkdev_get_block);
367}
368
Nick Piggin6272b5a2007-10-16 01:25:04 -0700369static int blkdev_write_begin(struct file *file, struct address_space *mapping,
370 loff_t pos, unsigned len, unsigned flags,
371 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
Christoph Hellwig155130a2010-06-04 11:29:58 +0200373 return block_write_begin(mapping, pos, len, flags, pagep,
374 blkdev_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375}
376
Nick Piggin6272b5a2007-10-16 01:25:04 -0700377static int blkdev_write_end(struct file *file, struct address_space *mapping,
378 loff_t pos, unsigned len, unsigned copied,
379 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Nick Piggin6272b5a2007-10-16 01:25:04 -0700381 int ret;
382 ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
383
384 unlock_page(page);
385 page_cache_release(page);
386
387 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388}
389
390/*
391 * private llseek:
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800392 * for a block special file file->f_path.dentry->d_inode->i_size is zero
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 * so we compute the size by hand (just as in block_read/write above)
394 */
395static loff_t block_llseek(struct file *file, loff_t offset, int origin)
396{
397 struct inode *bd_inode = file->f_mapping->host;
398 loff_t size;
399 loff_t retval;
400
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800401 mutex_lock(&bd_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 size = i_size_read(bd_inode);
403
Josef Bacik06222e42011-07-18 13:21:38 -0400404 retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 switch (origin) {
Josef Bacik06222e42011-07-18 13:21:38 -0400406 case SEEK_END:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 offset += size;
408 break;
Josef Bacik06222e42011-07-18 13:21:38 -0400409 case SEEK_CUR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 offset += file->f_pos;
Josef Bacik06222e42011-07-18 13:21:38 -0400411 case SEEK_SET:
412 break;
413 default:
414 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 if (offset >= 0 && offset <= size) {
417 if (offset != file->f_pos) {
418 file->f_pos = offset;
419 }
420 retval = offset;
421 }
Josef Bacik06222e42011-07-18 13:21:38 -0400422out:
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800423 mutex_unlock(&bd_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 return retval;
425}
426
Josef Bacik02c24a82011-07-16 20:44:56 -0400427int blkdev_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428{
Anton Blanchardb8af67e2010-04-23 13:18:06 -0400429 struct inode *bd_inode = filp->f_mapping->host;
430 struct block_device *bdev = I_BDEV(bd_inode);
Christoph Hellwigab0a9732009-10-29 14:14:04 +0100431 int error;
Rafael J. Wysockida5aa862011-08-02 02:17:48 +0200432
433 error = filemap_write_and_wait_range(filp->f_mapping, start, end);
434 if (error)
435 return error;
Christoph Hellwigab0a9732009-10-29 14:14:04 +0100436
Anton Blanchardb8af67e2010-04-23 13:18:06 -0400437 /*
438 * There is no need to serialise calls to blkdev_issue_flush with
439 * i_mutex and doing so causes performance issues with concurrent
440 * O_SYNC writers to a block device.
441 */
Christoph Hellwigdd3932e2010-09-16 20:51:46 +0200442 error = blkdev_issue_flush(bdev, GFP_KERNEL, NULL);
Christoph Hellwigab0a9732009-10-29 14:14:04 +0100443 if (error == -EOPNOTSUPP)
444 error = 0;
Anton Blanchardb8af67e2010-04-23 13:18:06 -0400445
Christoph Hellwigab0a9732009-10-29 14:14:04 +0100446 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447}
Andrew Mortonb1dd3b22010-04-06 14:35:00 -0700448EXPORT_SYMBOL(blkdev_fsync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
450/*
451 * pseudo-fs
452 */
453
454static __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
Christoph Lametere18b8902006-12-06 20:33:20 -0800455static struct kmem_cache * bdev_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457static struct inode *bdev_alloc_inode(struct super_block *sb)
458{
Christoph Lametere94b1762006-12-06 20:33:17 -0800459 struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 if (!ei)
461 return NULL;
Mikulas Patocka62ac6652012-09-26 07:46:43 +0200462
463 if (unlikely(percpu_init_rwsem(&ei->bdev.bd_block_size_semaphore))) {
464 kmem_cache_free(bdev_cachep, ei);
465 return NULL;
466 }
467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 return &ei->vfs_inode;
469}
470
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100471static void bdev_i_callback(struct rcu_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100473 struct inode *inode = container_of(head, struct inode, i_rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 struct bdev_inode *bdi = BDEV_I(inode);
475
Mikulas Patocka62ac6652012-09-26 07:46:43 +0200476 percpu_free_rwsem(&bdi->bdev.bd_block_size_semaphore);
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 kmem_cache_free(bdev_cachep, bdi);
479}
480
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100481static void bdev_destroy_inode(struct inode *inode)
482{
483 call_rcu(&inode->i_rcu, bdev_i_callback);
484}
485
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700486static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
488 struct bdev_inode *ei = (struct bdev_inode *) foo;
489 struct block_device *bdev = &ei->bdev;
490
Christoph Lametera35afb82007-05-16 22:10:57 -0700491 memset(bdev, 0, sizeof(*bdev));
492 mutex_init(&bdev->bd_mutex);
Christoph Lametera35afb82007-05-16 22:10:57 -0700493 INIT_LIST_HEAD(&bdev->bd_inodes);
494 INIT_LIST_HEAD(&bdev->bd_list);
Tejun Heo49731ba2011-01-14 18:43:57 +0100495#ifdef CONFIG_SYSFS
496 INIT_LIST_HEAD(&bdev->bd_holder_disks);
497#endif
Christoph Lametera35afb82007-05-16 22:10:57 -0700498 inode_init_once(&ei->vfs_inode);
Takashi Satofcccf502009-01-09 16:40:59 -0800499 /* Initialize mutex for freeze. */
500 mutex_init(&bdev->bd_fsfreeze_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
503static inline void __bd_forget(struct inode *inode)
504{
505 list_del_init(&inode->i_devices);
506 inode->i_bdev = NULL;
507 inode->i_mapping = &inode->i_data;
508}
509
Al Virob57922d2010-06-07 14:34:48 -0400510static void bdev_evict_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
512 struct block_device *bdev = &BDEV_I(inode)->bdev;
513 struct list_head *p;
Al Virob57922d2010-06-07 14:34:48 -0400514 truncate_inode_pages(&inode->i_data, 0);
515 invalidate_inode_buffers(inode); /* is it needed here? */
Jan Karadbd57682012-05-03 14:48:02 +0200516 clear_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 spin_lock(&bdev_lock);
518 while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
519 __bd_forget(list_entry(p, struct inode, i_devices));
520 }
521 list_del_init(&bdev->bd_list);
522 spin_unlock(&bdev_lock);
523}
524
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800525static const struct super_operations bdev_sops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 .statfs = simple_statfs,
527 .alloc_inode = bdev_alloc_inode,
528 .destroy_inode = bdev_destroy_inode,
529 .drop_inode = generic_delete_inode,
Al Virob57922d2010-06-07 14:34:48 -0400530 .evict_inode = bdev_evict_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531};
532
Al Viro51139ad2010-07-25 23:47:46 +0400533static struct dentry *bd_mount(struct file_system_type *fs_type,
534 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
Muthu Kumarb502bd12012-03-23 15:01:50 -0700536 return mount_pseudo(fs_type, "bdev:", &bdev_sops, NULL, BDEVFS_MAGIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
538
539static struct file_system_type bd_type = {
540 .name = "bdev",
Al Viro51139ad2010-07-25 23:47:46 +0400541 .mount = bd_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 .kill_sb = kill_anon_super,
543};
544
Al Virof47ec3f2011-11-21 21:15:42 -0500545static struct super_block *blockdev_superblock __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
547void __init bdev_cache_init(void)
548{
549 int err;
Sergey Senozhatskyace85772012-01-10 02:43:59 +0300550 static struct vfsmount *bd_mnt;
Denis ChengRqc2acf7b2008-12-01 14:34:56 -0800551
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800553 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
554 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +0900555 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 err = register_filesystem(&bd_type);
557 if (err)
558 panic("Cannot register bdev pseudo-fs");
559 bd_mnt = kern_mount(&bd_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 if (IS_ERR(bd_mnt))
561 panic("Cannot create bdev pseudo-fs");
Sergey Senozhatskyace85772012-01-10 02:43:59 +0300562 blockdev_superblock = bd_mnt->mnt_sb; /* For writeback */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563}
564
565/*
566 * Most likely _very_ bad one - but then it's hardly critical for small
567 * /dev and can be fixed when somebody will need really large one.
568 * Keep in mind that it will be fed through icache hash function too.
569 */
570static inline unsigned long hash(dev_t dev)
571{
572 return MAJOR(dev)+MINOR(dev);
573}
574
575static int bdev_test(struct inode *inode, void *data)
576{
577 return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
578}
579
580static int bdev_set(struct inode *inode, void *data)
581{
582 BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
583 return 0;
584}
585
586static LIST_HEAD(all_bdevs);
587
588struct block_device *bdget(dev_t dev)
589{
590 struct block_device *bdev;
591 struct inode *inode;
592
Denis ChengRqc2acf7b2008-12-01 14:34:56 -0800593 inode = iget5_locked(blockdev_superblock, hash(dev),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 bdev_test, bdev_set, &dev);
595
596 if (!inode)
597 return NULL;
598
599 bdev = &BDEV_I(inode)->bdev;
600
601 if (inode->i_state & I_NEW) {
602 bdev->bd_contains = NULL;
Lachlan McIlroy782b94c2011-06-30 11:01:45 +1000603 bdev->bd_super = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 bdev->bd_inode = inode;
605 bdev->bd_block_size = (1 << inode->i_blkbits);
606 bdev->bd_part_count = 0;
607 bdev->bd_invalidated = 0;
608 inode->i_mode = S_IFBLK;
609 inode->i_rdev = dev;
610 inode->i_bdev = bdev;
611 inode->i_data.a_ops = &def_blk_aops;
612 mapping_set_gfp_mask(&inode->i_data, GFP_USER);
613 inode->i_data.backing_dev_info = &default_backing_dev_info;
614 spin_lock(&bdev_lock);
615 list_add(&bdev->bd_list, &all_bdevs);
616 spin_unlock(&bdev_lock);
617 unlock_new_inode(inode);
618 }
619 return bdev;
620}
621
622EXPORT_SYMBOL(bdget);
623
Alan Jenkinsdddac6a2009-07-29 21:07:55 +0200624/**
625 * bdgrab -- Grab a reference to an already referenced block device
626 * @bdev: Block device to grab a reference to.
627 */
628struct block_device *bdgrab(struct block_device *bdev)
629{
Al Viro7de9c6ee2010-10-23 11:11:40 -0400630 ihold(bdev->bd_inode);
Alan Jenkinsdddac6a2009-07-29 21:07:55 +0200631 return bdev;
632}
633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634long nr_blockdev_pages(void)
635{
Matthias Kaehlcke203a2932007-07-15 23:40:23 -0700636 struct block_device *bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 long ret = 0;
638 spin_lock(&bdev_lock);
Matthias Kaehlcke203a2932007-07-15 23:40:23 -0700639 list_for_each_entry(bdev, &all_bdevs, bd_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 ret += bdev->bd_inode->i_mapping->nrpages;
641 }
642 spin_unlock(&bdev_lock);
643 return ret;
644}
645
646void bdput(struct block_device *bdev)
647{
648 iput(bdev->bd_inode);
649}
650
651EXPORT_SYMBOL(bdput);
652
653static struct block_device *bd_acquire(struct inode *inode)
654{
655 struct block_device *bdev;
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 spin_lock(&bdev_lock);
658 bdev = inode->i_bdev;
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700659 if (bdev) {
Al Viro7de9c6ee2010-10-23 11:11:40 -0400660 ihold(bdev->bd_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 spin_unlock(&bdev_lock);
662 return bdev;
663 }
664 spin_unlock(&bdev_lock);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 bdev = bdget(inode->i_rdev);
667 if (bdev) {
668 spin_lock(&bdev_lock);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700669 if (!inode->i_bdev) {
670 /*
Al Viro7de9c6ee2010-10-23 11:11:40 -0400671 * We take an additional reference to bd_inode,
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700672 * and it's released in clear_inode() of inode.
673 * So, we can access it via ->i_mapping always
674 * without igrab().
675 */
Al Viro7de9c6ee2010-10-23 11:11:40 -0400676 ihold(bdev->bd_inode);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700677 inode->i_bdev = bdev;
678 inode->i_mapping = bdev->bd_inode->i_mapping;
679 list_add(&inode->i_devices, &bdev->bd_inodes);
680 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 spin_unlock(&bdev_lock);
682 }
683 return bdev;
684}
685
Al Virof47ec3f2011-11-21 21:15:42 -0500686static inline int sb_is_blkdev_sb(struct super_block *sb)
687{
688 return sb == blockdev_superblock;
689}
690
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691/* Call when you free inode */
692
693void bd_forget(struct inode *inode)
694{
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700695 struct block_device *bdev = NULL;
696
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 spin_lock(&bdev_lock);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700698 if (inode->i_bdev) {
Denis ChengRqc2acf7b2008-12-01 14:34:56 -0800699 if (!sb_is_blkdev_sb(inode->i_sb))
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700700 bdev = inode->i_bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 __bd_forget(inode);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700702 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 spin_unlock(&bdev_lock);
OGAWA Hirofumi09d967c2006-06-22 14:47:21 -0700704
705 if (bdev)
706 iput(bdev->bd_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
708
Tejun Heo1a3cbbc2010-04-07 18:52:29 +0900709/**
710 * bd_may_claim - test whether a block device can be claimed
711 * @bdev: block device of interest
712 * @whole: whole block device containing @bdev, may equal @bdev
713 * @holder: holder trying to claim @bdev
714 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300715 * Test whether @bdev can be claimed by @holder.
Tejun Heo1a3cbbc2010-04-07 18:52:29 +0900716 *
717 * CONTEXT:
718 * spin_lock(&bdev_lock).
719 *
720 * RETURNS:
721 * %true if @bdev can be claimed, %false otherwise.
722 */
723static bool bd_may_claim(struct block_device *bdev, struct block_device *whole,
724 void *holder)
725{
726 if (bdev->bd_holder == holder)
727 return true; /* already a holder */
728 else if (bdev->bd_holder != NULL)
729 return false; /* held by someone else */
730 else if (bdev->bd_contains == bdev)
731 return true; /* is a whole device which isn't held */
732
Tejun Heoe525fd82010-11-13 11:55:17 +0100733 else if (whole->bd_holder == bd_may_claim)
Tejun Heo1a3cbbc2010-04-07 18:52:29 +0900734 return true; /* is a partition of a device that is being partitioned */
735 else if (whole->bd_holder != NULL)
736 return false; /* is a partition of a held device */
737 else
738 return true; /* is a partition of an un-held device */
739}
740
741/**
Tejun Heo6b4517a2010-04-07 18:53:59 +0900742 * bd_prepare_to_claim - prepare to claim a block device
743 * @bdev: block device of interest
744 * @whole: the whole device containing @bdev, may equal @bdev
745 * @holder: holder trying to claim @bdev
746 *
747 * Prepare to claim @bdev. This function fails if @bdev is already
748 * claimed by another holder and waits if another claiming is in
749 * progress. This function doesn't actually claim. On successful
750 * return, the caller has ownership of bd_claiming and bd_holder[s].
751 *
752 * CONTEXT:
753 * spin_lock(&bdev_lock). Might release bdev_lock, sleep and regrab
754 * it multiple times.
755 *
756 * RETURNS:
757 * 0 if @bdev can be claimed, -EBUSY otherwise.
758 */
759static int bd_prepare_to_claim(struct block_device *bdev,
760 struct block_device *whole, void *holder)
761{
762retry:
763 /* if someone else claimed, fail */
764 if (!bd_may_claim(bdev, whole, holder))
765 return -EBUSY;
766
Tejun Heoe75aa852010-08-04 17:59:39 +0200767 /* if claiming is already in progress, wait for it to finish */
768 if (whole->bd_claiming) {
Tejun Heo6b4517a2010-04-07 18:53:59 +0900769 wait_queue_head_t *wq = bit_waitqueue(&whole->bd_claiming, 0);
770 DEFINE_WAIT(wait);
771
772 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
773 spin_unlock(&bdev_lock);
774 schedule();
775 finish_wait(wq, &wait);
776 spin_lock(&bdev_lock);
777 goto retry;
778 }
779
780 /* yay, all mine */
781 return 0;
782}
783
784/**
785 * bd_start_claiming - start claiming a block device
786 * @bdev: block device of interest
787 * @holder: holder trying to claim @bdev
788 *
789 * @bdev is about to be opened exclusively. Check @bdev can be opened
790 * exclusively and mark that an exclusive open is in progress. Each
791 * successful call to this function must be matched with a call to
Nick Pigginb0018362010-05-26 01:51:19 +1000792 * either bd_finish_claiming() or bd_abort_claiming() (which do not
793 * fail).
794 *
795 * This function is used to gain exclusive access to the block device
796 * without actually causing other exclusive open attempts to fail. It
797 * should be used when the open sequence itself requires exclusive
798 * access but may subsequently fail.
Tejun Heo6b4517a2010-04-07 18:53:59 +0900799 *
800 * CONTEXT:
801 * Might sleep.
802 *
803 * RETURNS:
804 * Pointer to the block device containing @bdev on success, ERR_PTR()
805 * value on failure.
806 */
807static struct block_device *bd_start_claiming(struct block_device *bdev,
808 void *holder)
809{
810 struct gendisk *disk;
811 struct block_device *whole;
812 int partno, err;
813
814 might_sleep();
815
816 /*
817 * @bdev might not have been initialized properly yet, look up
818 * and grab the outer block device the hard way.
819 */
820 disk = get_gendisk(bdev->bd_dev, &partno);
821 if (!disk)
822 return ERR_PTR(-ENXIO);
823
Tejun Heod4c208b2011-06-13 12:45:48 +0200824 /*
825 * Normally, @bdev should equal what's returned from bdget_disk()
826 * if partno is 0; however, some drivers (floppy) use multiple
827 * bdev's for the same physical device and @bdev may be one of the
828 * aliases. Keep @bdev if partno is 0. This means claimer
829 * tracking is broken for those devices but it has always been that
830 * way.
831 */
832 if (partno)
833 whole = bdget_disk(disk, 0);
834 else
835 whole = bdgrab(bdev);
836
Nick Piggincf342572010-05-26 01:50:21 +1000837 module_put(disk->fops->owner);
Tejun Heo6b4517a2010-04-07 18:53:59 +0900838 put_disk(disk);
839 if (!whole)
840 return ERR_PTR(-ENOMEM);
841
842 /* prepare to claim, if successful, mark claiming in progress */
843 spin_lock(&bdev_lock);
844
845 err = bd_prepare_to_claim(bdev, whole, holder);
846 if (err == 0) {
847 whole->bd_claiming = holder;
848 spin_unlock(&bdev_lock);
849 return whole;
850 } else {
851 spin_unlock(&bdev_lock);
852 bdput(whole);
853 return ERR_PTR(err);
854 }
855}
856
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800857#ifdef CONFIG_SYSFS
Tejun Heo49731ba2011-01-14 18:43:57 +0100858struct bd_holder_disk {
859 struct list_head list;
860 struct gendisk *disk;
861 int refcnt;
862};
863
864static struct bd_holder_disk *bd_find_holder_disk(struct block_device *bdev,
865 struct gendisk *disk)
866{
867 struct bd_holder_disk *holder;
868
869 list_for_each_entry(holder, &bdev->bd_holder_disks, list)
870 if (holder->disk == disk)
871 return holder;
872 return NULL;
873}
874
Andrew Morton4d7dd8fd2006-09-29 01:58:56 -0700875static int add_symlink(struct kobject *from, struct kobject *to)
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800876{
Andrew Morton4d7dd8fd2006-09-29 01:58:56 -0700877 return sysfs_create_link(from, to, kobject_name(to));
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800878}
879
880static void del_symlink(struct kobject *from, struct kobject *to)
881{
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800882 sysfs_remove_link(from, kobject_name(to));
883}
884
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800885/**
Tejun Heoe09b4572010-11-13 11:55:17 +0100886 * bd_link_disk_holder - create symlinks between holding disk and slave bdev
887 * @bdev: the claimed slave bdev
888 * @disk: the holding disk
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -0500889 *
Tejun Heo49731ba2011-01-14 18:43:57 +0100890 * DON'T USE THIS UNLESS YOU'RE ALREADY USING IT.
891 *
Tejun Heoe09b4572010-11-13 11:55:17 +0100892 * This functions creates the following sysfs symlinks.
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -0500893 *
Tejun Heoe09b4572010-11-13 11:55:17 +0100894 * - from "slaves" directory of the holder @disk to the claimed @bdev
895 * - from "holders" directory of the @bdev to the holder @disk
896 *
897 * For example, if /dev/dm-0 maps to /dev/sda and disk for dm-0 is
898 * passed to bd_link_disk_holder(), then:
899 *
900 * /sys/block/dm-0/slaves/sda --> /sys/block/sda
901 * /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
902 *
903 * The caller must have claimed @bdev before calling this function and
904 * ensure that both @bdev and @disk are valid during the creation and
905 * lifetime of these symlinks.
906 *
907 * CONTEXT:
908 * Might sleep.
909 *
910 * RETURNS:
911 * 0 on success, -errno on failure.
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -0500912 */
Tejun Heoe09b4572010-11-13 11:55:17 +0100913int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk)
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -0500914{
Tejun Heo49731ba2011-01-14 18:43:57 +0100915 struct bd_holder_disk *holder;
Tejun Heoe09b4572010-11-13 11:55:17 +0100916 int ret = 0;
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800917
Peter Zijlstra2e7b6512006-12-08 02:36:13 -0800918 mutex_lock(&bdev->bd_mutex);
Jun'ichi Nomuradf6c0cd2006-10-30 16:23:56 -0500919
Tejun Heo49731ba2011-01-14 18:43:57 +0100920 WARN_ON_ONCE(!bdev->bd_holder);
Johannes Weiner4e916722007-07-15 23:41:25 -0700921
Tejun Heoe09b4572010-11-13 11:55:17 +0100922 /* FIXME: remove the following once add_disk() handles errors */
923 if (WARN_ON(!disk->slave_dir || !bdev->bd_part->holder_dir))
924 goto out_unlock;
Johannes Weiner4e916722007-07-15 23:41:25 -0700925
Tejun Heo49731ba2011-01-14 18:43:57 +0100926 holder = bd_find_holder_disk(bdev, disk);
927 if (holder) {
928 holder->refcnt++;
Tejun Heoe09b4572010-11-13 11:55:17 +0100929 goto out_unlock;
930 }
931
Tejun Heo49731ba2011-01-14 18:43:57 +0100932 holder = kzalloc(sizeof(*holder), GFP_KERNEL);
933 if (!holder) {
934 ret = -ENOMEM;
935 goto out_unlock;
936 }
937
938 INIT_LIST_HEAD(&holder->list);
939 holder->disk = disk;
940 holder->refcnt = 1;
941
942 ret = add_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
943 if (ret)
944 goto out_free;
945
946 ret = add_symlink(bdev->bd_part->holder_dir, &disk_to_dev(disk)->kobj);
947 if (ret)
948 goto out_del;
Tejun Heoe7407d12011-02-24 09:56:32 +0100949 /*
950 * bdev could be deleted beneath us which would implicitly destroy
951 * the holder directory. Hold on to it.
952 */
953 kobject_get(bdev->bd_part->holder_dir);
Tejun Heo49731ba2011-01-14 18:43:57 +0100954
955 list_add(&holder->list, &bdev->bd_holder_disks);
956 goto out_unlock;
957
958out_del:
959 del_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
960out_free:
961 kfree(holder);
Tejun Heoe09b4572010-11-13 11:55:17 +0100962out_unlock:
Jun'ichi Nomurab4cf1b72006-03-27 01:18:00 -0800963 mutex_unlock(&bdev->bd_mutex);
Tejun Heoe09b4572010-11-13 11:55:17 +0100964 return ret;
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800965}
Tejun Heoe09b4572010-11-13 11:55:17 +0100966EXPORT_SYMBOL_GPL(bd_link_disk_holder);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800967
Tejun Heo49731ba2011-01-14 18:43:57 +0100968/**
969 * bd_unlink_disk_holder - destroy symlinks created by bd_link_disk_holder()
970 * @bdev: the calimed slave bdev
971 * @disk: the holding disk
972 *
973 * DON'T USE THIS UNLESS YOU'RE ALREADY USING IT.
974 *
975 * CONTEXT:
976 * Might sleep.
977 */
978void bd_unlink_disk_holder(struct block_device *bdev, struct gendisk *disk)
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800979{
Tejun Heo49731ba2011-01-14 18:43:57 +0100980 struct bd_holder_disk *holder;
Tejun Heoe09b4572010-11-13 11:55:17 +0100981
Tejun Heo49731ba2011-01-14 18:43:57 +0100982 mutex_lock(&bdev->bd_mutex);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800983
Tejun Heo49731ba2011-01-14 18:43:57 +0100984 holder = bd_find_holder_disk(bdev, disk);
985
986 if (!WARN_ON_ONCE(holder == NULL) && !--holder->refcnt) {
987 del_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
988 del_symlink(bdev->bd_part->holder_dir,
989 &disk_to_dev(disk)->kobj);
Tejun Heoe7407d12011-02-24 09:56:32 +0100990 kobject_put(bdev->bd_part->holder_dir);
Tejun Heo49731ba2011-01-14 18:43:57 +0100991 list_del_init(&holder->list);
992 kfree(holder);
993 }
994
995 mutex_unlock(&bdev->bd_mutex);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800996}
Tejun Heo49731ba2011-01-14 18:43:57 +0100997EXPORT_SYMBOL_GPL(bd_unlink_disk_holder);
Jun'ichi Nomura641dc632006-03-27 01:17:57 -0800998#endif
999
Andrew Patterson0c002c22008-09-04 14:27:20 -06001000/**
Andrew Patterson56ade442008-09-04 14:27:40 -06001001 * flush_disk - invalidates all buffer-cache entries on a disk
1002 *
1003 * @bdev: struct block device to be flushed
Randy Dunlape6eb5ce2011-02-26 10:54:00 -08001004 * @kill_dirty: flag to guide handling of dirty inodes
Andrew Patterson56ade442008-09-04 14:27:40 -06001005 *
1006 * Invalidates all buffer-cache entries on a disk. It should be called
1007 * when a disk has been changed -- either by a media change or online
1008 * resize.
1009 */
NeilBrown93b270f2011-02-24 17:25:47 +11001010static void flush_disk(struct block_device *bdev, bool kill_dirty)
Andrew Patterson56ade442008-09-04 14:27:40 -06001011{
NeilBrown93b270f2011-02-24 17:25:47 +11001012 if (__invalidate_device(bdev, kill_dirty)) {
Andrew Patterson56ade442008-09-04 14:27:40 -06001013 char name[BDEVNAME_SIZE] = "";
1014
1015 if (bdev->bd_disk)
1016 disk_name(bdev->bd_disk, 0, name);
1017 printk(KERN_WARNING "VFS: busy inodes on changed media or "
1018 "resized disk %s\n", name);
1019 }
1020
1021 if (!bdev->bd_disk)
1022 return;
Tejun Heod27769e2011-08-23 20:01:04 +02001023 if (disk_part_scan_enabled(bdev->bd_disk))
Andrew Patterson56ade442008-09-04 14:27:40 -06001024 bdev->bd_invalidated = 1;
1025}
1026
1027/**
Randy Dunlap57d1b532008-10-09 10:42:38 +02001028 * check_disk_size_change - checks for disk size change and adjusts bdev size.
Andrew Pattersonc3279d12008-09-04 14:27:25 -06001029 * @disk: struct gendisk to check
1030 * @bdev: struct bdev to adjust.
1031 *
1032 * This routine checks to see if the bdev size does not match the disk size
1033 * and adjusts it if it differs.
1034 */
1035void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
1036{
1037 loff_t disk_size, bdev_size;
1038
1039 disk_size = (loff_t)get_capacity(disk) << 9;
1040 bdev_size = i_size_read(bdev->bd_inode);
1041 if (disk_size != bdev_size) {
1042 char name[BDEVNAME_SIZE];
1043
1044 disk_name(disk, 0, name);
1045 printk(KERN_INFO
1046 "%s: detected capacity change from %lld to %lld\n",
1047 name, bdev_size, disk_size);
1048 i_size_write(bdev->bd_inode, disk_size);
NeilBrown93b270f2011-02-24 17:25:47 +11001049 flush_disk(bdev, false);
Andrew Pattersonc3279d12008-09-04 14:27:25 -06001050 }
1051}
1052EXPORT_SYMBOL(check_disk_size_change);
1053
1054/**
Randy Dunlap57d1b532008-10-09 10:42:38 +02001055 * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
Andrew Patterson0c002c22008-09-04 14:27:20 -06001056 * @disk: struct gendisk to be revalidated
1057 *
1058 * This routine is a wrapper for lower-level driver's revalidate_disk
1059 * call-backs. It is used to do common pre and post operations needed
1060 * for all revalidate_disk operations.
1061 */
1062int revalidate_disk(struct gendisk *disk)
1063{
Andrew Pattersonc3279d12008-09-04 14:27:25 -06001064 struct block_device *bdev;
Andrew Patterson0c002c22008-09-04 14:27:20 -06001065 int ret = 0;
1066
1067 if (disk->fops->revalidate_disk)
1068 ret = disk->fops->revalidate_disk(disk);
1069
Andrew Pattersonc3279d12008-09-04 14:27:25 -06001070 bdev = bdget_disk(disk, 0);
1071 if (!bdev)
1072 return ret;
1073
1074 mutex_lock(&bdev->bd_mutex);
1075 check_disk_size_change(disk, bdev);
1076 mutex_unlock(&bdev->bd_mutex);
1077 bdput(bdev);
Andrew Patterson0c002c22008-09-04 14:27:20 -06001078 return ret;
1079}
1080EXPORT_SYMBOL(revalidate_disk);
1081
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082/*
1083 * This routine checks whether a removable media has been changed,
1084 * and invalidates all buffer-cache-entries in that case. This
1085 * is a relatively slow routine, so we have to try to minimize using
1086 * it. Thus it is called only upon a 'mount' or 'open'. This
1087 * is the best way of combining speed and utility, I think.
1088 * People changing diskettes in the middle of an operation deserve
1089 * to lose :-)
1090 */
1091int check_disk_change(struct block_device *bdev)
1092{
1093 struct gendisk *disk = bdev->bd_disk;
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -07001094 const struct block_device_operations *bdops = disk->fops;
Tejun Heo77ea8872010-12-08 20:57:37 +01001095 unsigned int events;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
Tejun Heo77ea8872010-12-08 20:57:37 +01001097 events = disk_clear_events(disk, DISK_EVENT_MEDIA_CHANGE |
1098 DISK_EVENT_EJECT_REQUEST);
1099 if (!(events & DISK_EVENT_MEDIA_CHANGE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 return 0;
1101
NeilBrown93b270f2011-02-24 17:25:47 +11001102 flush_disk(bdev, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 if (bdops->revalidate_disk)
1104 bdops->revalidate_disk(bdev->bd_disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 return 1;
1106}
1107
1108EXPORT_SYMBOL(check_disk_change);
1109
1110void bd_set_size(struct block_device *bdev, loff_t size)
1111{
Martin K. Petersene1defc42009-05-22 17:17:49 -04001112 unsigned bsize = bdev_logical_block_size(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
1114 bdev->bd_inode->i_size = size;
1115 while (bsize < PAGE_CACHE_SIZE) {
1116 if (size & bsize)
1117 break;
1118 bsize <<= 1;
1119 }
1120 bdev->bd_block_size = bsize;
1121 bdev->bd_inode->i_blkbits = blksize_bits(bsize);
1122}
1123EXPORT_SYMBOL(bd_set_size);
1124
Al Viro9a1c3542008-02-22 20:40:24 -05001125static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
NeilBrown37be4122006-12-08 02:36:16 -08001126
Peter Zijlstra6d740cd2007-02-20 13:58:18 -08001127/*
1128 * bd_mutex locking:
1129 *
1130 * mutex_lock(part->bd_mutex)
1131 * mutex_lock_nested(whole->bd_mutex, 1)
1132 */
1133
Al Viro572c4892007-10-08 13:24:05 -04001134static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 struct gendisk *disk;
Tejun Heo523e1d32011-10-19 14:31:07 +02001137 struct module *owner;
Pavel Emelyanov7db9cfd2008-06-05 22:46:27 -07001138 int ret;
Tejun Heocf771cb2008-09-03 09:01:09 +02001139 int partno;
Al Virofe6e9c12008-06-23 08:30:55 -04001140 int perm = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
Al Viro572c4892007-10-08 13:24:05 -04001142 if (mode & FMODE_READ)
Al Virofe6e9c12008-06-23 08:30:55 -04001143 perm |= MAY_READ;
Al Viro572c4892007-10-08 13:24:05 -04001144 if (mode & FMODE_WRITE)
Al Virofe6e9c12008-06-23 08:30:55 -04001145 perm |= MAY_WRITE;
1146 /*
1147 * hooks: /n/, see "layering violations".
1148 */
Chris Wrightb7300b72010-08-10 18:02:55 -07001149 if (!for_part) {
1150 ret = devcgroup_inode_permission(bdev->bd_inode, perm);
1151 if (ret != 0) {
1152 bdput(bdev);
1153 return ret;
1154 }
Al Viro82666022008-08-01 05:32:04 -04001155 }
Pavel Emelyanov7db9cfd2008-06-05 22:46:27 -07001156
NeilBrownd3374822009-01-09 08:31:10 +11001157 restart:
Tejun Heo0762b8b2008-08-25 19:56:12 +09001158
Tejun Heo89f97492008-11-05 10:21:06 +01001159 ret = -ENXIO;
Tejun Heocf771cb2008-09-03 09:01:09 +02001160 disk = get_gendisk(bdev->bd_dev, &partno);
Tejun Heo0762b8b2008-08-25 19:56:12 +09001161 if (!disk)
Arnd Bergmann6e9624b2010-08-07 18:25:34 +02001162 goto out;
Tejun Heo523e1d32011-10-19 14:31:07 +02001163 owner = disk->fops->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
Tejun Heo69e02c52011-03-09 19:54:27 +01001165 disk_block_events(disk);
NeilBrown6796bf52006-12-08 02:36:16 -08001166 mutex_lock_nested(&bdev->bd_mutex, for_part);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 if (!bdev->bd_openers) {
1168 bdev->bd_disk = disk;
Andi Kleen87192a22012-01-12 17:20:34 -08001169 bdev->bd_queue = disk->queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 bdev->bd_contains = bdev;
Tejun Heocf771cb2008-09-03 09:01:09 +02001171 if (!partno) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 struct backing_dev_info *bdi;
Tejun Heo89f97492008-11-05 10:21:06 +01001173
1174 ret = -ENXIO;
1175 bdev->bd_part = disk_get_part(disk, partno);
1176 if (!bdev->bd_part)
1177 goto out_clear;
1178
Tejun Heo1196f8b2011-04-21 20:54:45 +02001179 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 if (disk->fops->open) {
Al Viro572c4892007-10-08 13:24:05 -04001181 ret = disk->fops->open(bdev, mode);
NeilBrownd3374822009-01-09 08:31:10 +11001182 if (ret == -ERESTARTSYS) {
1183 /* Lost a race with 'disk' being
1184 * deleted, try again.
1185 * See md.c
1186 */
1187 disk_put_part(bdev->bd_part);
1188 bdev->bd_part = NULL;
NeilBrownd3374822009-01-09 08:31:10 +11001189 bdev->bd_disk = NULL;
Andi Kleen87192a22012-01-12 17:20:34 -08001190 bdev->bd_queue = NULL;
NeilBrownd3374822009-01-09 08:31:10 +11001191 mutex_unlock(&bdev->bd_mutex);
Tejun Heo69e02c52011-03-09 19:54:27 +01001192 disk_unblock_events(disk);
Tejun Heo69e02c52011-03-09 19:54:27 +01001193 put_disk(disk);
Tejun Heo523e1d32011-10-19 14:31:07 +02001194 module_put(owner);
NeilBrownd3374822009-01-09 08:31:10 +11001195 goto restart;
1196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 }
Tejun Heo7e697232011-05-23 13:26:07 +02001198
1199 if (!ret && !bdev->bd_openers) {
1200 bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
1201 bdi = blk_get_backing_dev_info(bdev);
1202 if (bdi == NULL)
1203 bdi = &default_backing_dev_info;
1204 bdev_inode_switch_bdi(bdev->bd_inode, bdi);
1205 }
1206
Tejun Heo1196f8b2011-04-21 20:54:45 +02001207 /*
1208 * If the device is invalidated, rescan partition
1209 * if open succeeded or failed with -ENOMEDIUM.
1210 * The latter is necessary to prevent ghost
1211 * partitions on a removed medium.
1212 */
Jun'ichi Nomurafe316bf2012-03-02 10:38:33 +01001213 if (bdev->bd_invalidated) {
1214 if (!ret)
1215 rescan_partitions(disk, bdev);
1216 else if (ret == -ENOMEDIUM)
1217 invalidate_partitions(disk, bdev);
1218 }
Tejun Heo1196f8b2011-04-21 20:54:45 +02001219 if (ret)
1220 goto out_clear;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 struct block_device *whole;
1223 whole = bdget_disk(disk, 0);
1224 ret = -ENOMEM;
1225 if (!whole)
Tejun Heo0762b8b2008-08-25 19:56:12 +09001226 goto out_clear;
NeilBrown37be4122006-12-08 02:36:16 -08001227 BUG_ON(for_part);
Al Viro572c4892007-10-08 13:24:05 -04001228 ret = __blkdev_get(whole, mode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 if (ret)
Tejun Heo0762b8b2008-08-25 19:56:12 +09001230 goto out_clear;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 bdev->bd_contains = whole;
Dave Chinnera5491e02010-10-21 11:49:26 +11001232 bdev_inode_switch_bdi(bdev->bd_inode,
1233 whole->bd_inode->i_data.backing_dev_info);
Tejun Heo89f97492008-11-05 10:21:06 +01001234 bdev->bd_part = disk_get_part(disk, partno);
Tejun Heoe71bf0d2008-09-03 09:03:02 +02001235 if (!(disk->flags & GENHD_FL_UP) ||
Tejun Heo89f97492008-11-05 10:21:06 +01001236 !bdev->bd_part || !bdev->bd_part->nr_sects) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 ret = -ENXIO;
Tejun Heo0762b8b2008-08-25 19:56:12 +09001238 goto out_clear;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 }
Tejun Heo89f97492008-11-05 10:21:06 +01001240 bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 }
1242 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 if (bdev->bd_contains == bdev) {
Tejun Heo1196f8b2011-04-21 20:54:45 +02001244 ret = 0;
1245 if (bdev->bd_disk->fops->open)
Al Viro572c4892007-10-08 13:24:05 -04001246 ret = bdev->bd_disk->fops->open(bdev, mode);
Tejun Heo1196f8b2011-04-21 20:54:45 +02001247 /* the same as first opener case, read comment there */
Jun'ichi Nomurafe316bf2012-03-02 10:38:33 +01001248 if (bdev->bd_invalidated) {
1249 if (!ret)
1250 rescan_partitions(bdev->bd_disk, bdev);
1251 else if (ret == -ENOMEDIUM)
1252 invalidate_partitions(bdev->bd_disk, bdev);
1253 }
Tejun Heo1196f8b2011-04-21 20:54:45 +02001254 if (ret)
1255 goto out_unlock_bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 }
Tejun Heo69e02c52011-03-09 19:54:27 +01001257 /* only one opener holds refs to the module and disk */
Tejun Heo69e02c52011-03-09 19:54:27 +01001258 put_disk(disk);
Tejun Heo523e1d32011-10-19 14:31:07 +02001259 module_put(owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 }
1261 bdev->bd_openers++;
NeilBrown37be4122006-12-08 02:36:16 -08001262 if (for_part)
1263 bdev->bd_part_count++;
Arjan van de Venc039e312006-03-23 03:00:28 -08001264 mutex_unlock(&bdev->bd_mutex);
Tejun Heo69e02c52011-03-09 19:54:27 +01001265 disk_unblock_events(disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 return 0;
1267
Tejun Heo0762b8b2008-08-25 19:56:12 +09001268 out_clear:
Tejun Heo89f97492008-11-05 10:21:06 +01001269 disk_put_part(bdev->bd_part);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 bdev->bd_disk = NULL;
Tejun Heo0762b8b2008-08-25 19:56:12 +09001271 bdev->bd_part = NULL;
Andi Kleen87192a22012-01-12 17:20:34 -08001272 bdev->bd_queue = NULL;
Dave Chinnera5491e02010-10-21 11:49:26 +11001273 bdev_inode_switch_bdi(bdev->bd_inode, &default_backing_dev_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 if (bdev != bdev->bd_contains)
Al Viro572c4892007-10-08 13:24:05 -04001275 __blkdev_put(bdev->bd_contains, mode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 bdev->bd_contains = NULL;
Tejun Heo0762b8b2008-08-25 19:56:12 +09001277 out_unlock_bdev:
Arjan van de Venc039e312006-03-23 03:00:28 -08001278 mutex_unlock(&bdev->bd_mutex);
Tejun Heo69e02c52011-03-09 19:54:27 +01001279 disk_unblock_events(disk);
Tejun Heo0762b8b2008-08-25 19:56:12 +09001280 put_disk(disk);
Tejun Heo523e1d32011-10-19 14:31:07 +02001281 module_put(owner);
Dan Carpenter4345cab2011-03-19 13:53:31 +01001282 out:
Tejun Heo0762b8b2008-08-25 19:56:12 +09001283 bdput(bdev);
1284
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 return ret;
1286}
1287
Tejun Heod4d77622010-11-13 11:55:18 +01001288/**
1289 * blkdev_get - open a block device
1290 * @bdev: block_device to open
1291 * @mode: FMODE_* mask
1292 * @holder: exclusive holder identifier
1293 *
1294 * Open @bdev with @mode. If @mode includes %FMODE_EXCL, @bdev is
1295 * open with exclusive access. Specifying %FMODE_EXCL with %NULL
1296 * @holder is invalid. Exclusive opens may nest for the same @holder.
1297 *
1298 * On success, the reference count of @bdev is unchanged. On failure,
1299 * @bdev is put.
1300 *
1301 * CONTEXT:
1302 * Might sleep.
1303 *
1304 * RETURNS:
1305 * 0 on success, -errno on failure.
1306 */
Tejun Heoe525fd82010-11-13 11:55:17 +01001307int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308{
Tejun Heoe525fd82010-11-13 11:55:17 +01001309 struct block_device *whole = NULL;
1310 int res;
1311
1312 WARN_ON_ONCE((mode & FMODE_EXCL) && !holder);
1313
1314 if ((mode & FMODE_EXCL) && holder) {
1315 whole = bd_start_claiming(bdev, holder);
1316 if (IS_ERR(whole)) {
1317 bdput(bdev);
1318 return PTR_ERR(whole);
1319 }
1320 }
1321
1322 res = __blkdev_get(bdev, mode, 0);
1323
1324 if (whole) {
Tejun Heod4dc2102011-04-21 20:54:46 +02001325 struct gendisk *disk = whole->bd_disk;
1326
Tejun Heo6a027ef2010-11-13 11:55:17 +01001327 /* finish claiming */
Tejun Heo77ea8872010-12-08 20:57:37 +01001328 mutex_lock(&bdev->bd_mutex);
Tejun Heo6a027ef2010-11-13 11:55:17 +01001329 spin_lock(&bdev_lock);
1330
Tejun Heo77ea8872010-12-08 20:57:37 +01001331 if (!res) {
Tejun Heo6a027ef2010-11-13 11:55:17 +01001332 BUG_ON(!bd_may_claim(bdev, whole, holder));
1333 /*
1334 * Note that for a whole device bd_holders
1335 * will be incremented twice, and bd_holder
1336 * will be set to bd_may_claim before being
1337 * set to holder
1338 */
1339 whole->bd_holders++;
1340 whole->bd_holder = bd_may_claim;
1341 bdev->bd_holders++;
1342 bdev->bd_holder = holder;
1343 }
1344
1345 /* tell others that we're done */
1346 BUG_ON(whole->bd_claiming != holder);
1347 whole->bd_claiming = NULL;
1348 wake_up_bit(&whole->bd_claiming, 0);
1349
1350 spin_unlock(&bdev_lock);
Tejun Heo77ea8872010-12-08 20:57:37 +01001351
1352 /*
Tejun Heod4dc2102011-04-21 20:54:46 +02001353 * Block event polling for write claims if requested. Any
1354 * write holder makes the write_holder state stick until
1355 * all are released. This is good enough and tracking
1356 * individual writeable reference is too fragile given the
1357 * way @mode is used in blkdev_get/put().
Tejun Heo77ea8872010-12-08 20:57:37 +01001358 */
Tejun Heo4c49ff32011-06-01 08:27:41 +02001359 if (!res && (mode & FMODE_WRITE) && !bdev->bd_write_holder &&
1360 (disk->flags & GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE)) {
Tejun Heo77ea8872010-12-08 20:57:37 +01001361 bdev->bd_write_holder = true;
Tejun Heod4dc2102011-04-21 20:54:46 +02001362 disk_block_events(disk);
Tejun Heo77ea8872010-12-08 20:57:37 +01001363 }
1364
1365 mutex_unlock(&bdev->bd_mutex);
Tejun Heo6a027ef2010-11-13 11:55:17 +01001366 bdput(whole);
Tejun Heoe525fd82010-11-13 11:55:17 +01001367 }
1368
1369 return res;
NeilBrown37be4122006-12-08 02:36:16 -08001370}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371EXPORT_SYMBOL(blkdev_get);
1372
Tejun Heod4d77622010-11-13 11:55:18 +01001373/**
1374 * blkdev_get_by_path - open a block device by name
1375 * @path: path to the block device to open
1376 * @mode: FMODE_* mask
1377 * @holder: exclusive holder identifier
1378 *
1379 * Open the blockdevice described by the device file at @path. @mode
1380 * and @holder are identical to blkdev_get().
1381 *
1382 * On success, the returned block_device has reference count of one.
1383 *
1384 * CONTEXT:
1385 * Might sleep.
1386 *
1387 * RETURNS:
1388 * Pointer to block_device on success, ERR_PTR(-errno) on failure.
1389 */
1390struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
1391 void *holder)
1392{
1393 struct block_device *bdev;
1394 int err;
1395
1396 bdev = lookup_bdev(path);
1397 if (IS_ERR(bdev))
1398 return bdev;
1399
1400 err = blkdev_get(bdev, mode, holder);
1401 if (err)
1402 return ERR_PTR(err);
1403
Chuck Ebberte51900f2011-02-16 18:11:53 -05001404 if ((mode & FMODE_WRITE) && bdev_read_only(bdev)) {
1405 blkdev_put(bdev, mode);
1406 return ERR_PTR(-EACCES);
1407 }
1408
Tejun Heod4d77622010-11-13 11:55:18 +01001409 return bdev;
1410}
1411EXPORT_SYMBOL(blkdev_get_by_path);
1412
1413/**
1414 * blkdev_get_by_dev - open a block device by device number
1415 * @dev: device number of block device to open
1416 * @mode: FMODE_* mask
1417 * @holder: exclusive holder identifier
1418 *
1419 * Open the blockdevice described by device number @dev. @mode and
1420 * @holder are identical to blkdev_get().
1421 *
1422 * Use it ONLY if you really do not have anything better - i.e. when
1423 * you are behind a truly sucky interface and all you are given is a
1424 * device number. _Never_ to be used for internal purposes. If you
1425 * ever need it - reconsider your API.
1426 *
1427 * On success, the returned block_device has reference count of one.
1428 *
1429 * CONTEXT:
1430 * Might sleep.
1431 *
1432 * RETURNS:
1433 * Pointer to block_device on success, ERR_PTR(-errno) on failure.
1434 */
1435struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder)
1436{
1437 struct block_device *bdev;
1438 int err;
1439
1440 bdev = bdget(dev);
1441 if (!bdev)
1442 return ERR_PTR(-ENOMEM);
1443
1444 err = blkdev_get(bdev, mode, holder);
1445 if (err)
1446 return ERR_PTR(err);
1447
1448 return bdev;
1449}
1450EXPORT_SYMBOL(blkdev_get_by_dev);
1451
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452static int blkdev_open(struct inode * inode, struct file * filp)
1453{
1454 struct block_device *bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455
1456 /*
1457 * Preserve backwards compatibility and allow large file access
1458 * even if userspace doesn't ask for it explicitly. Some mkfs
1459 * binary needs it. We might want to drop this workaround
1460 * during an unstable branch.
1461 */
1462 filp->f_flags |= O_LARGEFILE;
1463
Al Viro572c4892007-10-08 13:24:05 -04001464 if (filp->f_flags & O_NDELAY)
1465 filp->f_mode |= FMODE_NDELAY;
1466 if (filp->f_flags & O_EXCL)
1467 filp->f_mode |= FMODE_EXCL;
1468 if ((filp->f_flags & O_ACCMODE) == 3)
1469 filp->f_mode |= FMODE_WRITE_IOCTL;
1470
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 bdev = bd_acquire(inode);
Pavel Emelianov6a2aae02006-10-28 10:38:33 -07001472 if (bdev == NULL)
1473 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
Al Viro572c4892007-10-08 13:24:05 -04001475 filp->f_mapping = bdev->bd_inode->i_mapping;
1476
Tejun Heoe525fd82010-11-13 11:55:17 +01001477 return blkdev_get(bdev, filp->f_mode, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478}
1479
Al Viro9a1c3542008-02-22 20:40:24 -05001480static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001481{
1482 int ret = 0;
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001483 struct gendisk *disk = bdev->bd_disk;
NeilBrown37be4122006-12-08 02:36:16 -08001484 struct block_device *victim = NULL;
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001485
NeilBrown6796bf52006-12-08 02:36:16 -08001486 mutex_lock_nested(&bdev->bd_mutex, for_part);
NeilBrown37be4122006-12-08 02:36:16 -08001487 if (for_part)
1488 bdev->bd_part_count--;
1489
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001490 if (!--bdev->bd_openers) {
Tejun Heo6a027ef2010-11-13 11:55:17 +01001491 WARN_ON_ONCE(bdev->bd_holders);
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001492 sync_blockdev(bdev);
1493 kill_bdev(bdev);
NeilBrown94007752011-09-10 17:20:21 +10001494 /* ->release can cause the old bdi to disappear,
1495 * so must switch it out first
1496 */
1497 bdev_inode_switch_bdi(bdev->bd_inode,
1498 &default_backing_dev_info);
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001499 }
1500 if (bdev->bd_contains == bdev) {
1501 if (disk->fops->release)
Al Viro9a1c3542008-02-22 20:40:24 -05001502 ret = disk->fops->release(disk, mode);
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001503 }
1504 if (!bdev->bd_openers) {
1505 struct module *owner = disk->fops->owner;
1506
Tejun Heo0762b8b2008-08-25 19:56:12 +09001507 disk_put_part(bdev->bd_part);
1508 bdev->bd_part = NULL;
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001509 bdev->bd_disk = NULL;
NeilBrown37be4122006-12-08 02:36:16 -08001510 if (bdev != bdev->bd_contains)
1511 victim = bdev->bd_contains;
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001512 bdev->bd_contains = NULL;
Tejun Heo523e1d32011-10-19 14:31:07 +02001513
1514 put_disk(disk);
1515 module_put(owner);
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001516 }
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001517 mutex_unlock(&bdev->bd_mutex);
1518 bdput(bdev);
NeilBrown37be4122006-12-08 02:36:16 -08001519 if (victim)
Al Viro9a1c3542008-02-22 20:40:24 -05001520 __blkdev_put(victim, mode, 1);
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001521 return ret;
1522}
1523
Al Viro9a1c3542008-02-22 20:40:24 -05001524int blkdev_put(struct block_device *bdev, fmode_t mode)
NeilBrown37be4122006-12-08 02:36:16 -08001525{
Tejun Heo85ef06d2011-07-01 16:17:47 +02001526 mutex_lock(&bdev->bd_mutex);
1527
Tejun Heoe525fd82010-11-13 11:55:17 +01001528 if (mode & FMODE_EXCL) {
Tejun Heo6a027ef2010-11-13 11:55:17 +01001529 bool bdev_free;
1530
1531 /*
1532 * Release a claim on the device. The holder fields
1533 * are protected with bdev_lock. bd_mutex is to
1534 * synchronize disk_holder unlinking.
1535 */
Tejun Heo6a027ef2010-11-13 11:55:17 +01001536 spin_lock(&bdev_lock);
1537
1538 WARN_ON_ONCE(--bdev->bd_holders < 0);
1539 WARN_ON_ONCE(--bdev->bd_contains->bd_holders < 0);
1540
1541 /* bd_contains might point to self, check in a separate step */
1542 if ((bdev_free = !bdev->bd_holders))
1543 bdev->bd_holder = NULL;
1544 if (!bdev->bd_contains->bd_holders)
1545 bdev->bd_contains->bd_holder = NULL;
1546
1547 spin_unlock(&bdev_lock);
1548
Tejun Heo77ea8872010-12-08 20:57:37 +01001549 /*
1550 * If this was the last claim, remove holder link and
1551 * unblock evpoll if it was a write holder.
1552 */
Tejun Heo85ef06d2011-07-01 16:17:47 +02001553 if (bdev_free && bdev->bd_write_holder) {
1554 disk_unblock_events(bdev->bd_disk);
1555 bdev->bd_write_holder = false;
Tejun Heo77ea8872010-12-08 20:57:37 +01001556 }
Tejun Heo69362172011-03-09 19:54:27 +01001557 }
Tejun Heo77ea8872010-12-08 20:57:37 +01001558
Tejun Heo85ef06d2011-07-01 16:17:47 +02001559 /*
1560 * Trigger event checking and tell drivers to flush MEDIA_CHANGE
1561 * event. This is to ensure detection of media removal commanded
1562 * from userland - e.g. eject(1).
1563 */
1564 disk_flush_events(bdev->bd_disk, DISK_EVENT_MEDIA_CHANGE);
1565
1566 mutex_unlock(&bdev->bd_mutex);
1567
Al Viro9a1c3542008-02-22 20:40:24 -05001568 return __blkdev_put(bdev, mode, 0);
NeilBrown37be4122006-12-08 02:36:16 -08001569}
Peter Zijlstra2e7b6512006-12-08 02:36:13 -08001570EXPORT_SYMBOL(blkdev_put);
1571
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572static int blkdev_close(struct inode * inode, struct file * filp)
1573{
1574 struct block_device *bdev = I_BDEV(filp->f_mapping->host);
Tejun Heoe525fd82010-11-13 11:55:17 +01001575
Al Viro9a1c3542008-02-22 20:40:24 -05001576 return blkdev_put(bdev, filp->f_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577}
1578
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -07001579static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580{
Al Viro56b26ad2008-09-19 03:17:36 -04001581 struct block_device *bdev = I_BDEV(file->f_mapping->host);
1582 fmode_t mode = file->f_mode;
Christoph Hellwigfd4ce1a2008-11-05 14:58:42 +01001583
1584 /*
1585 * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
1586 * to updated it before every ioctl.
1587 */
Al Viro56b26ad2008-09-19 03:17:36 -04001588 if (file->f_flags & O_NDELAY)
Christoph Hellwigfd4ce1a2008-11-05 14:58:42 +01001589 mode |= FMODE_NDELAY;
1590 else
1591 mode &= ~FMODE_NDELAY;
1592
Al Viro56b26ad2008-09-19 03:17:36 -04001593 return blkdev_ioctl(bdev, mode, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594}
1595
Mikulas Patockab87570f2012-09-26 07:46:40 +02001596ssize_t blkdev_aio_read(struct kiocb *iocb, const struct iovec *iov,
1597 unsigned long nr_segs, loff_t pos)
1598{
1599 ssize_t ret;
1600 struct block_device *bdev = I_BDEV(iocb->ki_filp->f_mapping->host);
1601
Mikulas Patocka62ac6652012-09-26 07:46:43 +02001602 percpu_down_read(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +02001603
1604 ret = generic_file_aio_read(iocb, iov, nr_segs, pos);
1605
Mikulas Patocka62ac6652012-09-26 07:46:43 +02001606 percpu_up_read(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +02001607
1608 return ret;
1609}
1610EXPORT_SYMBOL_GPL(blkdev_aio_read);
1611
Theodore Ts'o87d8fe12009-01-03 09:47:09 -05001612/*
Christoph Hellwigeef99382009-08-20 17:43:41 +02001613 * Write data to the block device. Only intended for the block device itself
1614 * and the raw driver which basically is a fake block device.
1615 *
1616 * Does not take i_mutex for the write and thus is not for general purpose
1617 * use.
1618 */
1619ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
1620 unsigned long nr_segs, loff_t pos)
1621{
1622 struct file *file = iocb->ki_filp;
Mikulas Patockab87570f2012-09-26 07:46:40 +02001623 struct block_device *bdev = I_BDEV(file->f_mapping->host);
Jianpeng Ma53362a02012-08-02 09:50:39 +02001624 struct blk_plug plug;
Christoph Hellwigeef99382009-08-20 17:43:41 +02001625 ssize_t ret;
1626
1627 BUG_ON(iocb->ki_pos != pos);
1628
Jianpeng Ma53362a02012-08-02 09:50:39 +02001629 blk_start_plug(&plug);
Mikulas Patockab87570f2012-09-26 07:46:40 +02001630
Mikulas Patocka62ac6652012-09-26 07:46:43 +02001631 percpu_down_read(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +02001632
Christoph Hellwigeef99382009-08-20 17:43:41 +02001633 ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
1634 if (ret > 0 || ret == -EIOCBQUEUED) {
1635 ssize_t err;
1636
1637 err = generic_write_sync(file, pos, ret);
1638 if (err < 0 && ret > 0)
1639 ret = err;
1640 }
Mikulas Patockab87570f2012-09-26 07:46:40 +02001641
Mikulas Patocka62ac6652012-09-26 07:46:43 +02001642 percpu_up_read(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +02001643
Jianpeng Ma53362a02012-08-02 09:50:39 +02001644 blk_finish_plug(&plug);
Mikulas Patockab87570f2012-09-26 07:46:40 +02001645
Christoph Hellwigeef99382009-08-20 17:43:41 +02001646 return ret;
1647}
1648EXPORT_SYMBOL_GPL(blkdev_aio_write);
1649
Fengguang Wu3eab7312012-09-26 09:57:55 +02001650static int blkdev_mmap(struct file *file, struct vm_area_struct *vma)
Mikulas Patockab87570f2012-09-26 07:46:40 +02001651{
1652 int ret;
1653 struct block_device *bdev = I_BDEV(file->f_mapping->host);
1654
Mikulas Patocka62ac6652012-09-26 07:46:43 +02001655 percpu_down_read(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +02001656
1657 ret = generic_file_mmap(file, vma);
1658
Mikulas Patocka62ac6652012-09-26 07:46:43 +02001659 percpu_up_read(&bdev->bd_block_size_semaphore);
Mikulas Patockab87570f2012-09-26 07:46:40 +02001660
1661 return ret;
1662}
1663
Christoph Hellwigeef99382009-08-20 17:43:41 +02001664/*
Theodore Ts'o87d8fe12009-01-03 09:47:09 -05001665 * Try to release a page associated with block device when the system
1666 * is under memory pressure.
1667 */
1668static int blkdev_releasepage(struct page *page, gfp_t wait)
1669{
1670 struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
1671
1672 if (super && super->s_op->bdev_try_to_free_page)
1673 return super->s_op->bdev_try_to_free_page(super, page, wait);
1674
1675 return try_to_free_buffers(page);
1676}
1677
Adrian Bunk4c54ac62008-02-18 13:48:31 +01001678static const struct address_space_operations def_blk_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 .readpage = blkdev_readpage,
1680 .writepage = blkdev_writepage,
Nick Piggin6272b5a2007-10-16 01:25:04 -07001681 .write_begin = blkdev_write_begin,
1682 .write_end = blkdev_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 .writepages = generic_writepages,
Theodore Ts'o87d8fe12009-01-03 09:47:09 -05001684 .releasepage = blkdev_releasepage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 .direct_IO = blkdev_direct_IO,
1686};
1687
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001688const struct file_operations def_blk_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 .open = blkdev_open,
1690 .release = blkdev_close,
1691 .llseek = block_llseek,
Badari Pulavarty543ade12006-09-30 23:28:48 -07001692 .read = do_sync_read,
1693 .write = do_sync_write,
Mikulas Patockab87570f2012-09-26 07:46:40 +02001694 .aio_read = blkdev_aio_read,
Christoph Hellwigeef99382009-08-20 17:43:41 +02001695 .aio_write = blkdev_aio_write,
Mikulas Patockab87570f2012-09-26 07:46:40 +02001696 .mmap = blkdev_mmap,
Andrew Mortonb1dd3b22010-04-06 14:35:00 -07001697 .fsync = blkdev_fsync,
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -07001698 .unlocked_ioctl = block_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699#ifdef CONFIG_COMPAT
1700 .compat_ioctl = compat_blkdev_ioctl,
1701#endif
Jens Axboe7f9c51f2006-05-01 19:59:32 +02001702 .splice_read = generic_file_splice_read,
1703 .splice_write = generic_file_splice_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704};
1705
1706int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
1707{
1708 int res;
1709 mm_segment_t old_fs = get_fs();
1710 set_fs(KERNEL_DS);
Al Viro56b26ad2008-09-19 03:17:36 -04001711 res = blkdev_ioctl(bdev, 0, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 set_fs(old_fs);
1713 return res;
1714}
1715
1716EXPORT_SYMBOL(ioctl_by_bdev);
1717
1718/**
1719 * lookup_bdev - lookup a struct block_device by name
Randy Dunlap94e29592009-01-06 14:41:15 -08001720 * @pathname: special file representing the block device
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 *
Randy Dunlap57d1b532008-10-09 10:42:38 +02001722 * Get a reference to the blockdevice at @pathname in the current
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 * namespace if possible and return it. Return ERR_PTR(error)
1724 * otherwise.
1725 */
Al Viro421748e2008-08-02 01:04:36 -04001726struct block_device *lookup_bdev(const char *pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727{
1728 struct block_device *bdev;
1729 struct inode *inode;
Al Viro421748e2008-08-02 01:04:36 -04001730 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 int error;
1732
Al Viro421748e2008-08-02 01:04:36 -04001733 if (!pathname || !*pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 return ERR_PTR(-EINVAL);
1735
Al Viro421748e2008-08-02 01:04:36 -04001736 error = kern_path(pathname, LOOKUP_FOLLOW, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 if (error)
1738 return ERR_PTR(error);
1739
Al Viro421748e2008-08-02 01:04:36 -04001740 inode = path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 error = -ENOTBLK;
1742 if (!S_ISBLK(inode->i_mode))
1743 goto fail;
1744 error = -EACCES;
Al Viro421748e2008-08-02 01:04:36 -04001745 if (path.mnt->mnt_flags & MNT_NODEV)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 goto fail;
1747 error = -ENOMEM;
1748 bdev = bd_acquire(inode);
1749 if (!bdev)
1750 goto fail;
1751out:
Al Viro421748e2008-08-02 01:04:36 -04001752 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 return bdev;
1754fail:
1755 bdev = ERR_PTR(error);
1756 goto out;
1757}
Al Virod5686b42008-08-01 05:00:11 -04001758EXPORT_SYMBOL(lookup_bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
NeilBrown93b270f2011-02-24 17:25:47 +11001760int __invalidate_device(struct block_device *bdev, bool kill_dirty)
David Howellsb71e8a42006-08-29 19:06:11 +01001761{
1762 struct super_block *sb = get_super(bdev);
1763 int res = 0;
1764
1765 if (sb) {
1766 /*
1767 * no need to lock the super, get_super holds the
1768 * read mutex so the filesystem cannot go away
1769 * under us (->put_super runs with the write lock
1770 * hold).
1771 */
1772 shrink_dcache_sb(sb);
NeilBrown93b270f2011-02-24 17:25:47 +11001773 res = invalidate_inodes(sb, kill_dirty);
David Howellsb71e8a42006-08-29 19:06:11 +01001774 drop_super(sb);
1775 }
Peter Zijlstraf98393a2007-05-06 14:49:54 -07001776 invalidate_bdev(bdev);
David Howellsb71e8a42006-08-29 19:06:11 +01001777 return res;
1778}
1779EXPORT_SYMBOL(__invalidate_device);
Jan Kara5c0d6b62012-07-03 16:45:31 +02001780
1781void iterate_bdevs(void (*func)(struct block_device *, void *), void *arg)
1782{
1783 struct inode *inode, *old_inode = NULL;
1784
1785 spin_lock(&inode_sb_list_lock);
1786 list_for_each_entry(inode, &blockdev_superblock->s_inodes, i_sb_list) {
1787 struct address_space *mapping = inode->i_mapping;
1788
1789 spin_lock(&inode->i_lock);
1790 if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW) ||
1791 mapping->nrpages == 0) {
1792 spin_unlock(&inode->i_lock);
1793 continue;
1794 }
1795 __iget(inode);
1796 spin_unlock(&inode->i_lock);
1797 spin_unlock(&inode_sb_list_lock);
1798 /*
1799 * We hold a reference to 'inode' so it couldn't have been
1800 * removed from s_inodes list while we dropped the
1801 * inode_sb_list_lock. We cannot iput the inode now as we can
1802 * be holding the last reference and we cannot iput it under
1803 * inode_sb_list_lock. So we keep the reference and iput it
1804 * later.
1805 */
1806 iput(old_inode);
1807 old_inode = inode;
1808
1809 func(I_BDEV(inode), arg);
1810
1811 spin_lock(&inode_sb_list_lock);
1812 }
1813 spin_unlock(&inode_sb_list_lock);
1814 iput(old_inode);
1815}