1
2
3
4
5
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/backing-dev.h>
18#include <linux/module.h>
19#include <linux/blkpg.h>
20#include <linux/magic.h>
21#include <linux/buffer_head.h>
22#include <linux/swap.h>
23#include <linux/pagevec.h>
24#include <linux/writeback.h>
25#include <linux/mpage.h>
26#include <linux/mount.h>
27#include <linux/uio.h>
28#include <linux/namei.h>
29#include <linux/log2.h>
30#include <linux/cleancache.h>
31#include <linux/dax.h>
32#include <asm/uaccess.h>
33#include "internal.h"
34
35struct bdev_inode {
36 struct block_device bdev;
37 struct inode vfs_inode;
38};
39
40static const struct address_space_operations def_blk_aops;
41
42static inline struct bdev_inode *BDEV_I(struct inode *inode)
43{
44 return container_of(inode, struct bdev_inode, vfs_inode);
45}
46
47struct block_device *I_BDEV(struct inode *inode)
48{
49 return &BDEV_I(inode)->bdev;
50}
51EXPORT_SYMBOL(I_BDEV);
52
53static void bdev_write_inode(struct block_device *bdev)
54{
55 struct inode *inode = bdev->bd_inode;
56 int ret;
57
58 spin_lock(&inode->i_lock);
59 while (inode->i_state & I_DIRTY) {
60 spin_unlock(&inode->i_lock);
61 ret = write_inode_now(inode, true);
62 if (ret) {
63 char name[BDEVNAME_SIZE];
64 pr_warn_ratelimited("VFS: Dirty inode writeback failed "
65 "for block device %s (err=%d).\n",
66 bdevname(bdev, name), ret);
67 }
68 spin_lock(&inode->i_lock);
69 }
70 spin_unlock(&inode->i_lock);
71}
72
73
74void kill_bdev(struct block_device *bdev)
75{
76 struct address_space *mapping = bdev->bd_inode->i_mapping;
77
78 if (mapping->nrpages == 0 && mapping->nrexceptional == 0)
79 return;
80
81 invalidate_bh_lrus();
82 truncate_inode_pages(mapping, 0);
83}
84EXPORT_SYMBOL(kill_bdev);
85
86
87void invalidate_bdev(struct block_device *bdev)
88{
89 struct address_space *mapping = bdev->bd_inode->i_mapping;
90
91 if (mapping->nrpages == 0)
92 return;
93
94 invalidate_bh_lrus();
95 lru_add_drain_all();
96 invalidate_mapping_pages(mapping, 0, -1);
97
98
99
100 cleancache_invalidate_inode(mapping);
101}
102EXPORT_SYMBOL(invalidate_bdev);
103
104int set_blocksize(struct block_device *bdev, int size)
105{
106
107 if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
108 return -EINVAL;
109
110
111 if (size < bdev_logical_block_size(bdev))
112 return -EINVAL;
113
114
115 if (bdev->bd_block_size != size) {
116 sync_blockdev(bdev);
117 bdev->bd_block_size = size;
118 bdev->bd_inode->i_blkbits = blksize_bits(size);
119 kill_bdev(bdev);
120 }
121 return 0;
122}
123
124EXPORT_SYMBOL(set_blocksize);
125
126int sb_set_blocksize(struct super_block *sb, int size)
127{
128 if (set_blocksize(sb->s_bdev, size))
129 return 0;
130
131
132 sb->s_blocksize = size;
133 sb->s_blocksize_bits = blksize_bits(size);
134 return sb->s_blocksize;
135}
136
137EXPORT_SYMBOL(sb_set_blocksize);
138
139int sb_min_blocksize(struct super_block *sb, int size)
140{
141 int minsize = bdev_logical_block_size(sb->s_bdev);
142 if (size < minsize)
143 size = minsize;
144 return sb_set_blocksize(sb, size);
145}
146
147EXPORT_SYMBOL(sb_min_blocksize);
148
149static int
150blkdev_get_block(struct inode *inode, sector_t iblock,
151 struct buffer_head *bh, int create)
152{
153 bh->b_bdev = I_BDEV(inode);
154 bh->b_blocknr = iblock;
155 set_buffer_mapped(bh);
156 return 0;
157}
158
159static struct inode *bdev_file_inode(struct file *file)
160{
161 return file->f_mapping->host;
162}
163
164static ssize_t
165blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
166{
167 struct file *file = iocb->ki_filp;
168 struct inode *inode = bdev_file_inode(file);
169
170 if (IS_DAX(inode))
171 return dax_do_io(iocb, inode, iter, offset, blkdev_get_block,
172 NULL, DIO_SKIP_DIO_COUNT);
173 return __blockdev_direct_IO(iocb, inode, I_BDEV(inode), iter, offset,
174 blkdev_get_block, NULL, NULL,
175 DIO_SKIP_DIO_COUNT);
176}
177
178int __sync_blockdev(struct block_device *bdev, int wait)
179{
180 if (!bdev)
181 return 0;
182 if (!wait)
183 return filemap_flush(bdev->bd_inode->i_mapping);
184 return filemap_write_and_wait(bdev->bd_inode->i_mapping);
185}
186
187
188
189
190
191int sync_blockdev(struct block_device *bdev)
192{
193 return __sync_blockdev(bdev, 1);
194}
195EXPORT_SYMBOL(sync_blockdev);
196
197
198
199
200
201
202int fsync_bdev(struct block_device *bdev)
203{
204 struct super_block *sb = get_super(bdev);
205 if (sb) {
206 int res = sync_filesystem(sb);
207 drop_super(sb);
208 return res;
209 }
210 return sync_blockdev(bdev);
211}
212EXPORT_SYMBOL(fsync_bdev);
213
214
215
216
217
218
219
220
221
222
223
224
225
226struct super_block *freeze_bdev(struct block_device *bdev)
227{
228 struct super_block *sb;
229 int error = 0;
230
231 mutex_lock(&bdev->bd_fsfreeze_mutex);
232 if (++bdev->bd_fsfreeze_count > 1) {
233
234
235
236
237
238 sb = get_super(bdev);
239 drop_super(sb);
240 mutex_unlock(&bdev->bd_fsfreeze_mutex);
241 return sb;
242 }
243
244 sb = get_active_super(bdev);
245 if (!sb)
246 goto out;
247 if (sb->s_op->freeze_super)
248 error = sb->s_op->freeze_super(sb);
249 else
250 error = freeze_super(sb);
251 if (error) {
252 deactivate_super(sb);
253 bdev->bd_fsfreeze_count--;
254 mutex_unlock(&bdev->bd_fsfreeze_mutex);
255 return ERR_PTR(error);
256 }
257 deactivate_super(sb);
258 out:
259 sync_blockdev(bdev);
260 mutex_unlock(&bdev->bd_fsfreeze_mutex);
261 return sb;
262}
263EXPORT_SYMBOL(freeze_bdev);
264
265
266
267
268
269
270
271
272int thaw_bdev(struct block_device *bdev, struct super_block *sb)
273{
274 int error = -EINVAL;
275
276 mutex_lock(&bdev->bd_fsfreeze_mutex);
277 if (!bdev->bd_fsfreeze_count)
278 goto out;
279
280 error = 0;
281 if (--bdev->bd_fsfreeze_count > 0)
282 goto out;
283
284 if (!sb)
285 goto out;
286
287 if (sb->s_op->thaw_super)
288 error = sb->s_op->thaw_super(sb);
289 else
290 error = thaw_super(sb);
291 if (error) {
292 bdev->bd_fsfreeze_count++;
293 mutex_unlock(&bdev->bd_fsfreeze_mutex);
294 return error;
295 }
296out:
297 mutex_unlock(&bdev->bd_fsfreeze_mutex);
298 return 0;
299}
300EXPORT_SYMBOL(thaw_bdev);
301
302static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
303{
304 return block_write_full_page(page, blkdev_get_block, wbc);
305}
306
307static int blkdev_readpage(struct file * file, struct page * page)
308{
309 return block_read_full_page(page, blkdev_get_block);
310}
311
312static int blkdev_readpages(struct file *file, struct address_space *mapping,
313 struct list_head *pages, unsigned nr_pages)
314{
315 return mpage_readpages(mapping, pages, nr_pages, blkdev_get_block);
316}
317
318static int blkdev_write_begin(struct file *file, struct address_space *mapping,
319 loff_t pos, unsigned len, unsigned flags,
320 struct page **pagep, void **fsdata)
321{
322 return block_write_begin(mapping, pos, len, flags, pagep,
323 blkdev_get_block);
324}
325
326static int blkdev_write_end(struct file *file, struct address_space *mapping,
327 loff_t pos, unsigned len, unsigned copied,
328 struct page *page, void *fsdata)
329{
330 int ret;
331 ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
332
333 unlock_page(page);
334 put_page(page);
335
336 return ret;
337}
338
339
340
341
342
343
344static loff_t block_llseek(struct file *file, loff_t offset, int whence)
345{
346 struct inode *bd_inode = bdev_file_inode(file);
347 loff_t retval;
348
349 inode_lock(bd_inode);
350 retval = fixed_size_llseek(file, offset, whence, i_size_read(bd_inode));
351 inode_unlock(bd_inode);
352 return retval;
353}
354
355int blkdev_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
356{
357 struct inode *bd_inode = bdev_file_inode(filp);
358 struct block_device *bdev = I_BDEV(bd_inode);
359 int error;
360
361 error = filemap_write_and_wait_range(filp->f_mapping, start, end);
362 if (error)
363 return error;
364
365
366
367
368
369
370 error = blkdev_issue_flush(bdev, GFP_KERNEL, NULL);
371 if (error == -EOPNOTSUPP)
372 error = 0;
373
374 return error;
375}
376EXPORT_SYMBOL(blkdev_fsync);
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394int bdev_read_page(struct block_device *bdev, sector_t sector,
395 struct page *page)
396{
397 const struct block_device_operations *ops = bdev->bd_disk->fops;
398 int result = -EOPNOTSUPP;
399
400 if (!ops->rw_page || bdev_get_integrity(bdev))
401 return result;
402
403 result = blk_queue_enter(bdev->bd_queue, false);
404 if (result)
405 return result;
406 result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, READ);
407 blk_queue_exit(bdev->bd_queue);
408 return result;
409}
410EXPORT_SYMBOL_GPL(bdev_read_page);
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431int bdev_write_page(struct block_device *bdev, sector_t sector,
432 struct page *page, struct writeback_control *wbc)
433{
434 int result;
435 int rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE;
436 const struct block_device_operations *ops = bdev->bd_disk->fops;
437
438 if (!ops->rw_page || bdev_get_integrity(bdev))
439 return -EOPNOTSUPP;
440 result = blk_queue_enter(bdev->bd_queue, false);
441 if (result)
442 return result;
443
444 set_page_writeback(page);
445 result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, rw);
446 if (result)
447 end_page_writeback(page);
448 else
449 unlock_page(page);
450 blk_queue_exit(bdev->bd_queue);
451 return result;
452}
453EXPORT_SYMBOL_GPL(bdev_write_page);
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469long bdev_direct_access(struct block_device *bdev, struct blk_dax_ctl *dax)
470{
471 sector_t sector = dax->sector;
472 long avail, size = dax->size;
473 const struct block_device_operations *ops = bdev->bd_disk->fops;
474
475
476
477
478
479 might_sleep();
480
481 if (size < 0)
482 return size;
483 if (!ops->direct_access)
484 return -EOPNOTSUPP;
485 if ((sector + DIV_ROUND_UP(size, 512)) >
486 part_nr_sects_read(bdev->bd_part))
487 return -ERANGE;
488 sector += get_start_sect(bdev);
489 if (sector % (PAGE_SIZE / 512))
490 return -EINVAL;
491 avail = ops->direct_access(bdev, sector, &dax->addr, &dax->pfn);
492 if (!avail)
493 return -ERANGE;
494 if (avail > 0 && avail & ~PAGE_MASK)
495 return -ENXIO;
496 return min(avail, size);
497}
498EXPORT_SYMBOL_GPL(bdev_direct_access);
499
500
501
502
503
504static __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
505static struct kmem_cache * bdev_cachep __read_mostly;
506
507static struct inode *bdev_alloc_inode(struct super_block *sb)
508{
509 struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
510 if (!ei)
511 return NULL;
512 return &ei->vfs_inode;
513}
514
515static void bdev_i_callback(struct rcu_head *head)
516{
517 struct inode *inode = container_of(head, struct inode, i_rcu);
518 struct bdev_inode *bdi = BDEV_I(inode);
519
520 kmem_cache_free(bdev_cachep, bdi);
521}
522
523static void bdev_destroy_inode(struct inode *inode)
524{
525 call_rcu(&inode->i_rcu, bdev_i_callback);
526}
527
528static void init_once(void *foo)
529{
530 struct bdev_inode *ei = (struct bdev_inode *) foo;
531 struct block_device *bdev = &ei->bdev;
532
533 memset(bdev, 0, sizeof(*bdev));
534 mutex_init(&bdev->bd_mutex);
535 INIT_LIST_HEAD(&bdev->bd_inodes);
536 INIT_LIST_HEAD(&bdev->bd_list);
537#ifdef CONFIG_SYSFS
538 INIT_LIST_HEAD(&bdev->bd_holder_disks);
539#endif
540 inode_init_once(&ei->vfs_inode);
541
542 mutex_init(&bdev->bd_fsfreeze_mutex);
543}
544
545static inline void __bd_forget(struct inode *inode)
546{
547 list_del_init(&inode->i_devices);
548 inode->i_bdev = NULL;
549 inode->i_mapping = &inode->i_data;
550}
551
552static void bdev_evict_inode(struct inode *inode)
553{
554 struct block_device *bdev = &BDEV_I(inode)->bdev;
555 struct list_head *p;
556 truncate_inode_pages_final(&inode->i_data);
557 invalidate_inode_buffers(inode);
558 clear_inode(inode);
559 spin_lock(&bdev_lock);
560 while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
561 __bd_forget(list_entry(p, struct inode, i_devices));
562 }
563 list_del_init(&bdev->bd_list);
564 spin_unlock(&bdev_lock);
565}
566
567static const struct super_operations bdev_sops = {
568 .statfs = simple_statfs,
569 .alloc_inode = bdev_alloc_inode,
570 .destroy_inode = bdev_destroy_inode,
571 .drop_inode = generic_delete_inode,
572 .evict_inode = bdev_evict_inode,
573};
574
575static struct dentry *bd_mount(struct file_system_type *fs_type,
576 int flags, const char *dev_name, void *data)
577{
578 struct dentry *dent;
579 dent = mount_pseudo(fs_type, "bdev:", &bdev_sops, NULL, BDEVFS_MAGIC);
580 if (dent)
581 dent->d_sb->s_iflags |= SB_I_CGROUPWB;
582 return dent;
583}
584
585static struct file_system_type bd_type = {
586 .name = "bdev",
587 .mount = bd_mount,
588 .kill_sb = kill_anon_super,
589};
590
591struct super_block *blockdev_superblock __read_mostly;
592EXPORT_SYMBOL_GPL(blockdev_superblock);
593
594void __init bdev_cache_init(void)
595{
596 int err;
597 static struct vfsmount *bd_mnt;
598
599 bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
600 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
601 SLAB_MEM_SPREAD|SLAB_ACCOUNT|SLAB_PANIC),
602 init_once);
603 err = register_filesystem(&bd_type);
604 if (err)
605 panic("Cannot register bdev pseudo-fs");
606 bd_mnt = kern_mount(&bd_type);
607 if (IS_ERR(bd_mnt))
608 panic("Cannot create bdev pseudo-fs");
609 blockdev_superblock = bd_mnt->mnt_sb;
610}
611
612
613
614
615
616
617static inline unsigned long hash(dev_t dev)
618{
619 return MAJOR(dev)+MINOR(dev);
620}
621
622static int bdev_test(struct inode *inode, void *data)
623{
624 return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
625}
626
627static int bdev_set(struct inode *inode, void *data)
628{
629 BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
630 return 0;
631}
632
633static LIST_HEAD(all_bdevs);
634
635struct block_device *bdget(dev_t dev)
636{
637 struct block_device *bdev;
638 struct inode *inode;
639
640 inode = iget5_locked(blockdev_superblock, hash(dev),
641 bdev_test, bdev_set, &dev);
642
643 if (!inode)
644 return NULL;
645
646 bdev = &BDEV_I(inode)->bdev;
647
648 if (inode->i_state & I_NEW) {
649 bdev->bd_contains = NULL;
650 bdev->bd_super = NULL;
651 bdev->bd_inode = inode;
652 bdev->bd_block_size = (1 << inode->i_blkbits);
653 bdev->bd_part_count = 0;
654 bdev->bd_invalidated = 0;
655 inode->i_mode = S_IFBLK;
656 inode->i_rdev = dev;
657 inode->i_bdev = bdev;
658 inode->i_data.a_ops = &def_blk_aops;
659 mapping_set_gfp_mask(&inode->i_data, GFP_USER);
660 spin_lock(&bdev_lock);
661 list_add(&bdev->bd_list, &all_bdevs);
662 spin_unlock(&bdev_lock);
663 unlock_new_inode(inode);
664 }
665 return bdev;
666}
667
668EXPORT_SYMBOL(bdget);
669
670
671
672
673
674struct block_device *bdgrab(struct block_device *bdev)
675{
676 ihold(bdev->bd_inode);
677 return bdev;
678}
679EXPORT_SYMBOL(bdgrab);
680
681long nr_blockdev_pages(void)
682{
683 struct block_device *bdev;
684 long ret = 0;
685 spin_lock(&bdev_lock);
686 list_for_each_entry(bdev, &all_bdevs, bd_list) {
687 ret += bdev->bd_inode->i_mapping->nrpages;
688 }
689 spin_unlock(&bdev_lock);
690 return ret;
691}
692
693void bdput(struct block_device *bdev)
694{
695 iput(bdev->bd_inode);
696}
697
698EXPORT_SYMBOL(bdput);
699
700static struct block_device *bd_acquire(struct inode *inode)
701{
702 struct block_device *bdev;
703
704 spin_lock(&bdev_lock);
705 bdev = inode->i_bdev;
706 if (bdev) {
707 bdgrab(bdev);
708 spin_unlock(&bdev_lock);
709 return bdev;
710 }
711 spin_unlock(&bdev_lock);
712
713 bdev = bdget(inode->i_rdev);
714 if (bdev) {
715 spin_lock(&bdev_lock);
716 if (!inode->i_bdev) {
717
718
719
720
721
722
723 bdgrab(bdev);
724 inode->i_bdev = bdev;
725 inode->i_mapping = bdev->bd_inode->i_mapping;
726 list_add(&inode->i_devices, &bdev->bd_inodes);
727 }
728 spin_unlock(&bdev_lock);
729 }
730 return bdev;
731}
732
733
734
735void bd_forget(struct inode *inode)
736{
737 struct block_device *bdev = NULL;
738
739 spin_lock(&bdev_lock);
740 if (!sb_is_blkdev_sb(inode->i_sb))
741 bdev = inode->i_bdev;
742 __bd_forget(inode);
743 spin_unlock(&bdev_lock);
744
745 if (bdev)
746 bdput(bdev);
747}
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763static bool bd_may_claim(struct block_device *bdev, struct block_device *whole,
764 void *holder)
765{
766 if (bdev->bd_holder == holder)
767 return true;
768 else if (bdev->bd_holder != NULL)
769 return false;
770 else if (bdev->bd_contains == bdev)
771 return true;
772
773 else if (whole->bd_holder == bd_may_claim)
774 return true;
775 else if (whole->bd_holder != NULL)
776 return false;
777 else
778 return true;
779}
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799static int bd_prepare_to_claim(struct block_device *bdev,
800 struct block_device *whole, void *holder)
801{
802retry:
803
804 if (!bd_may_claim(bdev, whole, holder))
805 return -EBUSY;
806
807
808 if (whole->bd_claiming) {
809 wait_queue_head_t *wq = bit_waitqueue(&whole->bd_claiming, 0);
810 DEFINE_WAIT(wait);
811
812 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
813 spin_unlock(&bdev_lock);
814 schedule();
815 finish_wait(wq, &wait);
816 spin_lock(&bdev_lock);
817 goto retry;
818 }
819
820
821 return 0;
822}
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847static struct block_device *bd_start_claiming(struct block_device *bdev,
848 void *holder)
849{
850 struct gendisk *disk;
851 struct block_device *whole;
852 int partno, err;
853
854 might_sleep();
855
856
857
858
859
860 disk = get_gendisk(bdev->bd_dev, &partno);
861 if (!disk)
862 return ERR_PTR(-ENXIO);
863
864
865
866
867
868
869
870
871
872 if (partno)
873 whole = bdget_disk(disk, 0);
874 else
875 whole = bdgrab(bdev);
876
877 module_put(disk->fops->owner);
878 put_disk(disk);
879 if (!whole)
880 return ERR_PTR(-ENOMEM);
881
882
883 spin_lock(&bdev_lock);
884
885 err = bd_prepare_to_claim(bdev, whole, holder);
886 if (err == 0) {
887 whole->bd_claiming = holder;
888 spin_unlock(&bdev_lock);
889 return whole;
890 } else {
891 spin_unlock(&bdev_lock);
892 bdput(whole);
893 return ERR_PTR(err);
894 }
895}
896
897#ifdef CONFIG_SYSFS
898struct bd_holder_disk {
899 struct list_head list;
900 struct gendisk *disk;
901 int refcnt;
902};
903
904static struct bd_holder_disk *bd_find_holder_disk(struct block_device *bdev,
905 struct gendisk *disk)
906{
907 struct bd_holder_disk *holder;
908
909 list_for_each_entry(holder, &bdev->bd_holder_disks, list)
910 if (holder->disk == disk)
911 return holder;
912 return NULL;
913}
914
915static int add_symlink(struct kobject *from, struct kobject *to)
916{
917 return sysfs_create_link(from, to, kobject_name(to));
918}
919
920static void del_symlink(struct kobject *from, struct kobject *to)
921{
922 sysfs_remove_link(from, kobject_name(to));
923}
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk)
954{
955 struct bd_holder_disk *holder;
956 int ret = 0;
957
958 mutex_lock(&bdev->bd_mutex);
959
960 WARN_ON_ONCE(!bdev->bd_holder);
961
962
963 if (WARN_ON(!disk->slave_dir || !bdev->bd_part->holder_dir))
964 goto out_unlock;
965
966 holder = bd_find_holder_disk(bdev, disk);
967 if (holder) {
968 holder->refcnt++;
969 goto out_unlock;
970 }
971
972 holder = kzalloc(sizeof(*holder), GFP_KERNEL);
973 if (!holder) {
974 ret = -ENOMEM;
975 goto out_unlock;
976 }
977
978 INIT_LIST_HEAD(&holder->list);
979 holder->disk = disk;
980 holder->refcnt = 1;
981
982 ret = add_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
983 if (ret)
984 goto out_free;
985
986 ret = add_symlink(bdev->bd_part->holder_dir, &disk_to_dev(disk)->kobj);
987 if (ret)
988 goto out_del;
989
990
991
992
993 kobject_get(bdev->bd_part->holder_dir);
994
995 list_add(&holder->list, &bdev->bd_holder_disks);
996 goto out_unlock;
997
998out_del:
999 del_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
1000out_free:
1001 kfree(holder);
1002out_unlock:
1003 mutex_unlock(&bdev->bd_mutex);
1004 return ret;
1005}
1006EXPORT_SYMBOL_GPL(bd_link_disk_holder);
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018void bd_unlink_disk_holder(struct block_device *bdev, struct gendisk *disk)
1019{
1020 struct bd_holder_disk *holder;
1021
1022 mutex_lock(&bdev->bd_mutex);
1023
1024 holder = bd_find_holder_disk(bdev, disk);
1025
1026 if (!WARN_ON_ONCE(holder == NULL) && !--holder->refcnt) {
1027 del_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
1028 del_symlink(bdev->bd_part->holder_dir,
1029 &disk_to_dev(disk)->kobj);
1030 kobject_put(bdev->bd_part->holder_dir);
1031 list_del_init(&holder->list);
1032 kfree(holder);
1033 }
1034
1035 mutex_unlock(&bdev->bd_mutex);
1036}
1037EXPORT_SYMBOL_GPL(bd_unlink_disk_holder);
1038#endif
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050static void flush_disk(struct block_device *bdev, bool kill_dirty)
1051{
1052 if (__invalidate_device(bdev, kill_dirty)) {
1053 printk(KERN_WARNING "VFS: busy inodes on changed media or "
1054 "resized disk %s\n",
1055 bdev->bd_disk ? bdev->bd_disk->disk_name : "");
1056 }
1057
1058 if (!bdev->bd_disk)
1059 return;
1060 if (disk_part_scan_enabled(bdev->bd_disk))
1061 bdev->bd_invalidated = 1;
1062}
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
1073{
1074 loff_t disk_size, bdev_size;
1075
1076 disk_size = (loff_t)get_capacity(disk) << 9;
1077 bdev_size = i_size_read(bdev->bd_inode);
1078 if (disk_size != bdev_size) {
1079 printk(KERN_INFO
1080 "%s: detected capacity change from %lld to %lld\n",
1081 disk->disk_name, bdev_size, disk_size);
1082 i_size_write(bdev->bd_inode, disk_size);
1083 flush_disk(bdev, false);
1084 }
1085}
1086EXPORT_SYMBOL(check_disk_size_change);
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096int revalidate_disk(struct gendisk *disk)
1097{
1098 struct block_device *bdev;
1099 int ret = 0;
1100
1101 if (disk->fops->revalidate_disk)
1102 ret = disk->fops->revalidate_disk(disk);
1103 blk_integrity_revalidate(disk);
1104 bdev = bdget_disk(disk, 0);
1105 if (!bdev)
1106 return ret;
1107
1108 mutex_lock(&bdev->bd_mutex);
1109 check_disk_size_change(disk, bdev);
1110 bdev->bd_invalidated = 0;
1111 mutex_unlock(&bdev->bd_mutex);
1112 bdput(bdev);
1113 return ret;
1114}
1115EXPORT_SYMBOL(revalidate_disk);
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126int check_disk_change(struct block_device *bdev)
1127{
1128 struct gendisk *disk = bdev->bd_disk;
1129 const struct block_device_operations *bdops = disk->fops;
1130 unsigned int events;
1131
1132 events = disk_clear_events(disk, DISK_EVENT_MEDIA_CHANGE |
1133 DISK_EVENT_EJECT_REQUEST);
1134 if (!(events & DISK_EVENT_MEDIA_CHANGE))
1135 return 0;
1136
1137 flush_disk(bdev, true);
1138 if (bdops->revalidate_disk)
1139 bdops->revalidate_disk(bdev->bd_disk);
1140 return 1;
1141}
1142
1143EXPORT_SYMBOL(check_disk_change);
1144
1145void bd_set_size(struct block_device *bdev, loff_t size)
1146{
1147 unsigned bsize = bdev_logical_block_size(bdev);
1148
1149 inode_lock(bdev->bd_inode);
1150 i_size_write(bdev->bd_inode, size);
1151 inode_unlock(bdev->bd_inode);
1152 while (bsize < PAGE_SIZE) {
1153 if (size & bsize)
1154 break;
1155 bsize <<= 1;
1156 }
1157 bdev->bd_block_size = bsize;
1158 bdev->bd_inode->i_blkbits = blksize_bits(bsize);
1159}
1160EXPORT_SYMBOL(bd_set_size);
1161
1162static void __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
1163
1164
1165
1166
1167
1168
1169
1170
1171static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
1172{
1173 struct gendisk *disk;
1174 struct module *owner;
1175 int ret;
1176 int partno;
1177 int perm = 0;
1178
1179 if (mode & FMODE_READ)
1180 perm |= MAY_READ;
1181 if (mode & FMODE_WRITE)
1182 perm |= MAY_WRITE;
1183
1184
1185
1186 if (!for_part) {
1187 ret = devcgroup_inode_permission(bdev->bd_inode, perm);
1188 if (ret != 0) {
1189 bdput(bdev);
1190 return ret;
1191 }
1192 }
1193
1194 restart:
1195
1196 ret = -ENXIO;
1197 disk = get_gendisk(bdev->bd_dev, &partno);
1198 if (!disk)
1199 goto out;
1200 owner = disk->fops->owner;
1201
1202 disk_block_events(disk);
1203 mutex_lock_nested(&bdev->bd_mutex, for_part);
1204 if (!bdev->bd_openers) {
1205 bdev->bd_disk = disk;
1206 bdev->bd_queue = disk->queue;
1207 bdev->bd_contains = bdev;
1208 if (IS_ENABLED(CONFIG_BLK_DEV_DAX) && disk->fops->direct_access)
1209 bdev->bd_inode->i_flags = S_DAX;
1210 else
1211 bdev->bd_inode->i_flags = 0;
1212
1213 if (!partno) {
1214 ret = -ENXIO;
1215 bdev->bd_part = disk_get_part(disk, partno);
1216 if (!bdev->bd_part)
1217 goto out_clear;
1218
1219 ret = 0;
1220 if (disk->fops->open) {
1221 ret = disk->fops->open(bdev, mode);
1222 if (ret == -ERESTARTSYS) {
1223
1224
1225
1226
1227 disk_put_part(bdev->bd_part);
1228 bdev->bd_part = NULL;
1229 bdev->bd_disk = NULL;
1230 bdev->bd_queue = NULL;
1231 mutex_unlock(&bdev->bd_mutex);
1232 disk_unblock_events(disk);
1233 put_disk(disk);
1234 module_put(owner);
1235 goto restart;
1236 }
1237 }
1238
1239 if (!ret) {
1240 bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
1241 if (!blkdev_dax_capable(bdev))
1242 bdev->bd_inode->i_flags &= ~S_DAX;
1243 }
1244
1245
1246
1247
1248
1249
1250
1251 if (bdev->bd_invalidated) {
1252 if (!ret)
1253 rescan_partitions(disk, bdev);
1254 else if (ret == -ENOMEDIUM)
1255 invalidate_partitions(disk, bdev);
1256 }
1257
1258 if (ret)
1259 goto out_clear;
1260 } else {
1261 struct block_device *whole;
1262 whole = bdget_disk(disk, 0);
1263 ret = -ENOMEM;
1264 if (!whole)
1265 goto out_clear;
1266 BUG_ON(for_part);
1267 ret = __blkdev_get(whole, mode, 1);
1268 if (ret)
1269 goto out_clear;
1270 bdev->bd_contains = whole;
1271 bdev->bd_part = disk_get_part(disk, partno);
1272 if (!(disk->flags & GENHD_FL_UP) ||
1273 !bdev->bd_part || !bdev->bd_part->nr_sects) {
1274 ret = -ENXIO;
1275 goto out_clear;
1276 }
1277 bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
1278 if (!blkdev_dax_capable(bdev))
1279 bdev->bd_inode->i_flags &= ~S_DAX;
1280 }
1281 } else {
1282 if (bdev->bd_contains == bdev) {
1283 ret = 0;
1284 if (bdev->bd_disk->fops->open)
1285 ret = bdev->bd_disk->fops->open(bdev, mode);
1286
1287 if (bdev->bd_invalidated) {
1288 if (!ret)
1289 rescan_partitions(bdev->bd_disk, bdev);
1290 else if (ret == -ENOMEDIUM)
1291 invalidate_partitions(bdev->bd_disk, bdev);
1292 }
1293 if (ret)
1294 goto out_unlock_bdev;
1295 }
1296
1297 put_disk(disk);
1298 module_put(owner);
1299 }
1300 bdev->bd_openers++;
1301 if (for_part)
1302 bdev->bd_part_count++;
1303 mutex_unlock(&bdev->bd_mutex);
1304 disk_unblock_events(disk);
1305 return 0;
1306
1307 out_clear:
1308 disk_put_part(bdev->bd_part);
1309 bdev->bd_disk = NULL;
1310 bdev->bd_part = NULL;
1311 bdev->bd_queue = NULL;
1312 if (bdev != bdev->bd_contains)
1313 __blkdev_put(bdev->bd_contains, mode, 1);
1314 bdev->bd_contains = NULL;
1315 out_unlock_bdev:
1316 mutex_unlock(&bdev->bd_mutex);
1317 disk_unblock_events(disk);
1318 put_disk(disk);
1319 module_put(owner);
1320 out:
1321 bdput(bdev);
1322
1323 return ret;
1324}
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder)
1346{
1347 struct block_device *whole = NULL;
1348 int res;
1349
1350 WARN_ON_ONCE((mode & FMODE_EXCL) && !holder);
1351
1352 if ((mode & FMODE_EXCL) && holder) {
1353 whole = bd_start_claiming(bdev, holder);
1354 if (IS_ERR(whole)) {
1355 bdput(bdev);
1356 return PTR_ERR(whole);
1357 }
1358 }
1359
1360 res = __blkdev_get(bdev, mode, 0);
1361
1362 if (whole) {
1363 struct gendisk *disk = whole->bd_disk;
1364
1365
1366 mutex_lock(&bdev->bd_mutex);
1367 spin_lock(&bdev_lock);
1368
1369 if (!res) {
1370 BUG_ON(!bd_may_claim(bdev, whole, holder));
1371
1372
1373
1374
1375
1376
1377 whole->bd_holders++;
1378 whole->bd_holder = bd_may_claim;
1379 bdev->bd_holders++;
1380 bdev->bd_holder = holder;
1381 }
1382
1383
1384 BUG_ON(whole->bd_claiming != holder);
1385 whole->bd_claiming = NULL;
1386 wake_up_bit(&whole->bd_claiming, 0);
1387
1388 spin_unlock(&bdev_lock);
1389
1390
1391
1392
1393
1394
1395
1396
1397 if (!res && (mode & FMODE_WRITE) && !bdev->bd_write_holder &&
1398 (disk->flags & GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE)) {
1399 bdev->bd_write_holder = true;
1400 disk_block_events(disk);
1401 }
1402
1403 mutex_unlock(&bdev->bd_mutex);
1404 bdput(whole);
1405 }
1406
1407 return res;
1408}
1409EXPORT_SYMBOL(blkdev_get);
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
1429 void *holder)
1430{
1431 struct block_device *bdev;
1432 int err;
1433
1434 bdev = lookup_bdev(path);
1435 if (IS_ERR(bdev))
1436 return bdev;
1437
1438 err = blkdev_get(bdev, mode, holder);
1439 if (err)
1440 return ERR_PTR(err);
1441
1442 if ((mode & FMODE_WRITE) && bdev_read_only(bdev)) {
1443 blkdev_put(bdev, mode);
1444 return ERR_PTR(-EACCES);
1445 }
1446
1447 return bdev;
1448}
1449EXPORT_SYMBOL(blkdev_get_by_path);
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder)
1474{
1475 struct block_device *bdev;
1476 int err;
1477
1478 bdev = bdget(dev);
1479 if (!bdev)
1480 return ERR_PTR(-ENOMEM);
1481
1482 err = blkdev_get(bdev, mode, holder);
1483 if (err)
1484 return ERR_PTR(err);
1485
1486 return bdev;
1487}
1488EXPORT_SYMBOL(blkdev_get_by_dev);
1489
1490static int blkdev_open(struct inode * inode, struct file * filp)
1491{
1492 struct block_device *bdev;
1493
1494
1495
1496
1497
1498
1499
1500 filp->f_flags |= O_LARGEFILE;
1501
1502 if (filp->f_flags & O_NDELAY)
1503 filp->f_mode |= FMODE_NDELAY;
1504 if (filp->f_flags & O_EXCL)
1505 filp->f_mode |= FMODE_EXCL;
1506 if ((filp->f_flags & O_ACCMODE) == 3)
1507 filp->f_mode |= FMODE_WRITE_IOCTL;
1508
1509 bdev = bd_acquire(inode);
1510 if (bdev == NULL)
1511 return -ENOMEM;
1512
1513 filp->f_mapping = bdev->bd_inode->i_mapping;
1514
1515 return blkdev_get(bdev, filp->f_mode, filp);
1516}
1517
1518static void __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
1519{
1520 struct gendisk *disk = bdev->bd_disk;
1521 struct block_device *victim = NULL;
1522
1523 mutex_lock_nested(&bdev->bd_mutex, for_part);
1524 if (for_part)
1525 bdev->bd_part_count--;
1526
1527 if (!--bdev->bd_openers) {
1528 WARN_ON_ONCE(bdev->bd_holders);
1529 sync_blockdev(bdev);
1530 kill_bdev(bdev);
1531
1532 bdev_write_inode(bdev);
1533
1534
1535
1536
1537
1538 inode_detach_wb(bdev->bd_inode);
1539 }
1540 if (bdev->bd_contains == bdev) {
1541 if (disk->fops->release)
1542 disk->fops->release(disk, mode);
1543 }
1544 if (!bdev->bd_openers) {
1545 struct module *owner = disk->fops->owner;
1546
1547 disk_put_part(bdev->bd_part);
1548 bdev->bd_part = NULL;
1549 bdev->bd_disk = NULL;
1550 if (bdev != bdev->bd_contains)
1551 victim = bdev->bd_contains;
1552 bdev->bd_contains = NULL;
1553
1554 put_disk(disk);
1555 module_put(owner);
1556 }
1557 mutex_unlock(&bdev->bd_mutex);
1558 bdput(bdev);
1559 if (victim)
1560 __blkdev_put(victim, mode, 1);
1561}
1562
1563void blkdev_put(struct block_device *bdev, fmode_t mode)
1564{
1565 mutex_lock(&bdev->bd_mutex);
1566
1567 if (mode & FMODE_EXCL) {
1568 bool bdev_free;
1569
1570
1571
1572
1573
1574
1575 spin_lock(&bdev_lock);
1576
1577 WARN_ON_ONCE(--bdev->bd_holders < 0);
1578 WARN_ON_ONCE(--bdev->bd_contains->bd_holders < 0);
1579
1580
1581 if ((bdev_free = !bdev->bd_holders))
1582 bdev->bd_holder = NULL;
1583 if (!bdev->bd_contains->bd_holders)
1584 bdev->bd_contains->bd_holder = NULL;
1585
1586 spin_unlock(&bdev_lock);
1587
1588
1589
1590
1591
1592 if (bdev_free && bdev->bd_write_holder) {
1593 disk_unblock_events(bdev->bd_disk);
1594 bdev->bd_write_holder = false;
1595 }
1596 }
1597
1598
1599
1600
1601
1602
1603 disk_flush_events(bdev->bd_disk, DISK_EVENT_MEDIA_CHANGE);
1604
1605 mutex_unlock(&bdev->bd_mutex);
1606
1607 __blkdev_put(bdev, mode, 0);
1608}
1609EXPORT_SYMBOL(blkdev_put);
1610
1611static int blkdev_close(struct inode * inode, struct file * filp)
1612{
1613 struct block_device *bdev = I_BDEV(bdev_file_inode(filp));
1614 blkdev_put(bdev, filp->f_mode);
1615 return 0;
1616}
1617
1618static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1619{
1620 struct block_device *bdev = I_BDEV(bdev_file_inode(file));
1621 fmode_t mode = file->f_mode;
1622
1623
1624
1625
1626
1627 if (file->f_flags & O_NDELAY)
1628 mode |= FMODE_NDELAY;
1629 else
1630 mode &= ~FMODE_NDELAY;
1631
1632 return blkdev_ioctl(bdev, mode, cmd, arg);
1633}
1634
1635
1636
1637
1638
1639
1640
1641
1642ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from)
1643{
1644 struct file *file = iocb->ki_filp;
1645 struct inode *bd_inode = bdev_file_inode(file);
1646 loff_t size = i_size_read(bd_inode);
1647 struct blk_plug plug;
1648 ssize_t ret;
1649
1650 if (bdev_read_only(I_BDEV(bd_inode)))
1651 return -EPERM;
1652
1653 if (!iov_iter_count(from))
1654 return 0;
1655
1656 if (iocb->ki_pos >= size)
1657 return -ENOSPC;
1658
1659 iov_iter_truncate(from, size - iocb->ki_pos);
1660
1661 blk_start_plug(&plug);
1662 ret = __generic_file_write_iter(iocb, from);
1663 if (ret > 0) {
1664 ssize_t err;
1665 err = generic_write_sync(file, iocb->ki_pos - ret, ret);
1666 if (err < 0)
1667 ret = err;
1668 }
1669 blk_finish_plug(&plug);
1670 return ret;
1671}
1672EXPORT_SYMBOL_GPL(blkdev_write_iter);
1673
1674ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to)
1675{
1676 struct file *file = iocb->ki_filp;
1677 struct inode *bd_inode = bdev_file_inode(file);
1678 loff_t size = i_size_read(bd_inode);
1679 loff_t pos = iocb->ki_pos;
1680
1681 if (pos >= size)
1682 return 0;
1683
1684 size -= pos;
1685 iov_iter_truncate(to, size);
1686 return generic_file_read_iter(iocb, to);
1687}
1688EXPORT_SYMBOL_GPL(blkdev_read_iter);
1689
1690
1691
1692
1693
1694static int blkdev_releasepage(struct page *page, gfp_t wait)
1695{
1696 struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
1697
1698 if (super && super->s_op->bdev_try_to_free_page)
1699 return super->s_op->bdev_try_to_free_page(super, page, wait);
1700
1701 return try_to_free_buffers(page);
1702}
1703
1704static int blkdev_writepages(struct address_space *mapping,
1705 struct writeback_control *wbc)
1706{
1707 if (dax_mapping(mapping)) {
1708 struct block_device *bdev = I_BDEV(mapping->host);
1709
1710 return dax_writeback_mapping_range(mapping, bdev, wbc);
1711 }
1712 return generic_writepages(mapping, wbc);
1713}
1714
1715static const struct address_space_operations def_blk_aops = {
1716 .readpage = blkdev_readpage,
1717 .readpages = blkdev_readpages,
1718 .writepage = blkdev_writepage,
1719 .write_begin = blkdev_write_begin,
1720 .write_end = blkdev_write_end,
1721 .writepages = blkdev_writepages,
1722 .releasepage = blkdev_releasepage,
1723 .direct_IO = blkdev_direct_IO,
1724 .is_dirty_writeback = buffer_check_dirty_writeback,
1725};
1726
1727#ifdef CONFIG_FS_DAX
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747static int blkdev_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1748{
1749 return __dax_fault(vma, vmf, blkdev_get_block, NULL);
1750}
1751
1752static int blkdev_dax_pfn_mkwrite(struct vm_area_struct *vma,
1753 struct vm_fault *vmf)
1754{
1755 return dax_pfn_mkwrite(vma, vmf);
1756}
1757
1758static int blkdev_dax_pmd_fault(struct vm_area_struct *vma, unsigned long addr,
1759 pmd_t *pmd, unsigned int flags)
1760{
1761 return __dax_pmd_fault(vma, addr, pmd, flags, blkdev_get_block, NULL);
1762}
1763
1764static const struct vm_operations_struct blkdev_dax_vm_ops = {
1765 .fault = blkdev_dax_fault,
1766 .pmd_fault = blkdev_dax_pmd_fault,
1767 .pfn_mkwrite = blkdev_dax_pfn_mkwrite,
1768};
1769
1770static const struct vm_operations_struct blkdev_default_vm_ops = {
1771 .fault = filemap_fault,
1772 .map_pages = filemap_map_pages,
1773};
1774
1775static int blkdev_mmap(struct file *file, struct vm_area_struct *vma)
1776{
1777 struct inode *bd_inode = bdev_file_inode(file);
1778
1779 file_accessed(file);
1780 if (IS_DAX(bd_inode)) {
1781 vma->vm_ops = &blkdev_dax_vm_ops;
1782 vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
1783 } else {
1784 vma->vm_ops = &blkdev_default_vm_ops;
1785 }
1786
1787 return 0;
1788}
1789#else
1790#define blkdev_mmap generic_file_mmap
1791#endif
1792
1793const struct file_operations def_blk_fops = {
1794 .open = blkdev_open,
1795 .release = blkdev_close,
1796 .llseek = block_llseek,
1797 .read_iter = blkdev_read_iter,
1798 .write_iter = blkdev_write_iter,
1799 .mmap = blkdev_mmap,
1800 .fsync = blkdev_fsync,
1801 .unlocked_ioctl = block_ioctl,
1802#ifdef CONFIG_COMPAT
1803 .compat_ioctl = compat_blkdev_ioctl,
1804#endif
1805 .splice_read = generic_file_splice_read,
1806 .splice_write = iter_file_splice_write,
1807};
1808
1809int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
1810{
1811 int res;
1812 mm_segment_t old_fs = get_fs();
1813 set_fs(KERNEL_DS);
1814 res = blkdev_ioctl(bdev, 0, cmd, arg);
1815 set_fs(old_fs);
1816 return res;
1817}
1818
1819EXPORT_SYMBOL(ioctl_by_bdev);
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829struct block_device *lookup_bdev(const char *pathname)
1830{
1831 struct block_device *bdev;
1832 struct inode *inode;
1833 struct path path;
1834 int error;
1835
1836 if (!pathname || !*pathname)
1837 return ERR_PTR(-EINVAL);
1838
1839 error = kern_path(pathname, LOOKUP_FOLLOW, &path);
1840 if (error)
1841 return ERR_PTR(error);
1842
1843 inode = d_backing_inode(path.dentry);
1844 error = -ENOTBLK;
1845 if (!S_ISBLK(inode->i_mode))
1846 goto fail;
1847 error = -EACCES;
1848 if (path.mnt->mnt_flags & MNT_NODEV)
1849 goto fail;
1850 error = -ENOMEM;
1851 bdev = bd_acquire(inode);
1852 if (!bdev)
1853 goto fail;
1854out:
1855 path_put(&path);
1856 return bdev;
1857fail:
1858 bdev = ERR_PTR(error);
1859 goto out;
1860}
1861EXPORT_SYMBOL(lookup_bdev);
1862
1863int __invalidate_device(struct block_device *bdev, bool kill_dirty)
1864{
1865 struct super_block *sb = get_super(bdev);
1866 int res = 0;
1867
1868 if (sb) {
1869
1870
1871
1872
1873
1874
1875 shrink_dcache_sb(sb);
1876 res = invalidate_inodes(sb, kill_dirty);
1877 drop_super(sb);
1878 }
1879 invalidate_bdev(bdev);
1880 return res;
1881}
1882EXPORT_SYMBOL(__invalidate_device);
1883
1884void iterate_bdevs(void (*func)(struct block_device *, void *), void *arg)
1885{
1886 struct inode *inode, *old_inode = NULL;
1887
1888 spin_lock(&blockdev_superblock->s_inode_list_lock);
1889 list_for_each_entry(inode, &blockdev_superblock->s_inodes, i_sb_list) {
1890 struct address_space *mapping = inode->i_mapping;
1891
1892 spin_lock(&inode->i_lock);
1893 if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW) ||
1894 mapping->nrpages == 0) {
1895 spin_unlock(&inode->i_lock);
1896 continue;
1897 }
1898 __iget(inode);
1899 spin_unlock(&inode->i_lock);
1900 spin_unlock(&blockdev_superblock->s_inode_list_lock);
1901
1902
1903
1904
1905
1906
1907
1908
1909 iput(old_inode);
1910 old_inode = inode;
1911
1912 func(I_BDEV(inode), arg);
1913
1914 spin_lock(&blockdev_superblock->s_inode_list_lock);
1915 }
1916 spin_unlock(&blockdev_superblock->s_inode_list_lock);
1917 iput(old_inode);
1918}
1919