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