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