1
2
3
4
5
6
7
8#include <linux/module.h>
9#include <linux/ctype.h>
10#include <linux/fs.h>
11#include <linux/genhd.h>
12#include <linux/kdev_t.h>
13#include <linux/kernel.h>
14#include <linux/blkdev.h>
15#include <linux/backing-dev.h>
16#include <linux/init.h>
17#include <linux/spinlock.h>
18#include <linux/proc_fs.h>
19#include <linux/seq_file.h>
20#include <linux/slab.h>
21#include <linux/kmod.h>
22#include <linux/mutex.h>
23#include <linux/idr.h>
24#include <linux/log2.h>
25#include <linux/pm_runtime.h>
26#include <linux/badblocks.h>
27
28#include "blk.h"
29
30static struct kobject *block_depr;
31
32
33#define NR_EXT_DEVT (1 << MINORBITS)
34static DEFINE_IDA(ext_devt_ida);
35
36void set_capacity(struct gendisk *disk, sector_t sectors)
37{
38 struct block_device *bdev = disk->part0;
39
40 spin_lock(&bdev->bd_size_lock);
41 i_size_write(bdev->bd_inode, (loff_t)sectors << SECTOR_SHIFT);
42 spin_unlock(&bdev->bd_size_lock);
43}
44EXPORT_SYMBOL(set_capacity);
45
46
47
48
49
50bool set_capacity_and_notify(struct gendisk *disk, sector_t size)
51{
52 sector_t capacity = get_capacity(disk);
53 char *envp[] = { "RESIZE=1", NULL };
54
55 set_capacity(disk, size);
56
57
58
59
60
61
62 if (size == capacity ||
63 (disk->flags & (GENHD_FL_UP | GENHD_FL_HIDDEN)) != GENHD_FL_UP)
64 return false;
65
66 pr_info("%s: detected capacity change from %lld to %lld\n",
67 disk->disk_name, capacity, size);
68
69
70
71
72
73 if (!capacity || !size)
74 return false;
75 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
76 return true;
77}
78EXPORT_SYMBOL_GPL(set_capacity_and_notify);
79
80
81
82
83
84char *disk_name(struct gendisk *hd, int partno, char *buf)
85{
86 if (!partno)
87 snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
88 else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
89 snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, partno);
90 else
91 snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, partno);
92
93 return buf;
94}
95
96const char *bdevname(struct block_device *bdev, char *buf)
97{
98 return disk_name(bdev->bd_disk, bdev->bd_partno, buf);
99}
100EXPORT_SYMBOL(bdevname);
101
102static void part_stat_read_all(struct block_device *part,
103 struct disk_stats *stat)
104{
105 int cpu;
106
107 memset(stat, 0, sizeof(struct disk_stats));
108 for_each_possible_cpu(cpu) {
109 struct disk_stats *ptr = per_cpu_ptr(part->bd_stats, cpu);
110 int group;
111
112 for (group = 0; group < NR_STAT_GROUPS; group++) {
113 stat->nsecs[group] += ptr->nsecs[group];
114 stat->sectors[group] += ptr->sectors[group];
115 stat->ios[group] += ptr->ios[group];
116 stat->merges[group] += ptr->merges[group];
117 }
118
119 stat->io_ticks += ptr->io_ticks;
120 }
121}
122
123static unsigned int part_in_flight(struct block_device *part)
124{
125 unsigned int inflight = 0;
126 int cpu;
127
128 for_each_possible_cpu(cpu) {
129 inflight += part_stat_local_read_cpu(part, in_flight[0], cpu) +
130 part_stat_local_read_cpu(part, in_flight[1], cpu);
131 }
132 if ((int)inflight < 0)
133 inflight = 0;
134
135 return inflight;
136}
137
138static void part_in_flight_rw(struct block_device *part,
139 unsigned int inflight[2])
140{
141 int cpu;
142
143 inflight[0] = 0;
144 inflight[1] = 0;
145 for_each_possible_cpu(cpu) {
146 inflight[0] += part_stat_local_read_cpu(part, in_flight[0], cpu);
147 inflight[1] += part_stat_local_read_cpu(part, in_flight[1], cpu);
148 }
149 if ((int)inflight[0] < 0)
150 inflight[0] = 0;
151 if ((int)inflight[1] < 0)
152 inflight[1] = 0;
153}
154
155
156
157
158
159#define BLKDEV_MAJOR_HASH_SIZE 255
160static struct blk_major_name {
161 struct blk_major_name *next;
162 int major;
163 char name[16];
164 void (*probe)(dev_t devt);
165} *major_names[BLKDEV_MAJOR_HASH_SIZE];
166static DEFINE_MUTEX(major_names_lock);
167
168
169static inline int major_to_index(unsigned major)
170{
171 return major % BLKDEV_MAJOR_HASH_SIZE;
172}
173
174#ifdef CONFIG_PROC_FS
175void blkdev_show(struct seq_file *seqf, off_t offset)
176{
177 struct blk_major_name *dp;
178
179 mutex_lock(&major_names_lock);
180 for (dp = major_names[major_to_index(offset)]; dp; dp = dp->next)
181 if (dp->major == offset)
182 seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
183 mutex_unlock(&major_names_lock);
184}
185#endif
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210int __register_blkdev(unsigned int major, const char *name,
211 void (*probe)(dev_t devt))
212{
213 struct blk_major_name **n, *p;
214 int index, ret = 0;
215
216 mutex_lock(&major_names_lock);
217
218
219 if (major == 0) {
220 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
221 if (major_names[index] == NULL)
222 break;
223 }
224
225 if (index == 0) {
226 printk("%s: failed to get major for %s\n",
227 __func__, name);
228 ret = -EBUSY;
229 goto out;
230 }
231 major = index;
232 ret = major;
233 }
234
235 if (major >= BLKDEV_MAJOR_MAX) {
236 pr_err("%s: major requested (%u) is greater than the maximum (%u) for %s\n",
237 __func__, major, BLKDEV_MAJOR_MAX-1, name);
238
239 ret = -EINVAL;
240 goto out;
241 }
242
243 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
244 if (p == NULL) {
245 ret = -ENOMEM;
246 goto out;
247 }
248
249 p->major = major;
250 p->probe = probe;
251 strlcpy(p->name, name, sizeof(p->name));
252 p->next = NULL;
253 index = major_to_index(major);
254
255 for (n = &major_names[index]; *n; n = &(*n)->next) {
256 if ((*n)->major == major)
257 break;
258 }
259 if (!*n)
260 *n = p;
261 else
262 ret = -EBUSY;
263
264 if (ret < 0) {
265 printk("register_blkdev: cannot get major %u for %s\n",
266 major, name);
267 kfree(p);
268 }
269out:
270 mutex_unlock(&major_names_lock);
271 return ret;
272}
273EXPORT_SYMBOL(__register_blkdev);
274
275void unregister_blkdev(unsigned int major, const char *name)
276{
277 struct blk_major_name **n;
278 struct blk_major_name *p = NULL;
279 int index = major_to_index(major);
280
281 mutex_lock(&major_names_lock);
282 for (n = &major_names[index]; *n; n = &(*n)->next)
283 if ((*n)->major == major)
284 break;
285 if (!*n || strcmp((*n)->name, name)) {
286 WARN_ON(1);
287 } else {
288 p = *n;
289 *n = p->next;
290 }
291 mutex_unlock(&major_names_lock);
292 kfree(p);
293}
294
295EXPORT_SYMBOL(unregister_blkdev);
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310static int blk_mangle_minor(int minor)
311{
312#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
313 int i;
314
315 for (i = 0; i < MINORBITS / 2; i++) {
316 int low = minor & (1 << i);
317 int high = minor & (1 << (MINORBITS - 1 - i));
318 int distance = MINORBITS - 1 - 2 * i;
319
320 minor ^= low | high;
321 low <<= distance;
322 high >>= distance;
323 minor |= low | high;
324 }
325#endif
326 return minor;
327}
328
329int blk_alloc_ext_minor(void)
330{
331 int idx;
332
333 idx = ida_alloc_range(&ext_devt_ida, 0, NR_EXT_DEVT, GFP_KERNEL);
334 if (idx < 0) {
335 if (idx == -ENOSPC)
336 return -EBUSY;
337 return idx;
338 }
339 return blk_mangle_minor(idx);
340}
341
342void blk_free_ext_minor(unsigned int minor)
343{
344 ida_free(&ext_devt_ida, blk_mangle_minor(minor));
345}
346
347static char *bdevt_str(dev_t devt, char *buf)
348{
349 if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) {
350 char tbuf[BDEVT_SIZE];
351 snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt));
352 snprintf(buf, BDEVT_SIZE, "%-9s", tbuf);
353 } else
354 snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt));
355
356 return buf;
357}
358
359void disk_uevent(struct gendisk *disk, enum kobject_action action)
360{
361 struct block_device *part;
362 unsigned long idx;
363
364 rcu_read_lock();
365 xa_for_each(&disk->part_tbl, idx, part) {
366 if (bdev_is_partition(part) && !bdev_nr_sectors(part))
367 continue;
368 if (!kobject_get_unless_zero(&part->bd_device.kobj))
369 continue;
370
371 rcu_read_unlock();
372 kobject_uevent(bdev_kobj(part), action);
373 put_device(&part->bd_device);
374 rcu_read_lock();
375 }
376 rcu_read_unlock();
377}
378EXPORT_SYMBOL_GPL(disk_uevent);
379
380static void disk_scan_partitions(struct gendisk *disk)
381{
382 struct block_device *bdev;
383
384 if (!get_capacity(disk) || !disk_part_scan_enabled(disk))
385 return;
386
387 set_bit(GD_NEED_PART_SCAN, &disk->state);
388 bdev = blkdev_get_by_dev(disk_devt(disk), FMODE_READ, NULL);
389 if (!IS_ERR(bdev))
390 blkdev_put(bdev, FMODE_READ);
391}
392
393static void register_disk(struct device *parent, struct gendisk *disk,
394 const struct attribute_group **groups)
395{
396 struct device *ddev = disk_to_dev(disk);
397 int err;
398
399 ddev->parent = parent;
400
401 dev_set_name(ddev, "%s", disk->disk_name);
402
403
404 dev_set_uevent_suppress(ddev, 1);
405
406 if (groups) {
407 WARN_ON(ddev->groups);
408 ddev->groups = groups;
409 }
410 if (device_add(ddev))
411 return;
412 if (!sysfs_deprecated) {
413 err = sysfs_create_link(block_depr, &ddev->kobj,
414 kobject_name(&ddev->kobj));
415 if (err) {
416 device_del(ddev);
417 return;
418 }
419 }
420
421
422
423
424
425
426 pm_runtime_set_memalloc_noio(ddev, true);
427
428 disk->part0->bd_holder_dir =
429 kobject_create_and_add("holders", &ddev->kobj);
430 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
431
432 if (disk->flags & GENHD_FL_HIDDEN)
433 return;
434
435 disk_scan_partitions(disk);
436
437
438 dev_set_uevent_suppress(ddev, 0);
439 disk_uevent(disk, KOBJ_ADD);
440
441 if (disk->queue->backing_dev_info->dev) {
442 err = sysfs_create_link(&ddev->kobj,
443 &disk->queue->backing_dev_info->dev->kobj,
444 "bdi");
445 WARN_ON(err);
446 }
447}
448
449
450
451
452
453
454
455
456
457
458
459
460
461static void __device_add_disk(struct device *parent, struct gendisk *disk,
462 const struct attribute_group **groups,
463 bool register_queue)
464{
465 int ret;
466
467
468
469
470
471
472
473 if (register_queue)
474 elevator_init_mq(disk->queue);
475
476
477
478
479
480
481
482
483 if (disk->major) {
484 WARN_ON(!disk->minors);
485
486 if (disk->minors > DISK_MAX_PARTS) {
487 pr_err("block: can't allocate more than %d partitions\n",
488 DISK_MAX_PARTS);
489 disk->minors = DISK_MAX_PARTS;
490 }
491 } else {
492 WARN_ON(disk->minors);
493
494 ret = blk_alloc_ext_minor();
495 if (ret < 0) {
496 WARN_ON(1);
497 return;
498 }
499 disk->major = BLOCK_EXT_MAJOR;
500 disk->first_minor = MINOR(ret);
501 disk->flags |= GENHD_FL_EXT_DEVT;
502 }
503
504 disk->flags |= GENHD_FL_UP;
505
506 disk_alloc_events(disk);
507
508 if (disk->flags & GENHD_FL_HIDDEN) {
509
510
511
512
513 disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
514 disk->flags |= GENHD_FL_NO_PART_SCAN;
515 } else {
516 struct backing_dev_info *bdi = disk->queue->backing_dev_info;
517 struct device *dev = disk_to_dev(disk);
518
519
520 dev->devt = MKDEV(disk->major, disk->first_minor);
521 ret = bdi_register(bdi, "%u:%u",
522 disk->major, disk->first_minor);
523 WARN_ON(ret);
524 bdi_set_owner(bdi, dev);
525 bdev_add(disk->part0, dev->devt);
526 }
527 register_disk(parent, disk, groups);
528 if (register_queue)
529 blk_register_queue(disk);
530
531
532
533
534
535 if (blk_get_queue(disk->queue))
536 set_bit(GD_QUEUE_REF, &disk->state);
537 else
538 WARN_ON_ONCE(1);
539
540 disk_add_events(disk);
541 blk_integrity_add(disk);
542}
543
544void device_add_disk(struct device *parent, struct gendisk *disk,
545 const struct attribute_group **groups)
546
547{
548 __device_add_disk(parent, disk, groups, true);
549}
550EXPORT_SYMBOL(device_add_disk);
551
552void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk)
553{
554 __device_add_disk(parent, disk, NULL, false);
555}
556EXPORT_SYMBOL(device_add_disk_no_queue_reg);
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577void del_gendisk(struct gendisk *disk)
578{
579 might_sleep();
580
581 if (WARN_ON_ONCE(!disk->queue))
582 return;
583
584 blk_integrity_del(disk);
585 disk_del_events(disk);
586
587 mutex_lock(&disk->open_mutex);
588 disk->flags &= ~GENHD_FL_UP;
589 blk_drop_partitions(disk);
590 mutex_unlock(&disk->open_mutex);
591
592 fsync_bdev(disk->part0);
593 __invalidate_device(disk->part0, true);
594
595
596
597
598
599 remove_inode_hash(disk->part0->bd_inode);
600
601 set_capacity(disk, 0);
602
603 if (!(disk->flags & GENHD_FL_HIDDEN)) {
604 sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
605
606
607
608
609
610 bdi_unregister(disk->queue->backing_dev_info);
611 }
612
613 blk_unregister_queue(disk);
614
615 kobject_put(disk->part0->bd_holder_dir);
616 kobject_put(disk->slave_dir);
617
618 part_stat_set_all(disk->part0, 0);
619 disk->part0->bd_stamp = 0;
620 if (!sysfs_deprecated)
621 sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
622 pm_runtime_set_memalloc_noio(disk_to_dev(disk), false);
623 device_del(disk_to_dev(disk));
624}
625EXPORT_SYMBOL(del_gendisk);
626
627
628static ssize_t disk_badblocks_show(struct device *dev,
629 struct device_attribute *attr,
630 char *page)
631{
632 struct gendisk *disk = dev_to_disk(dev);
633
634 if (!disk->bb)
635 return sprintf(page, "\n");
636
637 return badblocks_show(disk->bb, page, 0);
638}
639
640static ssize_t disk_badblocks_store(struct device *dev,
641 struct device_attribute *attr,
642 const char *page, size_t len)
643{
644 struct gendisk *disk = dev_to_disk(dev);
645
646 if (!disk->bb)
647 return -ENXIO;
648
649 return badblocks_store(disk->bb, page, len, 0);
650}
651
652void blk_request_module(dev_t devt)
653{
654 unsigned int major = MAJOR(devt);
655 struct blk_major_name **n;
656
657 mutex_lock(&major_names_lock);
658 for (n = &major_names[major_to_index(major)]; *n; n = &(*n)->next) {
659 if ((*n)->major == major && (*n)->probe) {
660 (*n)->probe(devt);
661 mutex_unlock(&major_names_lock);
662 return;
663 }
664 }
665 mutex_unlock(&major_names_lock);
666
667 if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
668
669 request_module("block-major-%d", MAJOR(devt));
670}
671
672
673
674
675
676
677void __init printk_all_partitions(void)
678{
679 struct class_dev_iter iter;
680 struct device *dev;
681
682 class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
683 while ((dev = class_dev_iter_next(&iter))) {
684 struct gendisk *disk = dev_to_disk(dev);
685 struct block_device *part;
686 char name_buf[BDEVNAME_SIZE];
687 char devt_buf[BDEVT_SIZE];
688 unsigned long idx;
689
690
691
692
693
694 if (get_capacity(disk) == 0 ||
695 (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
696 continue;
697
698
699
700
701
702 rcu_read_lock();
703 xa_for_each(&disk->part_tbl, idx, part) {
704 if (!bdev_nr_sectors(part))
705 continue;
706 printk("%s%s %10llu %s %s",
707 bdev_is_partition(part) ? " " : "",
708 bdevt_str(part->bd_dev, devt_buf),
709 bdev_nr_sectors(part) >> 1,
710 disk_name(disk, part->bd_partno, name_buf),
711 part->bd_meta_info ?
712 part->bd_meta_info->uuid : "");
713 if (bdev_is_partition(part))
714 printk("\n");
715 else if (dev->parent && dev->parent->driver)
716 printk(" driver: %s\n",
717 dev->parent->driver->name);
718 else
719 printk(" (driver?)\n");
720 }
721 rcu_read_unlock();
722 }
723 class_dev_iter_exit(&iter);
724}
725
726#ifdef CONFIG_PROC_FS
727
728static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
729{
730 loff_t skip = *pos;
731 struct class_dev_iter *iter;
732 struct device *dev;
733
734 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
735 if (!iter)
736 return ERR_PTR(-ENOMEM);
737
738 seqf->private = iter;
739 class_dev_iter_init(iter, &block_class, NULL, &disk_type);
740 do {
741 dev = class_dev_iter_next(iter);
742 if (!dev)
743 return NULL;
744 } while (skip--);
745
746 return dev_to_disk(dev);
747}
748
749static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
750{
751 struct device *dev;
752
753 (*pos)++;
754 dev = class_dev_iter_next(seqf->private);
755 if (dev)
756 return dev_to_disk(dev);
757
758 return NULL;
759}
760
761static void disk_seqf_stop(struct seq_file *seqf, void *v)
762{
763 struct class_dev_iter *iter = seqf->private;
764
765
766 if (iter) {
767 class_dev_iter_exit(iter);
768 kfree(iter);
769 seqf->private = NULL;
770 }
771}
772
773static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
774{
775 void *p;
776
777 p = disk_seqf_start(seqf, pos);
778 if (!IS_ERR_OR_NULL(p) && !*pos)
779 seq_puts(seqf, "major minor #blocks name\n\n");
780 return p;
781}
782
783static int show_partition(struct seq_file *seqf, void *v)
784{
785 struct gendisk *sgp = v;
786 struct block_device *part;
787 unsigned long idx;
788 char buf[BDEVNAME_SIZE];
789
790
791 if (!get_capacity(sgp) || (!disk_max_parts(sgp) &&
792 (sgp->flags & GENHD_FL_REMOVABLE)))
793 return 0;
794 if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
795 return 0;
796
797 rcu_read_lock();
798 xa_for_each(&sgp->part_tbl, idx, part) {
799 if (!bdev_nr_sectors(part))
800 continue;
801 seq_printf(seqf, "%4d %7d %10llu %s\n",
802 MAJOR(part->bd_dev), MINOR(part->bd_dev),
803 bdev_nr_sectors(part) >> 1,
804 disk_name(sgp, part->bd_partno, buf));
805 }
806 rcu_read_unlock();
807 return 0;
808}
809
810static const struct seq_operations partitions_op = {
811 .start = show_partition_start,
812 .next = disk_seqf_next,
813 .stop = disk_seqf_stop,
814 .show = show_partition
815};
816#endif
817
818static int __init genhd_device_init(void)
819{
820 int error;
821
822 block_class.dev_kobj = sysfs_dev_block_kobj;
823 error = class_register(&block_class);
824 if (unlikely(error))
825 return error;
826 blk_dev_init();
827
828 register_blkdev(BLOCK_EXT_MAJOR, "blkext");
829
830
831 if (!sysfs_deprecated)
832 block_depr = kobject_create_and_add("block", NULL);
833 return 0;
834}
835
836subsys_initcall(genhd_device_init);
837
838static ssize_t disk_range_show(struct device *dev,
839 struct device_attribute *attr, char *buf)
840{
841 struct gendisk *disk = dev_to_disk(dev);
842
843 return sprintf(buf, "%d\n", disk->minors);
844}
845
846static ssize_t disk_ext_range_show(struct device *dev,
847 struct device_attribute *attr, char *buf)
848{
849 struct gendisk *disk = dev_to_disk(dev);
850
851 return sprintf(buf, "%d\n", disk_max_parts(disk));
852}
853
854static ssize_t disk_removable_show(struct device *dev,
855 struct device_attribute *attr, char *buf)
856{
857 struct gendisk *disk = dev_to_disk(dev);
858
859 return sprintf(buf, "%d\n",
860 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
861}
862
863static ssize_t disk_hidden_show(struct device *dev,
864 struct device_attribute *attr, char *buf)
865{
866 struct gendisk *disk = dev_to_disk(dev);
867
868 return sprintf(buf, "%d\n",
869 (disk->flags & GENHD_FL_HIDDEN ? 1 : 0));
870}
871
872static ssize_t disk_ro_show(struct device *dev,
873 struct device_attribute *attr, char *buf)
874{
875 struct gendisk *disk = dev_to_disk(dev);
876
877 return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
878}
879
880ssize_t part_size_show(struct device *dev,
881 struct device_attribute *attr, char *buf)
882{
883 return sprintf(buf, "%llu\n", bdev_nr_sectors(dev_to_bdev(dev)));
884}
885
886ssize_t part_stat_show(struct device *dev,
887 struct device_attribute *attr, char *buf)
888{
889 struct block_device *bdev = dev_to_bdev(dev);
890 struct request_queue *q = bdev->bd_disk->queue;
891 struct disk_stats stat;
892 unsigned int inflight;
893
894 part_stat_read_all(bdev, &stat);
895 if (queue_is_mq(q))
896 inflight = blk_mq_in_flight(q, bdev);
897 else
898 inflight = part_in_flight(bdev);
899
900 return sprintf(buf,
901 "%8lu %8lu %8llu %8u "
902 "%8lu %8lu %8llu %8u "
903 "%8u %8u %8u "
904 "%8lu %8lu %8llu %8u "
905 "%8lu %8u"
906 "\n",
907 stat.ios[STAT_READ],
908 stat.merges[STAT_READ],
909 (unsigned long long)stat.sectors[STAT_READ],
910 (unsigned int)div_u64(stat.nsecs[STAT_READ], NSEC_PER_MSEC),
911 stat.ios[STAT_WRITE],
912 stat.merges[STAT_WRITE],
913 (unsigned long long)stat.sectors[STAT_WRITE],
914 (unsigned int)div_u64(stat.nsecs[STAT_WRITE], NSEC_PER_MSEC),
915 inflight,
916 jiffies_to_msecs(stat.io_ticks),
917 (unsigned int)div_u64(stat.nsecs[STAT_READ] +
918 stat.nsecs[STAT_WRITE] +
919 stat.nsecs[STAT_DISCARD] +
920 stat.nsecs[STAT_FLUSH],
921 NSEC_PER_MSEC),
922 stat.ios[STAT_DISCARD],
923 stat.merges[STAT_DISCARD],
924 (unsigned long long)stat.sectors[STAT_DISCARD],
925 (unsigned int)div_u64(stat.nsecs[STAT_DISCARD], NSEC_PER_MSEC),
926 stat.ios[STAT_FLUSH],
927 (unsigned int)div_u64(stat.nsecs[STAT_FLUSH], NSEC_PER_MSEC));
928}
929
930ssize_t part_inflight_show(struct device *dev, struct device_attribute *attr,
931 char *buf)
932{
933 struct block_device *bdev = dev_to_bdev(dev);
934 struct request_queue *q = bdev->bd_disk->queue;
935 unsigned int inflight[2];
936
937 if (queue_is_mq(q))
938 blk_mq_in_flight_rw(q, bdev, inflight);
939 else
940 part_in_flight_rw(bdev, inflight);
941
942 return sprintf(buf, "%8u %8u\n", inflight[0], inflight[1]);
943}
944
945static ssize_t disk_capability_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, "%x\n", disk->flags);
951}
952
953static ssize_t disk_alignment_offset_show(struct device *dev,
954 struct device_attribute *attr,
955 char *buf)
956{
957 struct gendisk *disk = dev_to_disk(dev);
958
959 return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
960}
961
962static ssize_t disk_discard_alignment_show(struct device *dev,
963 struct device_attribute *attr,
964 char *buf)
965{
966 struct gendisk *disk = dev_to_disk(dev);
967
968 return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
969}
970
971static DEVICE_ATTR(range, 0444, disk_range_show, NULL);
972static DEVICE_ATTR(ext_range, 0444, disk_ext_range_show, NULL);
973static DEVICE_ATTR(removable, 0444, disk_removable_show, NULL);
974static DEVICE_ATTR(hidden, 0444, disk_hidden_show, NULL);
975static DEVICE_ATTR(ro, 0444, disk_ro_show, NULL);
976static DEVICE_ATTR(size, 0444, part_size_show, NULL);
977static DEVICE_ATTR(alignment_offset, 0444, disk_alignment_offset_show, NULL);
978static DEVICE_ATTR(discard_alignment, 0444, disk_discard_alignment_show, NULL);
979static DEVICE_ATTR(capability, 0444, disk_capability_show, NULL);
980static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
981static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
982static DEVICE_ATTR(badblocks, 0644, disk_badblocks_show, disk_badblocks_store);
983
984#ifdef CONFIG_FAIL_MAKE_REQUEST
985ssize_t part_fail_show(struct device *dev,
986 struct device_attribute *attr, char *buf)
987{
988 return sprintf(buf, "%d\n", dev_to_bdev(dev)->bd_make_it_fail);
989}
990
991ssize_t part_fail_store(struct device *dev,
992 struct device_attribute *attr,
993 const char *buf, size_t count)
994{
995 int i;
996
997 if (count > 0 && sscanf(buf, "%d", &i) > 0)
998 dev_to_bdev(dev)->bd_make_it_fail = i;
999
1000 return count;
1001}
1002
1003static struct device_attribute dev_attr_fail =
1004 __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
1005#endif
1006
1007#ifdef CONFIG_FAIL_IO_TIMEOUT
1008static struct device_attribute dev_attr_fail_timeout =
1009 __ATTR(io-timeout-fail, 0644, part_timeout_show, part_timeout_store);
1010#endif
1011
1012static struct attribute *disk_attrs[] = {
1013 &dev_attr_range.attr,
1014 &dev_attr_ext_range.attr,
1015 &dev_attr_removable.attr,
1016 &dev_attr_hidden.attr,
1017 &dev_attr_ro.attr,
1018 &dev_attr_size.attr,
1019 &dev_attr_alignment_offset.attr,
1020 &dev_attr_discard_alignment.attr,
1021 &dev_attr_capability.attr,
1022 &dev_attr_stat.attr,
1023 &dev_attr_inflight.attr,
1024 &dev_attr_badblocks.attr,
1025 &dev_attr_events.attr,
1026 &dev_attr_events_async.attr,
1027 &dev_attr_events_poll_msecs.attr,
1028#ifdef CONFIG_FAIL_MAKE_REQUEST
1029 &dev_attr_fail.attr,
1030#endif
1031#ifdef CONFIG_FAIL_IO_TIMEOUT
1032 &dev_attr_fail_timeout.attr,
1033#endif
1034 NULL
1035};
1036
1037static umode_t disk_visible(struct kobject *kobj, struct attribute *a, int n)
1038{
1039 struct device *dev = container_of(kobj, typeof(*dev), kobj);
1040 struct gendisk *disk = dev_to_disk(dev);
1041
1042 if (a == &dev_attr_badblocks.attr && !disk->bb)
1043 return 0;
1044 return a->mode;
1045}
1046
1047static struct attribute_group disk_attr_group = {
1048 .attrs = disk_attrs,
1049 .is_visible = disk_visible,
1050};
1051
1052static const struct attribute_group *disk_attr_groups[] = {
1053 &disk_attr_group,
1054 NULL
1055};
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071static void disk_release(struct device *dev)
1072{
1073 struct gendisk *disk = dev_to_disk(dev);
1074
1075 might_sleep();
1076
1077 if (MAJOR(dev->devt) == BLOCK_EXT_MAJOR)
1078 blk_free_ext_minor(MINOR(dev->devt));
1079 disk_release_events(disk);
1080 kfree(disk->random);
1081 xa_destroy(&disk->part_tbl);
1082 if (test_bit(GD_QUEUE_REF, &disk->state) && disk->queue)
1083 blk_put_queue(disk->queue);
1084 bdput(disk->part0);
1085}
1086struct class block_class = {
1087 .name = "block",
1088};
1089
1090static char *block_devnode(struct device *dev, umode_t *mode,
1091 kuid_t *uid, kgid_t *gid)
1092{
1093 struct gendisk *disk = dev_to_disk(dev);
1094
1095 if (disk->fops->devnode)
1096 return disk->fops->devnode(disk, mode);
1097 return NULL;
1098}
1099
1100const struct device_type disk_type = {
1101 .name = "disk",
1102 .groups = disk_attr_groups,
1103 .release = disk_release,
1104 .devnode = block_devnode,
1105};
1106
1107#ifdef CONFIG_PROC_FS
1108
1109
1110
1111
1112
1113
1114
1115static int diskstats_show(struct seq_file *seqf, void *v)
1116{
1117 struct gendisk *gp = v;
1118 struct block_device *hd;
1119 char buf[BDEVNAME_SIZE];
1120 unsigned int inflight;
1121 struct disk_stats stat;
1122 unsigned long idx;
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132 rcu_read_lock();
1133 xa_for_each(&gp->part_tbl, idx, hd) {
1134 if (bdev_is_partition(hd) && !bdev_nr_sectors(hd))
1135 continue;
1136 part_stat_read_all(hd, &stat);
1137 if (queue_is_mq(gp->queue))
1138 inflight = blk_mq_in_flight(gp->queue, hd);
1139 else
1140 inflight = part_in_flight(hd);
1141
1142 seq_printf(seqf, "%4d %7d %s "
1143 "%lu %lu %lu %u "
1144 "%lu %lu %lu %u "
1145 "%u %u %u "
1146 "%lu %lu %lu %u "
1147 "%lu %u"
1148 "\n",
1149 MAJOR(hd->bd_dev), MINOR(hd->bd_dev),
1150 disk_name(gp, hd->bd_partno, buf),
1151 stat.ios[STAT_READ],
1152 stat.merges[STAT_READ],
1153 stat.sectors[STAT_READ],
1154 (unsigned int)div_u64(stat.nsecs[STAT_READ],
1155 NSEC_PER_MSEC),
1156 stat.ios[STAT_WRITE],
1157 stat.merges[STAT_WRITE],
1158 stat.sectors[STAT_WRITE],
1159 (unsigned int)div_u64(stat.nsecs[STAT_WRITE],
1160 NSEC_PER_MSEC),
1161 inflight,
1162 jiffies_to_msecs(stat.io_ticks),
1163 (unsigned int)div_u64(stat.nsecs[STAT_READ] +
1164 stat.nsecs[STAT_WRITE] +
1165 stat.nsecs[STAT_DISCARD] +
1166 stat.nsecs[STAT_FLUSH],
1167 NSEC_PER_MSEC),
1168 stat.ios[STAT_DISCARD],
1169 stat.merges[STAT_DISCARD],
1170 stat.sectors[STAT_DISCARD],
1171 (unsigned int)div_u64(stat.nsecs[STAT_DISCARD],
1172 NSEC_PER_MSEC),
1173 stat.ios[STAT_FLUSH],
1174 (unsigned int)div_u64(stat.nsecs[STAT_FLUSH],
1175 NSEC_PER_MSEC)
1176 );
1177 }
1178 rcu_read_unlock();
1179
1180 return 0;
1181}
1182
1183static const struct seq_operations diskstats_op = {
1184 .start = disk_seqf_start,
1185 .next = disk_seqf_next,
1186 .stop = disk_seqf_stop,
1187 .show = diskstats_show
1188};
1189
1190static int __init proc_genhd_init(void)
1191{
1192 proc_create_seq("diskstats", 0, NULL, &diskstats_op);
1193 proc_create_seq("partitions", 0, NULL, &partitions_op);
1194 return 0;
1195}
1196module_init(proc_genhd_init);
1197#endif
1198
1199dev_t part_devt(struct gendisk *disk, u8 partno)
1200{
1201 struct block_device *part;
1202 dev_t devt = 0;
1203
1204 rcu_read_lock();
1205 part = xa_load(&disk->part_tbl, partno);
1206 if (part)
1207 devt = part->bd_dev;
1208 rcu_read_unlock();
1209
1210 return devt;
1211}
1212
1213dev_t blk_lookup_devt(const char *name, int partno)
1214{
1215 dev_t devt = MKDEV(0, 0);
1216 struct class_dev_iter iter;
1217 struct device *dev;
1218
1219 class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
1220 while ((dev = class_dev_iter_next(&iter))) {
1221 struct gendisk *disk = dev_to_disk(dev);
1222
1223 if (strcmp(dev_name(dev), name))
1224 continue;
1225
1226 if (partno < disk->minors) {
1227
1228
1229
1230 devt = MKDEV(MAJOR(dev->devt),
1231 MINOR(dev->devt) + partno);
1232 } else {
1233 devt = part_devt(disk, partno);
1234 if (devt)
1235 break;
1236 }
1237 }
1238 class_dev_iter_exit(&iter);
1239 return devt;
1240}
1241
1242struct gendisk *__alloc_disk_node(int minors, int node_id)
1243{
1244 struct gendisk *disk;
1245
1246 disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);
1247 if (!disk)
1248 return NULL;
1249
1250 disk->part0 = bdev_alloc(disk, 0);
1251 if (!disk->part0)
1252 goto out_free_disk;
1253
1254 disk->node_id = node_id;
1255 mutex_init(&disk->open_mutex);
1256 xa_init(&disk->part_tbl);
1257 if (xa_insert(&disk->part_tbl, 0, disk->part0, GFP_KERNEL))
1258 goto out_destroy_part_tbl;
1259
1260 disk->minors = minors;
1261 rand_initialize_disk(disk);
1262 disk_to_dev(disk)->class = &block_class;
1263 disk_to_dev(disk)->type = &disk_type;
1264 device_initialize(disk_to_dev(disk));
1265 return disk;
1266
1267out_destroy_part_tbl:
1268 xa_destroy(&disk->part_tbl);
1269 bdput(disk->part0);
1270out_free_disk:
1271 kfree(disk);
1272 return NULL;
1273}
1274EXPORT_SYMBOL(__alloc_disk_node);
1275
1276struct gendisk *__blk_alloc_disk(int node)
1277{
1278 struct request_queue *q;
1279 struct gendisk *disk;
1280
1281 q = blk_alloc_queue(node);
1282 if (!q)
1283 return NULL;
1284
1285 disk = __alloc_disk_node(0, node);
1286 if (!disk) {
1287 blk_cleanup_queue(q);
1288 return NULL;
1289 }
1290 disk->queue = q;
1291 return disk;
1292}
1293EXPORT_SYMBOL(__blk_alloc_disk);
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305void put_disk(struct gendisk *disk)
1306{
1307 if (disk)
1308 put_device(disk_to_dev(disk));
1309}
1310EXPORT_SYMBOL(put_disk);
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321void blk_cleanup_disk(struct gendisk *disk)
1322{
1323 blk_cleanup_queue(disk->queue);
1324 put_disk(disk);
1325}
1326EXPORT_SYMBOL(blk_cleanup_disk);
1327
1328static void set_disk_ro_uevent(struct gendisk *gd, int ro)
1329{
1330 char event[] = "DISK_RO=1";
1331 char *envp[] = { event, NULL };
1332
1333 if (!ro)
1334 event[8] = '0';
1335 kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
1336}
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347void set_disk_ro(struct gendisk *disk, bool read_only)
1348{
1349 if (read_only) {
1350 if (test_and_set_bit(GD_READ_ONLY, &disk->state))
1351 return;
1352 } else {
1353 if (!test_and_clear_bit(GD_READ_ONLY, &disk->state))
1354 return;
1355 }
1356 set_disk_ro_uevent(disk, read_only);
1357}
1358EXPORT_SYMBOL(set_disk_ro);
1359
1360int bdev_read_only(struct block_device *bdev)
1361{
1362 return bdev->bd_read_only || get_disk_ro(bdev->bd_disk);
1363}
1364EXPORT_SYMBOL(bdev_read_only);
1365