1
2
3
4
5#include <linux/module.h>
6#include <linux/fs.h>
7#include <linux/genhd.h>
8#include <linux/kdev_t.h>
9#include <linux/kernel.h>
10#include <linux/blkdev.h>
11#include <linux/backing-dev.h>
12#include <linux/init.h>
13#include <linux/spinlock.h>
14#include <linux/proc_fs.h>
15#include <linux/seq_file.h>
16#include <linux/slab.h>
17#include <linux/kmod.h>
18#include <linux/kobj_map.h>
19#include <linux/mutex.h>
20#include <linux/idr.h>
21#include <linux/log2.h>
22#include <linux/pm_runtime.h>
23#include <linux/badblocks.h>
24
25#include "blk.h"
26
27static DEFINE_MUTEX(block_class_lock);
28struct kobject *block_depr;
29
30
31#define NR_EXT_DEVT (1 << MINORBITS)
32
33
34
35
36static DEFINE_SPINLOCK(ext_devt_lock);
37static DEFINE_IDR(ext_devt_idr);
38
39static const struct device_type disk_type;
40
41static void disk_check_events(struct disk_events *ev,
42 unsigned int *clearing_ptr);
43static void disk_alloc_events(struct gendisk *disk);
44static void disk_add_events(struct gendisk *disk);
45static void disk_del_events(struct gendisk *disk);
46static void disk_release_events(struct gendisk *disk);
47
48void part_inc_in_flight(struct request_queue *q, struct hd_struct *part, int rw)
49{
50 if (q->mq_ops)
51 return;
52
53 atomic_inc(&part->in_flight[rw]);
54 if (part->partno)
55 atomic_inc(&part_to_disk(part)->part0.in_flight[rw]);
56}
57
58void part_dec_in_flight(struct request_queue *q, struct hd_struct *part, int rw)
59{
60 if (q->mq_ops)
61 return;
62
63 atomic_dec(&part->in_flight[rw]);
64 if (part->partno)
65 atomic_dec(&part_to_disk(part)->part0.in_flight[rw]);
66}
67
68void part_in_flight(struct request_queue *q, struct hd_struct *part,
69 unsigned int inflight[2])
70{
71 if (q->mq_ops) {
72 blk_mq_in_flight(q, part, inflight);
73 return;
74 }
75
76 inflight[0] = atomic_read(&part->in_flight[0]) +
77 atomic_read(&part->in_flight[1]);
78 if (part->partno) {
79 part = &part_to_disk(part)->part0;
80 inflight[1] = atomic_read(&part->in_flight[0]) +
81 atomic_read(&part->in_flight[1]);
82 }
83}
84
85void part_in_flight_rw(struct request_queue *q, struct hd_struct *part,
86 unsigned int inflight[2])
87{
88 if (q->mq_ops) {
89 blk_mq_in_flight_rw(q, part, inflight);
90 return;
91 }
92
93 inflight[0] = atomic_read(&part->in_flight[0]);
94 inflight[1] = atomic_read(&part->in_flight[1]);
95}
96
97struct hd_struct *__disk_get_part(struct gendisk *disk, int partno)
98{
99 struct disk_part_tbl *ptbl = rcu_dereference(disk->part_tbl);
100
101 if (unlikely(partno < 0 || partno >= ptbl->len))
102 return NULL;
103 return rcu_dereference(ptbl->part[partno]);
104}
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120struct hd_struct *disk_get_part(struct gendisk *disk, int partno)
121{
122 struct hd_struct *part;
123
124 rcu_read_lock();
125 part = __disk_get_part(disk, partno);
126 if (part)
127 get_device(part_to_dev(part));
128 rcu_read_unlock();
129
130 return part;
131}
132EXPORT_SYMBOL_GPL(disk_get_part);
133
134
135
136
137
138
139
140
141
142
143
144
145void disk_part_iter_init(struct disk_part_iter *piter, struct gendisk *disk,
146 unsigned int flags)
147{
148 struct disk_part_tbl *ptbl;
149
150 rcu_read_lock();
151 ptbl = rcu_dereference(disk->part_tbl);
152
153 piter->disk = disk;
154 piter->part = NULL;
155
156 if (flags & DISK_PITER_REVERSE)
157 piter->idx = ptbl->len - 1;
158 else if (flags & (DISK_PITER_INCL_PART0 | DISK_PITER_INCL_EMPTY_PART0))
159 piter->idx = 0;
160 else
161 piter->idx = 1;
162
163 piter->flags = flags;
164
165 rcu_read_unlock();
166}
167EXPORT_SYMBOL_GPL(disk_part_iter_init);
168
169
170
171
172
173
174
175
176
177
178struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter)
179{
180 struct disk_part_tbl *ptbl;
181 int inc, end;
182
183
184 disk_put_part(piter->part);
185 piter->part = NULL;
186
187
188 rcu_read_lock();
189 ptbl = rcu_dereference(piter->disk->part_tbl);
190
191
192 if (piter->flags & DISK_PITER_REVERSE) {
193 inc = -1;
194 if (piter->flags & (DISK_PITER_INCL_PART0 |
195 DISK_PITER_INCL_EMPTY_PART0))
196 end = -1;
197 else
198 end = 0;
199 } else {
200 inc = 1;
201 end = ptbl->len;
202 }
203
204
205 for (; piter->idx != end; piter->idx += inc) {
206 struct hd_struct *part;
207
208 part = rcu_dereference(ptbl->part[piter->idx]);
209 if (!part)
210 continue;
211 if (!part_nr_sects_read(part) &&
212 !(piter->flags & DISK_PITER_INCL_EMPTY) &&
213 !(piter->flags & DISK_PITER_INCL_EMPTY_PART0 &&
214 piter->idx == 0))
215 continue;
216
217 get_device(part_to_dev(part));
218 piter->part = part;
219 piter->idx += inc;
220 break;
221 }
222
223 rcu_read_unlock();
224
225 return piter->part;
226}
227EXPORT_SYMBOL_GPL(disk_part_iter_next);
228
229
230
231
232
233
234
235
236
237
238void disk_part_iter_exit(struct disk_part_iter *piter)
239{
240 disk_put_part(piter->part);
241 piter->part = NULL;
242}
243EXPORT_SYMBOL_GPL(disk_part_iter_exit);
244
245static inline int sector_in_part(struct hd_struct *part, sector_t sector)
246{
247 return part->start_sect <= sector &&
248 sector < part->start_sect + part_nr_sects_read(part);
249}
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector)
267{
268 struct disk_part_tbl *ptbl;
269 struct hd_struct *part;
270 int i;
271
272 ptbl = rcu_dereference(disk->part_tbl);
273
274 part = rcu_dereference(ptbl->last_lookup);
275 if (part && sector_in_part(part, sector))
276 return part;
277
278 for (i = 1; i < ptbl->len; i++) {
279 part = rcu_dereference(ptbl->part[i]);
280
281 if (part && sector_in_part(part, sector)) {
282 rcu_assign_pointer(ptbl->last_lookup, part);
283 return part;
284 }
285 }
286 return &disk->part0;
287}
288EXPORT_SYMBOL_GPL(disk_map_sector_rcu);
289
290
291
292
293
294#define BLKDEV_MAJOR_HASH_SIZE 255
295static struct blk_major_name {
296 struct blk_major_name *next;
297 int major;
298 char name[16];
299} *major_names[BLKDEV_MAJOR_HASH_SIZE];
300
301
302static inline int major_to_index(unsigned major)
303{
304 return major % BLKDEV_MAJOR_HASH_SIZE;
305}
306
307#ifdef CONFIG_PROC_FS
308void blkdev_show(struct seq_file *seqf, off_t offset)
309{
310 struct blk_major_name *dp;
311
312 mutex_lock(&block_class_lock);
313 for (dp = major_names[major_to_index(offset)]; dp; dp = dp->next)
314 if (dp->major == offset)
315 seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
316 mutex_unlock(&block_class_lock);
317}
318#endif
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340int register_blkdev(unsigned int major, const char *name)
341{
342 struct blk_major_name **n, *p;
343 int index, ret = 0;
344
345 mutex_lock(&block_class_lock);
346
347
348 if (major == 0) {
349 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
350 if (major_names[index] == NULL)
351 break;
352 }
353
354 if (index == 0) {
355 printk("register_blkdev: failed to get major for %s\n",
356 name);
357 ret = -EBUSY;
358 goto out;
359 }
360 major = index;
361 ret = major;
362 }
363
364 if (major >= BLKDEV_MAJOR_MAX) {
365 pr_err("register_blkdev: major requested (%u) is greater than the maximum (%u) for %s\n",
366 major, BLKDEV_MAJOR_MAX-1, name);
367
368 ret = -EINVAL;
369 goto out;
370 }
371
372 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
373 if (p == NULL) {
374 ret = -ENOMEM;
375 goto out;
376 }
377
378 p->major = major;
379 strlcpy(p->name, name, sizeof(p->name));
380 p->next = NULL;
381 index = major_to_index(major);
382
383 for (n = &major_names[index]; *n; n = &(*n)->next) {
384 if ((*n)->major == major)
385 break;
386 }
387 if (!*n)
388 *n = p;
389 else
390 ret = -EBUSY;
391
392 if (ret < 0) {
393 printk("register_blkdev: cannot get major %u for %s\n",
394 major, name);
395 kfree(p);
396 }
397out:
398 mutex_unlock(&block_class_lock);
399 return ret;
400}
401
402EXPORT_SYMBOL(register_blkdev);
403
404void unregister_blkdev(unsigned int major, const char *name)
405{
406 struct blk_major_name **n;
407 struct blk_major_name *p = NULL;
408 int index = major_to_index(major);
409
410 mutex_lock(&block_class_lock);
411 for (n = &major_names[index]; *n; n = &(*n)->next)
412 if ((*n)->major == major)
413 break;
414 if (!*n || strcmp((*n)->name, name)) {
415 WARN_ON(1);
416 } else {
417 p = *n;
418 *n = p->next;
419 }
420 mutex_unlock(&block_class_lock);
421 kfree(p);
422}
423
424EXPORT_SYMBOL(unregister_blkdev);
425
426static struct kobj_map *bdev_map;
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441static int blk_mangle_minor(int minor)
442{
443#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
444 int i;
445
446 for (i = 0; i < MINORBITS / 2; i++) {
447 int low = minor & (1 << i);
448 int high = minor & (1 << (MINORBITS - 1 - i));
449 int distance = MINORBITS - 1 - 2 * i;
450
451 minor ^= low | high;
452 low <<= distance;
453 high >>= distance;
454 minor |= low | high;
455 }
456#endif
457 return minor;
458}
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474int blk_alloc_devt(struct hd_struct *part, dev_t *devt)
475{
476 struct gendisk *disk = part_to_disk(part);
477 int idx;
478
479
480 if (part->partno < disk->minors) {
481 *devt = MKDEV(disk->major, disk->first_minor + part->partno);
482 return 0;
483 }
484
485
486 idr_preload(GFP_KERNEL);
487
488 spin_lock_bh(&ext_devt_lock);
489 idx = idr_alloc(&ext_devt_idr, part, 0, NR_EXT_DEVT, GFP_NOWAIT);
490 spin_unlock_bh(&ext_devt_lock);
491
492 idr_preload_end();
493 if (idx < 0)
494 return idx == -ENOSPC ? -EBUSY : idx;
495
496 *devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
497 return 0;
498}
499
500
501
502
503
504
505
506
507
508
509void blk_free_devt(dev_t devt)
510{
511 if (devt == MKDEV(0, 0))
512 return;
513
514 if (MAJOR(devt) == BLOCK_EXT_MAJOR) {
515 spin_lock_bh(&ext_devt_lock);
516 idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
517 spin_unlock_bh(&ext_devt_lock);
518 }
519}
520
521static char *bdevt_str(dev_t devt, char *buf)
522{
523 if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) {
524 char tbuf[BDEVT_SIZE];
525 snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt));
526 snprintf(buf, BDEVT_SIZE, "%-9s", tbuf);
527 } else
528 snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt));
529
530 return buf;
531}
532
533
534
535
536
537
538void blk_register_region(dev_t devt, unsigned long range, struct module *module,
539 struct kobject *(*probe)(dev_t, int *, void *),
540 int (*lock)(dev_t, void *), void *data)
541{
542 kobj_map(bdev_map, devt, range, module, probe, lock, data);
543}
544
545EXPORT_SYMBOL(blk_register_region);
546
547void blk_unregister_region(dev_t devt, unsigned long range)
548{
549 kobj_unmap(bdev_map, devt, range);
550}
551
552EXPORT_SYMBOL(blk_unregister_region);
553
554static struct kobject *exact_match(dev_t devt, int *partno, void *data)
555{
556 struct gendisk *p = data;
557
558 return &disk_to_dev(p)->kobj;
559}
560
561static int exact_lock(dev_t devt, void *data)
562{
563 struct gendisk *p = data;
564
565 if (!get_disk_and_module(p))
566 return -1;
567 return 0;
568}
569
570static void register_disk(struct device *parent, struct gendisk *disk)
571{
572 struct device *ddev = disk_to_dev(disk);
573 struct block_device *bdev;
574 struct disk_part_iter piter;
575 struct hd_struct *part;
576 int err;
577
578 ddev->parent = parent;
579
580 dev_set_name(ddev, "%s", disk->disk_name);
581
582
583 dev_set_uevent_suppress(ddev, 1);
584
585 if (device_add(ddev))
586 return;
587 if (!sysfs_deprecated) {
588 err = sysfs_create_link(block_depr, &ddev->kobj,
589 kobject_name(&ddev->kobj));
590 if (err) {
591 device_del(ddev);
592 return;
593 }
594 }
595
596
597
598
599
600
601 pm_runtime_set_memalloc_noio(ddev, true);
602
603 disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
604 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
605
606 if (disk->flags & GENHD_FL_HIDDEN) {
607 dev_set_uevent_suppress(ddev, 0);
608 return;
609 }
610
611
612 if (!disk_part_scan_enabled(disk))
613 goto exit;
614
615
616 if (!get_capacity(disk))
617 goto exit;
618
619 bdev = bdget_disk(disk, 0);
620 if (!bdev)
621 goto exit;
622
623 bdev->bd_invalidated = 1;
624 err = blkdev_get(bdev, FMODE_READ, NULL);
625 if (err < 0)
626 goto exit;
627 blkdev_put(bdev, FMODE_READ);
628
629exit:
630
631 dev_set_uevent_suppress(ddev, 0);
632 kobject_uevent(&ddev->kobj, KOBJ_ADD);
633
634
635 disk_part_iter_init(&piter, disk, 0);
636 while ((part = disk_part_iter_next(&piter)))
637 kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD);
638 disk_part_iter_exit(&piter);
639
640 err = sysfs_create_link(&ddev->kobj,
641 &disk->queue->backing_dev_info->dev->kobj,
642 "bdi");
643 WARN_ON(err);
644}
645
646
647
648
649
650
651
652
653
654
655
656
657static void __device_add_disk(struct device *parent, struct gendisk *disk,
658 bool register_queue)
659{
660 dev_t devt;
661 int retval;
662
663
664
665
666
667 WARN_ON(disk->minors && !(disk->major || disk->first_minor));
668 WARN_ON(!disk->minors &&
669 !(disk->flags & (GENHD_FL_EXT_DEVT | GENHD_FL_HIDDEN)));
670
671 disk->flags |= GENHD_FL_UP;
672
673 retval = blk_alloc_devt(&disk->part0, &devt);
674 if (retval) {
675 WARN_ON(1);
676 return;
677 }
678 disk->major = MAJOR(devt);
679 disk->first_minor = MINOR(devt);
680
681 disk_alloc_events(disk);
682
683 if (disk->flags & GENHD_FL_HIDDEN) {
684
685
686
687
688 disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
689 disk->flags |= GENHD_FL_NO_PART_SCAN;
690 } else {
691 int ret;
692
693
694 disk_to_dev(disk)->devt = devt;
695 ret = bdi_register_owner(disk->queue->backing_dev_info,
696 disk_to_dev(disk));
697 WARN_ON(ret);
698 blk_register_region(disk_devt(disk), disk->minors, NULL,
699 exact_match, exact_lock, disk);
700 }
701 register_disk(parent, disk);
702 if (register_queue)
703 blk_register_queue(disk);
704
705
706
707
708
709 WARN_ON_ONCE(!blk_get_queue(disk->queue));
710
711 disk_add_events(disk);
712 blk_integrity_add(disk);
713}
714
715void device_add_disk(struct device *parent, struct gendisk *disk)
716{
717 __device_add_disk(parent, disk, true);
718}
719EXPORT_SYMBOL(device_add_disk);
720
721void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk)
722{
723 __device_add_disk(parent, disk, false);
724}
725EXPORT_SYMBOL(device_add_disk_no_queue_reg);
726
727void del_gendisk(struct gendisk *disk)
728{
729 struct disk_part_iter piter;
730 struct hd_struct *part;
731
732 blk_integrity_del(disk);
733 disk_del_events(disk);
734
735
736
737
738
739 down_write(&disk->lookup_sem);
740
741 disk_part_iter_init(&piter, disk,
742 DISK_PITER_INCL_EMPTY | DISK_PITER_REVERSE);
743 while ((part = disk_part_iter_next(&piter))) {
744 invalidate_partition(disk, part->partno);
745 bdev_unhash_inode(part_devt(part));
746 delete_partition(disk, part->partno);
747 }
748 disk_part_iter_exit(&piter);
749
750 invalidate_partition(disk, 0);
751 bdev_unhash_inode(disk_devt(disk));
752 set_capacity(disk, 0);
753 disk->flags &= ~GENHD_FL_UP;
754 up_write(&disk->lookup_sem);
755
756 if (!(disk->flags & GENHD_FL_HIDDEN))
757 sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
758 if (disk->queue) {
759
760
761
762
763 if (!(disk->flags & GENHD_FL_HIDDEN))
764 bdi_unregister(disk->queue->backing_dev_info);
765 blk_unregister_queue(disk);
766 } else {
767 WARN_ON(1);
768 }
769
770 if (!(disk->flags & GENHD_FL_HIDDEN))
771 blk_unregister_region(disk_devt(disk), disk->minors);
772
773 kobject_put(disk->part0.holder_dir);
774 kobject_put(disk->slave_dir);
775
776 part_stat_set_all(&disk->part0, 0);
777 disk->part0.stamp = 0;
778 if (!sysfs_deprecated)
779 sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
780 pm_runtime_set_memalloc_noio(disk_to_dev(disk), false);
781 device_del(disk_to_dev(disk));
782}
783EXPORT_SYMBOL(del_gendisk);
784
785
786static ssize_t disk_badblocks_show(struct device *dev,
787 struct device_attribute *attr,
788 char *page)
789{
790 struct gendisk *disk = dev_to_disk(dev);
791
792 if (!disk->bb)
793 return sprintf(page, "\n");
794
795 return badblocks_show(disk->bb, page, 0);
796}
797
798static ssize_t disk_badblocks_store(struct device *dev,
799 struct device_attribute *attr,
800 const char *page, size_t len)
801{
802 struct gendisk *disk = dev_to_disk(dev);
803
804 if (!disk->bb)
805 return -ENXIO;
806
807 return badblocks_store(disk->bb, page, len, 0);
808}
809
810
811
812
813
814
815
816
817
818struct gendisk *get_gendisk(dev_t devt, int *partno)
819{
820 struct gendisk *disk = NULL;
821
822 if (MAJOR(devt) != BLOCK_EXT_MAJOR) {
823 struct kobject *kobj;
824
825 kobj = kobj_lookup(bdev_map, devt, partno);
826 if (kobj)
827 disk = dev_to_disk(kobj_to_dev(kobj));
828 } else {
829 struct hd_struct *part;
830
831 spin_lock_bh(&ext_devt_lock);
832 part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
833 if (part && get_disk_and_module(part_to_disk(part))) {
834 *partno = part->partno;
835 disk = part_to_disk(part);
836 }
837 spin_unlock_bh(&ext_devt_lock);
838 }
839
840 if (!disk)
841 return NULL;
842
843
844
845
846
847 down_read(&disk->lookup_sem);
848 if (unlikely((disk->flags & GENHD_FL_HIDDEN) ||
849 !(disk->flags & GENHD_FL_UP))) {
850 up_read(&disk->lookup_sem);
851 put_disk_and_module(disk);
852 disk = NULL;
853 } else {
854 up_read(&disk->lookup_sem);
855 }
856 return disk;
857}
858EXPORT_SYMBOL(get_gendisk);
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873struct block_device *bdget_disk(struct gendisk *disk, int partno)
874{
875 struct hd_struct *part;
876 struct block_device *bdev = NULL;
877
878 part = disk_get_part(disk, partno);
879 if (part)
880 bdev = bdget(part_devt(part));
881 disk_put_part(part);
882
883 return bdev;
884}
885EXPORT_SYMBOL(bdget_disk);
886
887
888
889
890
891
892void __init printk_all_partitions(void)
893{
894 struct class_dev_iter iter;
895 struct device *dev;
896
897 class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
898 while ((dev = class_dev_iter_next(&iter))) {
899 struct gendisk *disk = dev_to_disk(dev);
900 struct disk_part_iter piter;
901 struct hd_struct *part;
902 char name_buf[BDEVNAME_SIZE];
903 char devt_buf[BDEVT_SIZE];
904
905
906
907
908
909 if (get_capacity(disk) == 0 ||
910 (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
911 continue;
912
913
914
915
916
917
918 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
919 while ((part = disk_part_iter_next(&piter))) {
920 bool is_part0 = part == &disk->part0;
921
922 printk("%s%s %10llu %s %s", is_part0 ? "" : " ",
923 bdevt_str(part_devt(part), devt_buf),
924 (unsigned long long)part_nr_sects_read(part) >> 1
925 , disk_name(disk, part->partno, name_buf),
926 part->info ? part->info->uuid : "");
927 if (is_part0) {
928 if (dev->parent && dev->parent->driver)
929 printk(" driver: %s\n",
930 dev->parent->driver->name);
931 else
932 printk(" (driver?)\n");
933 } else
934 printk("\n");
935 }
936 disk_part_iter_exit(&piter);
937 }
938 class_dev_iter_exit(&iter);
939}
940
941#ifdef CONFIG_PROC_FS
942
943static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
944{
945 loff_t skip = *pos;
946 struct class_dev_iter *iter;
947 struct device *dev;
948
949 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
950 if (!iter)
951 return ERR_PTR(-ENOMEM);
952
953 seqf->private = iter;
954 class_dev_iter_init(iter, &block_class, NULL, &disk_type);
955 do {
956 dev = class_dev_iter_next(iter);
957 if (!dev)
958 return NULL;
959 } while (skip--);
960
961 return dev_to_disk(dev);
962}
963
964static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
965{
966 struct device *dev;
967
968 (*pos)++;
969 dev = class_dev_iter_next(seqf->private);
970 if (dev)
971 return dev_to_disk(dev);
972
973 return NULL;
974}
975
976static void disk_seqf_stop(struct seq_file *seqf, void *v)
977{
978 struct class_dev_iter *iter = seqf->private;
979
980
981 if (iter) {
982 class_dev_iter_exit(iter);
983 kfree(iter);
984 seqf->private = NULL;
985 }
986}
987
988static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
989{
990 void *p;
991
992 p = disk_seqf_start(seqf, pos);
993 if (!IS_ERR_OR_NULL(p) && !*pos)
994 seq_puts(seqf, "major minor #blocks name\n\n");
995 return p;
996}
997
998static int show_partition(struct seq_file *seqf, void *v)
999{
1000 struct gendisk *sgp = v;
1001 struct disk_part_iter piter;
1002 struct hd_struct *part;
1003 char buf[BDEVNAME_SIZE];
1004
1005
1006 if (!get_capacity(sgp) || (!disk_max_parts(sgp) &&
1007 (sgp->flags & GENHD_FL_REMOVABLE)))
1008 return 0;
1009 if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
1010 return 0;
1011
1012
1013 disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0);
1014 while ((part = disk_part_iter_next(&piter)))
1015 seq_printf(seqf, "%4d %7d %10llu %s\n",
1016 MAJOR(part_devt(part)), MINOR(part_devt(part)),
1017 (unsigned long long)part_nr_sects_read(part) >> 1,
1018 disk_name(sgp, part->partno, buf));
1019 disk_part_iter_exit(&piter);
1020
1021 return 0;
1022}
1023
1024static const struct seq_operations partitions_op = {
1025 .start = show_partition_start,
1026 .next = disk_seqf_next,
1027 .stop = disk_seqf_stop,
1028 .show = show_partition
1029};
1030#endif
1031
1032
1033static struct kobject *base_probe(dev_t devt, int *partno, void *data)
1034{
1035 if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
1036
1037 request_module("block-major-%d", MAJOR(devt));
1038 return NULL;
1039}
1040
1041static int __init genhd_device_init(void)
1042{
1043 int error;
1044
1045 block_class.dev_kobj = sysfs_dev_block_kobj;
1046 error = class_register(&block_class);
1047 if (unlikely(error))
1048 return error;
1049 bdev_map = kobj_map_init(base_probe, &block_class_lock);
1050 blk_dev_init();
1051
1052 register_blkdev(BLOCK_EXT_MAJOR, "blkext");
1053
1054
1055 if (!sysfs_deprecated)
1056 block_depr = kobject_create_and_add("block", NULL);
1057 return 0;
1058}
1059
1060subsys_initcall(genhd_device_init);
1061
1062static ssize_t disk_range_show(struct device *dev,
1063 struct device_attribute *attr, char *buf)
1064{
1065 struct gendisk *disk = dev_to_disk(dev);
1066
1067 return sprintf(buf, "%d\n", disk->minors);
1068}
1069
1070static ssize_t disk_ext_range_show(struct device *dev,
1071 struct device_attribute *attr, char *buf)
1072{
1073 struct gendisk *disk = dev_to_disk(dev);
1074
1075 return sprintf(buf, "%d\n", disk_max_parts(disk));
1076}
1077
1078static ssize_t disk_removable_show(struct device *dev,
1079 struct device_attribute *attr, char *buf)
1080{
1081 struct gendisk *disk = dev_to_disk(dev);
1082
1083 return sprintf(buf, "%d\n",
1084 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
1085}
1086
1087static ssize_t disk_hidden_show(struct device *dev,
1088 struct device_attribute *attr, char *buf)
1089{
1090 struct gendisk *disk = dev_to_disk(dev);
1091
1092 return sprintf(buf, "%d\n",
1093 (disk->flags & GENHD_FL_HIDDEN ? 1 : 0));
1094}
1095
1096static ssize_t disk_ro_show(struct device *dev,
1097 struct device_attribute *attr, char *buf)
1098{
1099 struct gendisk *disk = dev_to_disk(dev);
1100
1101 return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
1102}
1103
1104static ssize_t disk_capability_show(struct device *dev,
1105 struct device_attribute *attr, char *buf)
1106{
1107 struct gendisk *disk = dev_to_disk(dev);
1108
1109 return sprintf(buf, "%x\n", disk->flags);
1110}
1111
1112static ssize_t disk_alignment_offset_show(struct device *dev,
1113 struct device_attribute *attr,
1114 char *buf)
1115{
1116 struct gendisk *disk = dev_to_disk(dev);
1117
1118 return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
1119}
1120
1121static ssize_t disk_discard_alignment_show(struct device *dev,
1122 struct device_attribute *attr,
1123 char *buf)
1124{
1125 struct gendisk *disk = dev_to_disk(dev);
1126
1127 return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
1128}
1129
1130static DEVICE_ATTR(range, 0444, disk_range_show, NULL);
1131static DEVICE_ATTR(ext_range, 0444, disk_ext_range_show, NULL);
1132static DEVICE_ATTR(removable, 0444, disk_removable_show, NULL);
1133static DEVICE_ATTR(hidden, 0444, disk_hidden_show, NULL);
1134static DEVICE_ATTR(ro, 0444, disk_ro_show, NULL);
1135static DEVICE_ATTR(size, 0444, part_size_show, NULL);
1136static DEVICE_ATTR(alignment_offset, 0444, disk_alignment_offset_show, NULL);
1137static DEVICE_ATTR(discard_alignment, 0444, disk_discard_alignment_show, NULL);
1138static DEVICE_ATTR(capability, 0444, disk_capability_show, NULL);
1139static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
1140static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
1141static DEVICE_ATTR(badblocks, 0644, disk_badblocks_show, disk_badblocks_store);
1142#ifdef CONFIG_FAIL_MAKE_REQUEST
1143static struct device_attribute dev_attr_fail =
1144 __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
1145#endif
1146#ifdef CONFIG_FAIL_IO_TIMEOUT
1147static struct device_attribute dev_attr_fail_timeout =
1148 __ATTR(io-timeout-fail, 0644, part_timeout_show, part_timeout_store);
1149#endif
1150
1151static struct attribute *disk_attrs[] = {
1152 &dev_attr_range.attr,
1153 &dev_attr_ext_range.attr,
1154 &dev_attr_removable.attr,
1155 &dev_attr_hidden.attr,
1156 &dev_attr_ro.attr,
1157 &dev_attr_size.attr,
1158 &dev_attr_alignment_offset.attr,
1159 &dev_attr_discard_alignment.attr,
1160 &dev_attr_capability.attr,
1161 &dev_attr_stat.attr,
1162 &dev_attr_inflight.attr,
1163 &dev_attr_badblocks.attr,
1164#ifdef CONFIG_FAIL_MAKE_REQUEST
1165 &dev_attr_fail.attr,
1166#endif
1167#ifdef CONFIG_FAIL_IO_TIMEOUT
1168 &dev_attr_fail_timeout.attr,
1169#endif
1170 NULL
1171};
1172
1173static umode_t disk_visible(struct kobject *kobj, struct attribute *a, int n)
1174{
1175 struct device *dev = container_of(kobj, typeof(*dev), kobj);
1176 struct gendisk *disk = dev_to_disk(dev);
1177
1178 if (a == &dev_attr_badblocks.attr && !disk->bb)
1179 return 0;
1180 return a->mode;
1181}
1182
1183static struct attribute_group disk_attr_group = {
1184 .attrs = disk_attrs,
1185 .is_visible = disk_visible,
1186};
1187
1188static const struct attribute_group *disk_attr_groups[] = {
1189 &disk_attr_group,
1190 NULL
1191};
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204static void disk_replace_part_tbl(struct gendisk *disk,
1205 struct disk_part_tbl *new_ptbl)
1206{
1207 struct disk_part_tbl *old_ptbl =
1208 rcu_dereference_protected(disk->part_tbl, 1);
1209
1210 rcu_assign_pointer(disk->part_tbl, new_ptbl);
1211
1212 if (old_ptbl) {
1213 rcu_assign_pointer(old_ptbl->last_lookup, NULL);
1214 kfree_rcu(old_ptbl, rcu_head);
1215 }
1216}
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233int disk_expand_part_tbl(struct gendisk *disk, int partno)
1234{
1235 struct disk_part_tbl *old_ptbl =
1236 rcu_dereference_protected(disk->part_tbl, 1);
1237 struct disk_part_tbl *new_ptbl;
1238 int len = old_ptbl ? old_ptbl->len : 0;
1239 int i, target;
1240 size_t size;
1241
1242
1243
1244
1245
1246 target = partno + 1;
1247 if (target < 0)
1248 return -EINVAL;
1249
1250
1251 if (disk_max_parts(disk) && target > disk_max_parts(disk))
1252 return -EINVAL;
1253
1254 if (target <= len)
1255 return 0;
1256
1257 size = sizeof(*new_ptbl) + target * sizeof(new_ptbl->part[0]);
1258 new_ptbl = kzalloc_node(size, GFP_KERNEL, disk->node_id);
1259 if (!new_ptbl)
1260 return -ENOMEM;
1261
1262 new_ptbl->len = target;
1263
1264 for (i = 0; i < len; i++)
1265 rcu_assign_pointer(new_ptbl->part[i], old_ptbl->part[i]);
1266
1267 disk_replace_part_tbl(disk, new_ptbl);
1268 return 0;
1269}
1270
1271static void disk_release(struct device *dev)
1272{
1273 struct gendisk *disk = dev_to_disk(dev);
1274
1275 blk_free_devt(dev->devt);
1276 disk_release_events(disk);
1277 kfree(disk->random);
1278 disk_replace_part_tbl(disk, NULL);
1279 hd_free_part(&disk->part0);
1280 if (disk->queue)
1281 blk_put_queue(disk->queue);
1282 kfree(disk);
1283}
1284struct class block_class = {
1285 .name = "block",
1286};
1287
1288static char *block_devnode(struct device *dev, umode_t *mode,
1289 kuid_t *uid, kgid_t *gid)
1290{
1291 struct gendisk *disk = dev_to_disk(dev);
1292
1293 if (disk->devnode)
1294 return disk->devnode(disk, mode);
1295 return NULL;
1296}
1297
1298static const struct device_type disk_type = {
1299 .name = "disk",
1300 .groups = disk_attr_groups,
1301 .release = disk_release,
1302 .devnode = block_devnode,
1303};
1304
1305#ifdef CONFIG_PROC_FS
1306
1307
1308
1309
1310
1311
1312
1313static int diskstats_show(struct seq_file *seqf, void *v)
1314{
1315 struct gendisk *gp = v;
1316 struct disk_part_iter piter;
1317 struct hd_struct *hd;
1318 char buf[BDEVNAME_SIZE];
1319 unsigned int inflight[2];
1320 int cpu;
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330 disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0);
1331 while ((hd = disk_part_iter_next(&piter))) {
1332 cpu = part_stat_lock();
1333 part_round_stats(gp->queue, cpu, hd);
1334 part_stat_unlock();
1335 part_in_flight(gp->queue, hd, inflight);
1336 seq_printf(seqf, "%4d %7d %s "
1337 "%lu %lu %lu %u "
1338 "%lu %lu %lu %u "
1339 "%u %u %u "
1340 "%lu %lu %lu %u\n",
1341 MAJOR(part_devt(hd)), MINOR(part_devt(hd)),
1342 disk_name(gp, hd->partno, buf),
1343 part_stat_read(hd, ios[STAT_READ]),
1344 part_stat_read(hd, merges[STAT_READ]),
1345 part_stat_read(hd, sectors[STAT_READ]),
1346 (unsigned int)part_stat_read_msecs(hd, STAT_READ),
1347 part_stat_read(hd, ios[STAT_WRITE]),
1348 part_stat_read(hd, merges[STAT_WRITE]),
1349 part_stat_read(hd, sectors[STAT_WRITE]),
1350 (unsigned int)part_stat_read_msecs(hd, STAT_WRITE),
1351 inflight[0],
1352 jiffies_to_msecs(part_stat_read(hd, io_ticks)),
1353 jiffies_to_msecs(part_stat_read(hd, time_in_queue)),
1354 part_stat_read(hd, ios[STAT_DISCARD]),
1355 part_stat_read(hd, merges[STAT_DISCARD]),
1356 part_stat_read(hd, sectors[STAT_DISCARD]),
1357 (unsigned int)part_stat_read_msecs(hd, STAT_DISCARD)
1358 );
1359 }
1360 disk_part_iter_exit(&piter);
1361
1362 return 0;
1363}
1364
1365static const struct seq_operations diskstats_op = {
1366 .start = disk_seqf_start,
1367 .next = disk_seqf_next,
1368 .stop = disk_seqf_stop,
1369 .show = diskstats_show
1370};
1371
1372static int __init proc_genhd_init(void)
1373{
1374 proc_create_seq("diskstats", 0, NULL, &diskstats_op);
1375 proc_create_seq("partitions", 0, NULL, &partitions_op);
1376 return 0;
1377}
1378module_init(proc_genhd_init);
1379#endif
1380
1381dev_t blk_lookup_devt(const char *name, int partno)
1382{
1383 dev_t devt = MKDEV(0, 0);
1384 struct class_dev_iter iter;
1385 struct device *dev;
1386
1387 class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
1388 while ((dev = class_dev_iter_next(&iter))) {
1389 struct gendisk *disk = dev_to_disk(dev);
1390 struct hd_struct *part;
1391
1392 if (strcmp(dev_name(dev), name))
1393 continue;
1394
1395 if (partno < disk->minors) {
1396
1397
1398
1399 devt = MKDEV(MAJOR(dev->devt),
1400 MINOR(dev->devt) + partno);
1401 break;
1402 }
1403 part = disk_get_part(disk, partno);
1404 if (part) {
1405 devt = part_devt(part);
1406 disk_put_part(part);
1407 break;
1408 }
1409 disk_put_part(part);
1410 }
1411 class_dev_iter_exit(&iter);
1412 return devt;
1413}
1414EXPORT_SYMBOL(blk_lookup_devt);
1415
1416struct gendisk *__alloc_disk_node(int minors, int node_id)
1417{
1418 struct gendisk *disk;
1419 struct disk_part_tbl *ptbl;
1420
1421 if (minors > DISK_MAX_PARTS) {
1422 printk(KERN_ERR
1423 "block: can't allocate more than %d partitions\n",
1424 DISK_MAX_PARTS);
1425 minors = DISK_MAX_PARTS;
1426 }
1427
1428 disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);
1429 if (disk) {
1430 if (!init_part_stats(&disk->part0)) {
1431 kfree(disk);
1432 return NULL;
1433 }
1434 init_rwsem(&disk->lookup_sem);
1435 disk->node_id = node_id;
1436 if (disk_expand_part_tbl(disk, 0)) {
1437 free_part_stats(&disk->part0);
1438 kfree(disk);
1439 return NULL;
1440 }
1441 ptbl = rcu_dereference_protected(disk->part_tbl, 1);
1442 rcu_assign_pointer(ptbl->part[0], &disk->part0);
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453 seqcount_init(&disk->part0.nr_sects_seq);
1454 if (hd_ref_init(&disk->part0)) {
1455 hd_free_part(&disk->part0);
1456 kfree(disk);
1457 return NULL;
1458 }
1459
1460 disk->minors = minors;
1461 rand_initialize_disk(disk);
1462 disk_to_dev(disk)->class = &block_class;
1463 disk_to_dev(disk)->type = &disk_type;
1464 device_initialize(disk_to_dev(disk));
1465 }
1466 return disk;
1467}
1468EXPORT_SYMBOL(__alloc_disk_node);
1469
1470struct kobject *get_disk_and_module(struct gendisk *disk)
1471{
1472 struct module *owner;
1473 struct kobject *kobj;
1474
1475 if (!disk->fops)
1476 return NULL;
1477 owner = disk->fops->owner;
1478 if (owner && !try_module_get(owner))
1479 return NULL;
1480 kobj = kobject_get_unless_zero(&disk_to_dev(disk)->kobj);
1481 if (kobj == NULL) {
1482 module_put(owner);
1483 return NULL;
1484 }
1485 return kobj;
1486
1487}
1488EXPORT_SYMBOL(get_disk_and_module);
1489
1490void put_disk(struct gendisk *disk)
1491{
1492 if (disk)
1493 kobject_put(&disk_to_dev(disk)->kobj);
1494}
1495EXPORT_SYMBOL(put_disk);
1496
1497
1498
1499
1500
1501void put_disk_and_module(struct gendisk *disk)
1502{
1503 if (disk) {
1504 struct module *owner = disk->fops->owner;
1505
1506 put_disk(disk);
1507 module_put(owner);
1508 }
1509}
1510EXPORT_SYMBOL(put_disk_and_module);
1511
1512static void set_disk_ro_uevent(struct gendisk *gd, int ro)
1513{
1514 char event[] = "DISK_RO=1";
1515 char *envp[] = { event, NULL };
1516
1517 if (!ro)
1518 event[8] = '0';
1519 kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
1520}
1521
1522void set_device_ro(struct block_device *bdev, int flag)
1523{
1524 bdev->bd_part->policy = flag;
1525}
1526
1527EXPORT_SYMBOL(set_device_ro);
1528
1529void set_disk_ro(struct gendisk *disk, int flag)
1530{
1531 struct disk_part_iter piter;
1532 struct hd_struct *part;
1533
1534 if (disk->part0.policy != flag) {
1535 set_disk_ro_uevent(disk, flag);
1536 disk->part0.policy = flag;
1537 }
1538
1539 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
1540 while ((part = disk_part_iter_next(&piter)))
1541 part->policy = flag;
1542 disk_part_iter_exit(&piter);
1543}
1544
1545EXPORT_SYMBOL(set_disk_ro);
1546
1547int bdev_read_only(struct block_device *bdev)
1548{
1549 if (!bdev)
1550 return 0;
1551 return bdev->bd_part->policy;
1552}
1553
1554EXPORT_SYMBOL(bdev_read_only);
1555
1556int invalidate_partition(struct gendisk *disk, int partno)
1557{
1558 int res = 0;
1559 struct block_device *bdev = bdget_disk(disk, partno);
1560 if (bdev) {
1561 fsync_bdev(bdev);
1562 res = __invalidate_device(bdev, true);
1563 bdput(bdev);
1564 }
1565 return res;
1566}
1567
1568EXPORT_SYMBOL(invalidate_partition);
1569
1570
1571
1572
1573struct disk_events {
1574 struct list_head node;
1575 struct gendisk *disk;
1576 spinlock_t lock;
1577
1578 struct mutex block_mutex;
1579 int block;
1580 unsigned int pending;
1581 unsigned int clearing;
1582
1583 long poll_msecs;
1584 struct delayed_work dwork;
1585};
1586
1587static const char *disk_events_strs[] = {
1588 [ilog2(DISK_EVENT_MEDIA_CHANGE)] = "media_change",
1589 [ilog2(DISK_EVENT_EJECT_REQUEST)] = "eject_request",
1590};
1591
1592static char *disk_uevents[] = {
1593 [ilog2(DISK_EVENT_MEDIA_CHANGE)] = "DISK_MEDIA_CHANGE=1",
1594 [ilog2(DISK_EVENT_EJECT_REQUEST)] = "DISK_EJECT_REQUEST=1",
1595};
1596
1597
1598static DEFINE_MUTEX(disk_events_mutex);
1599static LIST_HEAD(disk_events);
1600
1601
1602static unsigned long disk_events_dfl_poll_msecs;
1603
1604static unsigned long disk_events_poll_jiffies(struct gendisk *disk)
1605{
1606 struct disk_events *ev = disk->ev;
1607 long intv_msecs = 0;
1608
1609
1610
1611
1612
1613
1614 if (ev->poll_msecs >= 0)
1615 intv_msecs = ev->poll_msecs;
1616 else if (disk->events & ~disk->async_events)
1617 intv_msecs = disk_events_dfl_poll_msecs;
1618
1619 return msecs_to_jiffies(intv_msecs);
1620}
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637void disk_block_events(struct gendisk *disk)
1638{
1639 struct disk_events *ev = disk->ev;
1640 unsigned long flags;
1641 bool cancel;
1642
1643 if (!ev)
1644 return;
1645
1646
1647
1648
1649
1650 mutex_lock(&ev->block_mutex);
1651
1652 spin_lock_irqsave(&ev->lock, flags);
1653 cancel = !ev->block++;
1654 spin_unlock_irqrestore(&ev->lock, flags);
1655
1656 if (cancel)
1657 cancel_delayed_work_sync(&disk->ev->dwork);
1658
1659 mutex_unlock(&ev->block_mutex);
1660}
1661
1662static void __disk_unblock_events(struct gendisk *disk, bool check_now)
1663{
1664 struct disk_events *ev = disk->ev;
1665 unsigned long intv;
1666 unsigned long flags;
1667
1668 spin_lock_irqsave(&ev->lock, flags);
1669
1670 if (WARN_ON_ONCE(ev->block <= 0))
1671 goto out_unlock;
1672
1673 if (--ev->block)
1674 goto out_unlock;
1675
1676 intv = disk_events_poll_jiffies(disk);
1677 if (check_now)
1678 queue_delayed_work(system_freezable_power_efficient_wq,
1679 &ev->dwork, 0);
1680 else if (intv)
1681 queue_delayed_work(system_freezable_power_efficient_wq,
1682 &ev->dwork, intv);
1683out_unlock:
1684 spin_unlock_irqrestore(&ev->lock, flags);
1685}
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697void disk_unblock_events(struct gendisk *disk)
1698{
1699 if (disk->ev)
1700 __disk_unblock_events(disk, false);
1701}
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715void disk_flush_events(struct gendisk *disk, unsigned int mask)
1716{
1717 struct disk_events *ev = disk->ev;
1718
1719 if (!ev)
1720 return;
1721
1722 spin_lock_irq(&ev->lock);
1723 ev->clearing |= mask;
1724 if (!ev->block)
1725 mod_delayed_work(system_freezable_power_efficient_wq,
1726 &ev->dwork, 0);
1727 spin_unlock_irq(&ev->lock);
1728}
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask)
1742{
1743 const struct block_device_operations *bdops = disk->fops;
1744 struct disk_events *ev = disk->ev;
1745 unsigned int pending;
1746 unsigned int clearing = mask;
1747
1748 if (!ev) {
1749
1750 if ((mask & DISK_EVENT_MEDIA_CHANGE) &&
1751 bdops->media_changed && bdops->media_changed(disk))
1752 return DISK_EVENT_MEDIA_CHANGE;
1753 return 0;
1754 }
1755
1756 disk_block_events(disk);
1757
1758
1759
1760
1761
1762
1763 spin_lock_irq(&ev->lock);
1764 clearing |= ev->clearing;
1765 ev->clearing = 0;
1766 spin_unlock_irq(&ev->lock);
1767
1768 disk_check_events(ev, &clearing);
1769
1770
1771
1772
1773 __disk_unblock_events(disk, ev->clearing ? true : false);
1774
1775
1776 spin_lock_irq(&ev->lock);
1777 pending = ev->pending & mask;
1778 ev->pending &= ~mask;
1779 spin_unlock_irq(&ev->lock);
1780 WARN_ON_ONCE(clearing & mask);
1781
1782 return pending;
1783}
1784
1785
1786
1787
1788
1789static void disk_events_workfn(struct work_struct *work)
1790{
1791 struct delayed_work *dwork = to_delayed_work(work);
1792 struct disk_events *ev = container_of(dwork, struct disk_events, dwork);
1793
1794 disk_check_events(ev, &ev->clearing);
1795}
1796
1797static void disk_check_events(struct disk_events *ev,
1798 unsigned int *clearing_ptr)
1799{
1800 struct gendisk *disk = ev->disk;
1801 char *envp[ARRAY_SIZE(disk_uevents) + 1] = { };
1802 unsigned int clearing = *clearing_ptr;
1803 unsigned int events;
1804 unsigned long intv;
1805 int nr_events = 0, i;
1806
1807
1808 events = disk->fops->check_events(disk, clearing);
1809
1810
1811 spin_lock_irq(&ev->lock);
1812
1813 events &= ~ev->pending;
1814 ev->pending |= events;
1815 *clearing_ptr &= ~clearing;
1816
1817 intv = disk_events_poll_jiffies(disk);
1818 if (!ev->block && intv)
1819 queue_delayed_work(system_freezable_power_efficient_wq,
1820 &ev->dwork, intv);
1821
1822 spin_unlock_irq(&ev->lock);
1823
1824
1825
1826
1827
1828
1829 for (i = 0; i < ARRAY_SIZE(disk_uevents); i++)
1830 if (events & disk->events & (1 << i))
1831 envp[nr_events++] = disk_uevents[i];
1832
1833 if (nr_events)
1834 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
1835}
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845static ssize_t __disk_events_show(unsigned int events, char *buf)
1846{
1847 const char *delim = "";
1848 ssize_t pos = 0;
1849 int i;
1850
1851 for (i = 0; i < ARRAY_SIZE(disk_events_strs); i++)
1852 if (events & (1 << i)) {
1853 pos += sprintf(buf + pos, "%s%s",
1854 delim, disk_events_strs[i]);
1855 delim = " ";
1856 }
1857 if (pos)
1858 pos += sprintf(buf + pos, "\n");
1859 return pos;
1860}
1861
1862static ssize_t disk_events_show(struct device *dev,
1863 struct device_attribute *attr, char *buf)
1864{
1865 struct gendisk *disk = dev_to_disk(dev);
1866
1867 return __disk_events_show(disk->events, buf);
1868}
1869
1870static ssize_t disk_events_async_show(struct device *dev,
1871 struct device_attribute *attr, char *buf)
1872{
1873 struct gendisk *disk = dev_to_disk(dev);
1874
1875 return __disk_events_show(disk->async_events, buf);
1876}
1877
1878static ssize_t disk_events_poll_msecs_show(struct device *dev,
1879 struct device_attribute *attr,
1880 char *buf)
1881{
1882 struct gendisk *disk = dev_to_disk(dev);
1883
1884 return sprintf(buf, "%ld\n", disk->ev->poll_msecs);
1885}
1886
1887static ssize_t disk_events_poll_msecs_store(struct device *dev,
1888 struct device_attribute *attr,
1889 const char *buf, size_t count)
1890{
1891 struct gendisk *disk = dev_to_disk(dev);
1892 long intv;
1893
1894 if (!count || !sscanf(buf, "%ld", &intv))
1895 return -EINVAL;
1896
1897 if (intv < 0 && intv != -1)
1898 return -EINVAL;
1899
1900 disk_block_events(disk);
1901 disk->ev->poll_msecs = intv;
1902 __disk_unblock_events(disk, true);
1903
1904 return count;
1905}
1906
1907static const DEVICE_ATTR(events, 0444, disk_events_show, NULL);
1908static const DEVICE_ATTR(events_async, 0444, disk_events_async_show, NULL);
1909static const DEVICE_ATTR(events_poll_msecs, 0644,
1910 disk_events_poll_msecs_show,
1911 disk_events_poll_msecs_store);
1912
1913static const struct attribute *disk_events_attrs[] = {
1914 &dev_attr_events.attr,
1915 &dev_attr_events_async.attr,
1916 &dev_attr_events_poll_msecs.attr,
1917 NULL,
1918};
1919
1920
1921
1922
1923
1924
1925
1926static int disk_events_set_dfl_poll_msecs(const char *val,
1927 const struct kernel_param *kp)
1928{
1929 struct disk_events *ev;
1930 int ret;
1931
1932 ret = param_set_ulong(val, kp);
1933 if (ret < 0)
1934 return ret;
1935
1936 mutex_lock(&disk_events_mutex);
1937
1938 list_for_each_entry(ev, &disk_events, node)
1939 disk_flush_events(ev->disk, 0);
1940
1941 mutex_unlock(&disk_events_mutex);
1942
1943 return 0;
1944}
1945
1946static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = {
1947 .set = disk_events_set_dfl_poll_msecs,
1948 .get = param_get_ulong,
1949};
1950
1951#undef MODULE_PARAM_PREFIX
1952#define MODULE_PARAM_PREFIX "block."
1953
1954module_param_cb(events_dfl_poll_msecs, &disk_events_dfl_poll_msecs_param_ops,
1955 &disk_events_dfl_poll_msecs, 0644);
1956
1957
1958
1959
1960static void disk_alloc_events(struct gendisk *disk)
1961{
1962 struct disk_events *ev;
1963
1964 if (!disk->fops->check_events)
1965 return;
1966
1967 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
1968 if (!ev) {
1969 pr_warn("%s: failed to initialize events\n", disk->disk_name);
1970 return;
1971 }
1972
1973 INIT_LIST_HEAD(&ev->node);
1974 ev->disk = disk;
1975 spin_lock_init(&ev->lock);
1976 mutex_init(&ev->block_mutex);
1977 ev->block = 1;
1978 ev->poll_msecs = -1;
1979 INIT_DELAYED_WORK(&ev->dwork, disk_events_workfn);
1980
1981 disk->ev = ev;
1982}
1983
1984static void disk_add_events(struct gendisk *disk)
1985{
1986 if (!disk->ev)
1987 return;
1988
1989
1990 if (sysfs_create_files(&disk_to_dev(disk)->kobj, disk_events_attrs) < 0)
1991 pr_warn("%s: failed to create sysfs files for events\n",
1992 disk->disk_name);
1993
1994 mutex_lock(&disk_events_mutex);
1995 list_add_tail(&disk->ev->node, &disk_events);
1996 mutex_unlock(&disk_events_mutex);
1997
1998
1999
2000
2001
2002 __disk_unblock_events(disk, true);
2003}
2004
2005static void disk_del_events(struct gendisk *disk)
2006{
2007 if (!disk->ev)
2008 return;
2009
2010 disk_block_events(disk);
2011
2012 mutex_lock(&disk_events_mutex);
2013 list_del_init(&disk->ev->node);
2014 mutex_unlock(&disk_events_mutex);
2015
2016 sysfs_remove_files(&disk_to_dev(disk)->kobj, disk_events_attrs);
2017}
2018
2019static void disk_release_events(struct gendisk *disk)
2020{
2021
2022 WARN_ON_ONCE(disk->ev && disk->ev->block != 1);
2023 kfree(disk->ev);
2024}
2025