1 // SPDX-License-Identifier: GPL-2.0
5 * Portions Copyright (C) 2020 Christoph Hellwig
8 #include <linux/module.h>
9 #include <linux/ctype.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>
30 static struct kobject *block_depr;
33 * Unique, monotonically increasing sequential number associated with block
34 * devices instances (i.e. incremented each time a device is attached).
35 * Associating uevents with block devices in userspace is difficult and racy:
36 * the uevent netlink socket is lossy, and on slow and overloaded systems has
37 * a very high latency.
38 * Block devices do not have exclusive owners in userspace, any process can set
39 * one up (e.g. loop devices). Moreover, device names can be reused (e.g. loop0
40 * can be reused again and again).
41 * A userspace process setting up a block device and watching for its events
42 * cannot thus reliably tell whether an event relates to the device it just set
43 * up or another earlier instance with the same name.
44 * This sequential number allows userspace processes to solve this problem, and
45 * uniquely associate an uevent to the lifetime to a device.
47 static atomic64_t diskseq;
49 /* for extended dynamic devt allocation, currently only one major is used */
50 #define NR_EXT_DEVT (1 << MINORBITS)
51 static DEFINE_IDA(ext_devt_ida);
53 void set_capacity(struct gendisk *disk, sector_t sectors)
55 struct block_device *bdev = disk->part0;
57 spin_lock(&bdev->bd_size_lock);
58 i_size_write(bdev->bd_inode, (loff_t)sectors << SECTOR_SHIFT);
59 spin_unlock(&bdev->bd_size_lock);
61 EXPORT_SYMBOL(set_capacity);
64 * Set disk capacity and notify if the size is not currently zero and will not
65 * be set to zero. Returns true if a uevent was sent, otherwise false.
67 bool set_capacity_and_notify(struct gendisk *disk, sector_t size)
69 sector_t capacity = get_capacity(disk);
70 char *envp[] = { "RESIZE=1", NULL };
72 set_capacity(disk, size);
75 * Only print a message and send a uevent if the gendisk is user visible
76 * and alive. This avoids spamming the log and udev when setting the
77 * initial capacity during probing.
79 if (size == capacity ||
80 (disk->flags & (GENHD_FL_UP | GENHD_FL_HIDDEN)) != GENHD_FL_UP)
83 pr_info("%s: detected capacity change from %lld to %lld\n",
84 disk->disk_name, capacity, size);
87 * Historically we did not send a uevent for changes to/from an empty
90 if (!capacity || !size)
92 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
95 EXPORT_SYMBOL_GPL(set_capacity_and_notify);
98 * Format the device name of the indicated block device into the supplied buffer
99 * and return a pointer to that same buffer for convenience.
101 * Note: do not use this in new code, use the %pg specifier to sprintf and
104 const char *bdevname(struct block_device *bdev, char *buf)
106 struct gendisk *hd = bdev->bd_disk;
107 int partno = bdev->bd_partno;
110 snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
111 else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
112 snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, partno);
114 snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, partno);
118 EXPORT_SYMBOL(bdevname);
120 static void part_stat_read_all(struct block_device *part,
121 struct disk_stats *stat)
125 memset(stat, 0, sizeof(struct disk_stats));
126 for_each_possible_cpu(cpu) {
127 struct disk_stats *ptr = per_cpu_ptr(part->bd_stats, cpu);
130 for (group = 0; group < NR_STAT_GROUPS; group++) {
131 stat->nsecs[group] += ptr->nsecs[group];
132 stat->sectors[group] += ptr->sectors[group];
133 stat->ios[group] += ptr->ios[group];
134 stat->merges[group] += ptr->merges[group];
137 stat->io_ticks += ptr->io_ticks;
141 static unsigned int part_in_flight(struct block_device *part)
143 unsigned int inflight = 0;
146 for_each_possible_cpu(cpu) {
147 inflight += part_stat_local_read_cpu(part, in_flight[0], cpu) +
148 part_stat_local_read_cpu(part, in_flight[1], cpu);
150 if ((int)inflight < 0)
156 static void part_in_flight_rw(struct block_device *part,
157 unsigned int inflight[2])
163 for_each_possible_cpu(cpu) {
164 inflight[0] += part_stat_local_read_cpu(part, in_flight[0], cpu);
165 inflight[1] += part_stat_local_read_cpu(part, in_flight[1], cpu);
167 if ((int)inflight[0] < 0)
169 if ((int)inflight[1] < 0)
174 * Can be deleted altogether. Later.
177 #define BLKDEV_MAJOR_HASH_SIZE 255
178 static struct blk_major_name {
179 struct blk_major_name *next;
182 void (*probe)(dev_t devt);
183 } *major_names[BLKDEV_MAJOR_HASH_SIZE];
184 static DEFINE_MUTEX(major_names_lock);
186 /* index in the above - for now: assume no multimajor ranges */
187 static inline int major_to_index(unsigned major)
189 return major % BLKDEV_MAJOR_HASH_SIZE;
192 #ifdef CONFIG_PROC_FS
193 void blkdev_show(struct seq_file *seqf, off_t offset)
195 struct blk_major_name *dp;
197 mutex_lock(&major_names_lock);
198 for (dp = major_names[major_to_index(offset)]; dp; dp = dp->next)
199 if (dp->major == offset)
200 seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
201 mutex_unlock(&major_names_lock);
203 #endif /* CONFIG_PROC_FS */
206 * __register_blkdev - register a new block device
208 * @major: the requested major device number [1..BLKDEV_MAJOR_MAX-1]. If
209 * @major = 0, try to allocate any unused major number.
210 * @name: the name of the new block device as a zero terminated string
211 * @probe: allback that is called on access to any minor number of @major
213 * The @name must be unique within the system.
215 * The return value depends on the @major input parameter:
217 * - if a major device number was requested in range [1..BLKDEV_MAJOR_MAX-1]
218 * then the function returns zero on success, or a negative error code
219 * - if any unused major number was requested with @major = 0 parameter
220 * then the return value is the allocated major number in range
221 * [1..BLKDEV_MAJOR_MAX-1] or a negative error code otherwise
223 * See Documentation/admin-guide/devices.txt for the list of allocated
226 * Use register_blkdev instead for any new code.
228 int __register_blkdev(unsigned int major, const char *name,
229 void (*probe)(dev_t devt))
231 struct blk_major_name **n, *p;
234 mutex_lock(&major_names_lock);
238 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
239 if (major_names[index] == NULL)
244 printk("%s: failed to get major for %s\n",
253 if (major >= BLKDEV_MAJOR_MAX) {
254 pr_err("%s: major requested (%u) is greater than the maximum (%u) for %s\n",
255 __func__, major, BLKDEV_MAJOR_MAX-1, name);
261 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
269 strlcpy(p->name, name, sizeof(p->name));
271 index = major_to_index(major);
273 for (n = &major_names[index]; *n; n = &(*n)->next) {
274 if ((*n)->major == major)
283 printk("register_blkdev: cannot get major %u for %s\n",
288 mutex_unlock(&major_names_lock);
291 EXPORT_SYMBOL(__register_blkdev);
293 void unregister_blkdev(unsigned int major, const char *name)
295 struct blk_major_name **n;
296 struct blk_major_name *p = NULL;
297 int index = major_to_index(major);
299 mutex_lock(&major_names_lock);
300 for (n = &major_names[index]; *n; n = &(*n)->next)
301 if ((*n)->major == major)
303 if (!*n || strcmp((*n)->name, name)) {
309 mutex_unlock(&major_names_lock);
313 EXPORT_SYMBOL(unregister_blkdev);
316 * blk_mangle_minor - scatter minor numbers apart
317 * @minor: minor number to mangle
319 * Scatter consecutively allocated @minor number apart if MANGLE_DEVT
320 * is enabled. Mangling twice gives the original value.
328 static int blk_mangle_minor(int minor)
330 #ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
333 for (i = 0; i < MINORBITS / 2; i++) {
334 int low = minor & (1 << i);
335 int high = minor & (1 << (MINORBITS - 1 - i));
336 int distance = MINORBITS - 1 - 2 * i;
338 minor ^= low | high; /* clear both bits */
339 low <<= distance; /* swap the positions */
341 minor |= low | high; /* and set */
347 int blk_alloc_ext_minor(void)
351 idx = ida_alloc_range(&ext_devt_ida, 0, NR_EXT_DEVT, GFP_KERNEL);
357 return blk_mangle_minor(idx);
360 void blk_free_ext_minor(unsigned int minor)
362 ida_free(&ext_devt_ida, blk_mangle_minor(minor));
365 static char *bdevt_str(dev_t devt, char *buf)
367 if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) {
368 char tbuf[BDEVT_SIZE];
369 snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt));
370 snprintf(buf, BDEVT_SIZE, "%-9s", tbuf);
372 snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt));
377 void disk_uevent(struct gendisk *disk, enum kobject_action action)
379 struct block_device *part;
383 xa_for_each(&disk->part_tbl, idx, part) {
384 if (bdev_is_partition(part) && !bdev_nr_sectors(part))
386 if (!kobject_get_unless_zero(&part->bd_device.kobj))
390 kobject_uevent(bdev_kobj(part), action);
391 put_device(&part->bd_device);
396 EXPORT_SYMBOL_GPL(disk_uevent);
398 static void disk_scan_partitions(struct gendisk *disk)
400 struct block_device *bdev;
402 if (!get_capacity(disk) || !disk_part_scan_enabled(disk))
405 set_bit(GD_NEED_PART_SCAN, &disk->state);
406 bdev = blkdev_get_by_dev(disk_devt(disk), FMODE_READ, NULL);
408 blkdev_put(bdev, FMODE_READ);
411 static void register_disk(struct device *parent, struct gendisk *disk,
412 const struct attribute_group **groups)
414 struct device *ddev = disk_to_dev(disk);
417 ddev->parent = parent;
419 dev_set_name(ddev, "%s", disk->disk_name);
421 /* delay uevents, until we scanned partition table */
422 dev_set_uevent_suppress(ddev, 1);
425 WARN_ON(ddev->groups);
426 ddev->groups = groups;
428 if (device_add(ddev))
430 if (!sysfs_deprecated) {
431 err = sysfs_create_link(block_depr, &ddev->kobj,
432 kobject_name(&ddev->kobj));
440 * avoid probable deadlock caused by allocating memory with
441 * GFP_KERNEL in runtime_resume callback of its all ancestor
444 pm_runtime_set_memalloc_noio(ddev, true);
446 disk->part0->bd_holder_dir =
447 kobject_create_and_add("holders", &ddev->kobj);
448 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
450 if (disk->flags & GENHD_FL_HIDDEN)
453 disk_scan_partitions(disk);
455 /* announce the disk and partitions after all partitions are created */
456 dev_set_uevent_suppress(ddev, 0);
457 disk_uevent(disk, KOBJ_ADD);
459 if (disk->queue->backing_dev_info->dev) {
460 err = sysfs_create_link(&ddev->kobj,
461 &disk->queue->backing_dev_info->dev->kobj,
468 * __device_add_disk - add disk information to kernel list
469 * @parent: parent device for the disk
470 * @disk: per-device partitioning information
471 * @groups: Additional per-device sysfs groups
472 * @register_queue: register the queue if set to true
474 * This function registers the partitioning information in @disk
477 * FIXME: error handling
479 static void __device_add_disk(struct device *parent, struct gendisk *disk,
480 const struct attribute_group **groups,
486 * The disk queue should now be all set with enough information about
487 * the device for the elevator code to pick an adequate default
488 * elevator if one is needed, that is, for devices requesting queue
492 elevator_init_mq(disk->queue);
495 * If the driver provides an explicit major number it also must provide
496 * the number of minors numbers supported, and those will be used to
498 * Otherwise just allocate the device numbers for both the whole device
499 * and all partitions from the extended dev_t space.
502 WARN_ON(!disk->minors);
504 if (disk->minors > DISK_MAX_PARTS) {
505 pr_err("block: can't allocate more than %d partitions\n",
507 disk->minors = DISK_MAX_PARTS;
510 WARN_ON(disk->minors);
512 ret = blk_alloc_ext_minor();
517 disk->major = BLOCK_EXT_MAJOR;
518 disk->first_minor = MINOR(ret);
519 disk->flags |= GENHD_FL_EXT_DEVT;
522 disk->flags |= GENHD_FL_UP;
524 disk_alloc_events(disk);
526 if (disk->flags & GENHD_FL_HIDDEN) {
528 * Don't let hidden disks show up in /proc/partitions,
529 * and don't bother scanning for partitions either.
531 disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
532 disk->flags |= GENHD_FL_NO_PART_SCAN;
534 struct backing_dev_info *bdi = disk->queue->backing_dev_info;
535 struct device *dev = disk_to_dev(disk);
537 /* Register BDI before referencing it from bdev */
538 dev->devt = MKDEV(disk->major, disk->first_minor);
539 ret = bdi_register(bdi, "%u:%u",
540 disk->major, disk->first_minor);
542 bdi_set_owner(bdi, dev);
543 bdev_add(disk->part0, dev->devt);
545 register_disk(parent, disk, groups);
547 blk_register_queue(disk);
550 * Take an extra ref on queue which will be put on disk_release()
551 * so that it sticks around as long as @disk is there.
553 if (blk_get_queue(disk->queue))
554 set_bit(GD_QUEUE_REF, &disk->state);
558 disk_add_events(disk);
559 blk_integrity_add(disk);
562 void device_add_disk(struct device *parent, struct gendisk *disk,
563 const struct attribute_group **groups)
566 __device_add_disk(parent, disk, groups, true);
568 EXPORT_SYMBOL(device_add_disk);
570 void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk)
572 __device_add_disk(parent, disk, NULL, false);
574 EXPORT_SYMBOL(device_add_disk_no_queue_reg);
577 * del_gendisk - remove the gendisk
578 * @disk: the struct gendisk to remove
580 * Removes the gendisk and all its associated resources. This deletes the
581 * partitions associated with the gendisk, and unregisters the associated
584 * This is the counter to the respective __device_add_disk() call.
586 * The final removal of the struct gendisk happens when its refcount reaches 0
587 * with put_disk(), which should be called after del_gendisk(), if
588 * __device_add_disk() was used.
590 * Drivers exist which depend on the release of the gendisk to be synchronous,
591 * it should not be deferred.
595 void del_gendisk(struct gendisk *disk)
599 if (WARN_ON_ONCE(!disk->queue))
602 blk_integrity_del(disk);
603 disk_del_events(disk);
605 mutex_lock(&disk->open_mutex);
606 remove_inode_hash(disk->part0->bd_inode);
607 disk->flags &= ~GENHD_FL_UP;
608 blk_drop_partitions(disk);
609 mutex_unlock(&disk->open_mutex);
611 fsync_bdev(disk->part0);
612 __invalidate_device(disk->part0, true);
614 set_capacity(disk, 0);
616 if (!(disk->flags & GENHD_FL_HIDDEN)) {
617 sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
620 * Unregister bdi before releasing device numbers (as they can
621 * get reused and we'd get clashes in sysfs).
623 bdi_unregister(disk->queue->backing_dev_info);
626 blk_unregister_queue(disk);
628 kobject_put(disk->part0->bd_holder_dir);
629 kobject_put(disk->slave_dir);
631 part_stat_set_all(disk->part0, 0);
632 disk->part0->bd_stamp = 0;
633 if (!sysfs_deprecated)
634 sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
635 pm_runtime_set_memalloc_noio(disk_to_dev(disk), false);
636 device_del(disk_to_dev(disk));
638 EXPORT_SYMBOL(del_gendisk);
640 /* sysfs access to bad-blocks list. */
641 static ssize_t disk_badblocks_show(struct device *dev,
642 struct device_attribute *attr,
645 struct gendisk *disk = dev_to_disk(dev);
648 return sprintf(page, "\n");
650 return badblocks_show(disk->bb, page, 0);
653 static ssize_t disk_badblocks_store(struct device *dev,
654 struct device_attribute *attr,
655 const char *page, size_t len)
657 struct gendisk *disk = dev_to_disk(dev);
662 return badblocks_store(disk->bb, page, len, 0);
665 void blk_request_module(dev_t devt)
667 unsigned int major = MAJOR(devt);
668 struct blk_major_name **n;
670 mutex_lock(&major_names_lock);
671 for (n = &major_names[major_to_index(major)]; *n; n = &(*n)->next) {
672 if ((*n)->major == major && (*n)->probe) {
674 mutex_unlock(&major_names_lock);
678 mutex_unlock(&major_names_lock);
680 if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
681 /* Make old-style 2.4 aliases work */
682 request_module("block-major-%d", MAJOR(devt));
686 * print a full list of all partitions - intended for places where the root
687 * filesystem can't be mounted and thus to give the victim some idea of what
690 void __init printk_all_partitions(void)
692 struct class_dev_iter iter;
695 class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
696 while ((dev = class_dev_iter_next(&iter))) {
697 struct gendisk *disk = dev_to_disk(dev);
698 struct block_device *part;
699 char devt_buf[BDEVT_SIZE];
703 * Don't show empty devices or things that have been
706 if (get_capacity(disk) == 0 ||
707 (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
711 * Note, unlike /proc/partitions, I am showing the numbers in
712 * hex - the same format as the root= option takes.
715 xa_for_each(&disk->part_tbl, idx, part) {
716 if (!bdev_nr_sectors(part))
718 printk("%s%s %10llu %pg %s",
719 bdev_is_partition(part) ? " " : "",
720 bdevt_str(part->bd_dev, devt_buf),
721 bdev_nr_sectors(part) >> 1, part,
723 part->bd_meta_info->uuid : "");
724 if (bdev_is_partition(part))
726 else if (dev->parent && dev->parent->driver)
727 printk(" driver: %s\n",
728 dev->parent->driver->name);
730 printk(" (driver?)\n");
734 class_dev_iter_exit(&iter);
737 #ifdef CONFIG_PROC_FS
739 static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
742 struct class_dev_iter *iter;
745 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
747 return ERR_PTR(-ENOMEM);
749 seqf->private = iter;
750 class_dev_iter_init(iter, &block_class, NULL, &disk_type);
752 dev = class_dev_iter_next(iter);
757 return dev_to_disk(dev);
760 static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
765 dev = class_dev_iter_next(seqf->private);
767 return dev_to_disk(dev);
772 static void disk_seqf_stop(struct seq_file *seqf, void *v)
774 struct class_dev_iter *iter = seqf->private;
776 /* stop is called even after start failed :-( */
778 class_dev_iter_exit(iter);
780 seqf->private = NULL;
784 static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
788 p = disk_seqf_start(seqf, pos);
789 if (!IS_ERR_OR_NULL(p) && !*pos)
790 seq_puts(seqf, "major minor #blocks name\n\n");
794 static int show_partition(struct seq_file *seqf, void *v)
796 struct gendisk *sgp = v;
797 struct block_device *part;
800 /* Don't show non-partitionable removeable devices or empty devices */
801 if (!get_capacity(sgp) || (!disk_max_parts(sgp) &&
802 (sgp->flags & GENHD_FL_REMOVABLE)))
804 if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
808 xa_for_each(&sgp->part_tbl, idx, part) {
809 if (!bdev_nr_sectors(part))
811 seq_printf(seqf, "%4d %7d %10llu %pg\n",
812 MAJOR(part->bd_dev), MINOR(part->bd_dev),
813 bdev_nr_sectors(part) >> 1, part);
819 static const struct seq_operations partitions_op = {
820 .start = show_partition_start,
821 .next = disk_seqf_next,
822 .stop = disk_seqf_stop,
823 .show = show_partition
827 static int __init genhd_device_init(void)
831 block_class.dev_kobj = sysfs_dev_block_kobj;
832 error = class_register(&block_class);
837 register_blkdev(BLOCK_EXT_MAJOR, "blkext");
839 /* create top-level block dir */
840 if (!sysfs_deprecated)
841 block_depr = kobject_create_and_add("block", NULL);
845 subsys_initcall(genhd_device_init);
847 static ssize_t disk_range_show(struct device *dev,
848 struct device_attribute *attr, char *buf)
850 struct gendisk *disk = dev_to_disk(dev);
852 return sprintf(buf, "%d\n", disk->minors);
855 static ssize_t disk_ext_range_show(struct device *dev,
856 struct device_attribute *attr, char *buf)
858 struct gendisk *disk = dev_to_disk(dev);
860 return sprintf(buf, "%d\n", disk_max_parts(disk));
863 static ssize_t disk_removable_show(struct device *dev,
864 struct device_attribute *attr, char *buf)
866 struct gendisk *disk = dev_to_disk(dev);
868 return sprintf(buf, "%d\n",
869 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
872 static ssize_t disk_hidden_show(struct device *dev,
873 struct device_attribute *attr, char *buf)
875 struct gendisk *disk = dev_to_disk(dev);
877 return sprintf(buf, "%d\n",
878 (disk->flags & GENHD_FL_HIDDEN ? 1 : 0));
881 static ssize_t disk_ro_show(struct device *dev,
882 struct device_attribute *attr, char *buf)
884 struct gendisk *disk = dev_to_disk(dev);
886 return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
889 ssize_t part_size_show(struct device *dev,
890 struct device_attribute *attr, char *buf)
892 return sprintf(buf, "%llu\n", bdev_nr_sectors(dev_to_bdev(dev)));
895 ssize_t part_stat_show(struct device *dev,
896 struct device_attribute *attr, char *buf)
898 struct block_device *bdev = dev_to_bdev(dev);
899 struct request_queue *q = bdev->bd_disk->queue;
900 struct disk_stats stat;
901 unsigned int inflight;
903 part_stat_read_all(bdev, &stat);
905 inflight = blk_mq_in_flight(q, bdev);
907 inflight = part_in_flight(bdev);
910 "%8lu %8lu %8llu %8u "
911 "%8lu %8lu %8llu %8u "
913 "%8lu %8lu %8llu %8u "
917 stat.merges[STAT_READ],
918 (unsigned long long)stat.sectors[STAT_READ],
919 (unsigned int)div_u64(stat.nsecs[STAT_READ], NSEC_PER_MSEC),
920 stat.ios[STAT_WRITE],
921 stat.merges[STAT_WRITE],
922 (unsigned long long)stat.sectors[STAT_WRITE],
923 (unsigned int)div_u64(stat.nsecs[STAT_WRITE], NSEC_PER_MSEC),
925 jiffies_to_msecs(stat.io_ticks),
926 (unsigned int)div_u64(stat.nsecs[STAT_READ] +
927 stat.nsecs[STAT_WRITE] +
928 stat.nsecs[STAT_DISCARD] +
929 stat.nsecs[STAT_FLUSH],
931 stat.ios[STAT_DISCARD],
932 stat.merges[STAT_DISCARD],
933 (unsigned long long)stat.sectors[STAT_DISCARD],
934 (unsigned int)div_u64(stat.nsecs[STAT_DISCARD], NSEC_PER_MSEC),
935 stat.ios[STAT_FLUSH],
936 (unsigned int)div_u64(stat.nsecs[STAT_FLUSH], NSEC_PER_MSEC));
939 ssize_t part_inflight_show(struct device *dev, struct device_attribute *attr,
942 struct block_device *bdev = dev_to_bdev(dev);
943 struct request_queue *q = bdev->bd_disk->queue;
944 unsigned int inflight[2];
947 blk_mq_in_flight_rw(q, bdev, inflight);
949 part_in_flight_rw(bdev, inflight);
951 return sprintf(buf, "%8u %8u\n", inflight[0], inflight[1]);
954 static ssize_t disk_capability_show(struct device *dev,
955 struct device_attribute *attr, char *buf)
957 struct gendisk *disk = dev_to_disk(dev);
959 return sprintf(buf, "%x\n", disk->flags);
962 static ssize_t disk_alignment_offset_show(struct device *dev,
963 struct device_attribute *attr,
966 struct gendisk *disk = dev_to_disk(dev);
968 return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
971 static ssize_t disk_discard_alignment_show(struct device *dev,
972 struct device_attribute *attr,
975 struct gendisk *disk = dev_to_disk(dev);
977 return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
980 static DEVICE_ATTR(range, 0444, disk_range_show, NULL);
981 static DEVICE_ATTR(ext_range, 0444, disk_ext_range_show, NULL);
982 static DEVICE_ATTR(removable, 0444, disk_removable_show, NULL);
983 static DEVICE_ATTR(hidden, 0444, disk_hidden_show, NULL);
984 static DEVICE_ATTR(ro, 0444, disk_ro_show, NULL);
985 static DEVICE_ATTR(size, 0444, part_size_show, NULL);
986 static DEVICE_ATTR(alignment_offset, 0444, disk_alignment_offset_show, NULL);
987 static DEVICE_ATTR(discard_alignment, 0444, disk_discard_alignment_show, NULL);
988 static DEVICE_ATTR(capability, 0444, disk_capability_show, NULL);
989 static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
990 static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
991 static DEVICE_ATTR(badblocks, 0644, disk_badblocks_show, disk_badblocks_store);
993 #ifdef CONFIG_FAIL_MAKE_REQUEST
994 ssize_t part_fail_show(struct device *dev,
995 struct device_attribute *attr, char *buf)
997 return sprintf(buf, "%d\n", dev_to_bdev(dev)->bd_make_it_fail);
1000 ssize_t part_fail_store(struct device *dev,
1001 struct device_attribute *attr,
1002 const char *buf, size_t count)
1006 if (count > 0 && sscanf(buf, "%d", &i) > 0)
1007 dev_to_bdev(dev)->bd_make_it_fail = i;
1012 static struct device_attribute dev_attr_fail =
1013 __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
1014 #endif /* CONFIG_FAIL_MAKE_REQUEST */
1016 #ifdef CONFIG_FAIL_IO_TIMEOUT
1017 static struct device_attribute dev_attr_fail_timeout =
1018 __ATTR(io-timeout-fail, 0644, part_timeout_show, part_timeout_store);
1021 static struct attribute *disk_attrs[] = {
1022 &dev_attr_range.attr,
1023 &dev_attr_ext_range.attr,
1024 &dev_attr_removable.attr,
1025 &dev_attr_hidden.attr,
1027 &dev_attr_size.attr,
1028 &dev_attr_alignment_offset.attr,
1029 &dev_attr_discard_alignment.attr,
1030 &dev_attr_capability.attr,
1031 &dev_attr_stat.attr,
1032 &dev_attr_inflight.attr,
1033 &dev_attr_badblocks.attr,
1034 &dev_attr_events.attr,
1035 &dev_attr_events_async.attr,
1036 &dev_attr_events_poll_msecs.attr,
1037 #ifdef CONFIG_FAIL_MAKE_REQUEST
1038 &dev_attr_fail.attr,
1040 #ifdef CONFIG_FAIL_IO_TIMEOUT
1041 &dev_attr_fail_timeout.attr,
1046 static umode_t disk_visible(struct kobject *kobj, struct attribute *a, int n)
1048 struct device *dev = container_of(kobj, typeof(*dev), kobj);
1049 struct gendisk *disk = dev_to_disk(dev);
1051 if (a == &dev_attr_badblocks.attr && !disk->bb)
1056 static struct attribute_group disk_attr_group = {
1057 .attrs = disk_attrs,
1058 .is_visible = disk_visible,
1061 static const struct attribute_group *disk_attr_groups[] = {
1067 * disk_release - releases all allocated resources of the gendisk
1068 * @dev: the device representing this disk
1070 * This function releases all allocated resources of the gendisk.
1072 * Drivers which used __device_add_disk() have a gendisk with a request_queue
1073 * assigned. Since the request_queue sits on top of the gendisk for these
1074 * drivers we also call blk_put_queue() for them, and we expect the
1075 * request_queue refcount to reach 0 at this point, and so the request_queue
1076 * will also be freed prior to the disk.
1078 * Context: can sleep
1080 static void disk_release(struct device *dev)
1082 struct gendisk *disk = dev_to_disk(dev);
1086 if (MAJOR(dev->devt) == BLOCK_EXT_MAJOR)
1087 blk_free_ext_minor(MINOR(dev->devt));
1088 disk_release_events(disk);
1089 kfree(disk->random);
1090 xa_destroy(&disk->part_tbl);
1091 if (test_bit(GD_QUEUE_REF, &disk->state) && disk->queue)
1092 blk_put_queue(disk->queue);
1093 iput(disk->part0->bd_inode); /* frees the disk */
1096 static int block_uevent(struct device *dev, struct kobj_uevent_env *env)
1098 struct gendisk *disk = dev_to_disk(dev);
1100 return add_uevent_var(env, "DISKSEQ=%llu", disk->diskseq);
1103 struct class block_class = {
1105 .dev_uevent = block_uevent,
1108 static char *block_devnode(struct device *dev, umode_t *mode,
1109 kuid_t *uid, kgid_t *gid)
1111 struct gendisk *disk = dev_to_disk(dev);
1113 if (disk->fops->devnode)
1114 return disk->fops->devnode(disk, mode);
1118 const struct device_type disk_type = {
1120 .groups = disk_attr_groups,
1121 .release = disk_release,
1122 .devnode = block_devnode,
1125 #ifdef CONFIG_PROC_FS
1127 * aggregate disk stat collector. Uses the same stats that the sysfs
1128 * entries do, above, but makes them available through one seq_file.
1130 * The output looks suspiciously like /proc/partitions with a bunch of
1133 static int diskstats_show(struct seq_file *seqf, void *v)
1135 struct gendisk *gp = v;
1136 struct block_device *hd;
1137 unsigned int inflight;
1138 struct disk_stats stat;
1142 if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
1143 seq_puts(seqf, "major minor name"
1144 " rio rmerge rsect ruse wio wmerge "
1145 "wsect wuse running use aveq"
1150 xa_for_each(&gp->part_tbl, idx, hd) {
1151 if (bdev_is_partition(hd) && !bdev_nr_sectors(hd))
1153 part_stat_read_all(hd, &stat);
1154 if (queue_is_mq(gp->queue))
1155 inflight = blk_mq_in_flight(gp->queue, hd);
1157 inflight = part_in_flight(hd);
1159 seq_printf(seqf, "%4d %7d %pg "
1166 MAJOR(hd->bd_dev), MINOR(hd->bd_dev), hd,
1167 stat.ios[STAT_READ],
1168 stat.merges[STAT_READ],
1169 stat.sectors[STAT_READ],
1170 (unsigned int)div_u64(stat.nsecs[STAT_READ],
1172 stat.ios[STAT_WRITE],
1173 stat.merges[STAT_WRITE],
1174 stat.sectors[STAT_WRITE],
1175 (unsigned int)div_u64(stat.nsecs[STAT_WRITE],
1178 jiffies_to_msecs(stat.io_ticks),
1179 (unsigned int)div_u64(stat.nsecs[STAT_READ] +
1180 stat.nsecs[STAT_WRITE] +
1181 stat.nsecs[STAT_DISCARD] +
1182 stat.nsecs[STAT_FLUSH],
1184 stat.ios[STAT_DISCARD],
1185 stat.merges[STAT_DISCARD],
1186 stat.sectors[STAT_DISCARD],
1187 (unsigned int)div_u64(stat.nsecs[STAT_DISCARD],
1189 stat.ios[STAT_FLUSH],
1190 (unsigned int)div_u64(stat.nsecs[STAT_FLUSH],
1199 static const struct seq_operations diskstats_op = {
1200 .start = disk_seqf_start,
1201 .next = disk_seqf_next,
1202 .stop = disk_seqf_stop,
1203 .show = diskstats_show
1206 static int __init proc_genhd_init(void)
1208 proc_create_seq("diskstats", 0, NULL, &diskstats_op);
1209 proc_create_seq("partitions", 0, NULL, &partitions_op);
1212 module_init(proc_genhd_init);
1213 #endif /* CONFIG_PROC_FS */
1215 dev_t part_devt(struct gendisk *disk, u8 partno)
1217 struct block_device *part;
1221 part = xa_load(&disk->part_tbl, partno);
1223 devt = part->bd_dev;
1229 dev_t blk_lookup_devt(const char *name, int partno)
1231 dev_t devt = MKDEV(0, 0);
1232 struct class_dev_iter iter;
1235 class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
1236 while ((dev = class_dev_iter_next(&iter))) {
1237 struct gendisk *disk = dev_to_disk(dev);
1239 if (strcmp(dev_name(dev), name))
1242 if (partno < disk->minors) {
1243 /* We need to return the right devno, even
1244 * if the partition doesn't exist yet.
1246 devt = MKDEV(MAJOR(dev->devt),
1247 MINOR(dev->devt) + partno);
1249 devt = part_devt(disk, partno);
1254 class_dev_iter_exit(&iter);
1258 struct gendisk *__alloc_disk_node(int minors, int node_id)
1260 struct gendisk *disk;
1262 disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);
1266 disk->part0 = bdev_alloc(disk, 0);
1270 disk->node_id = node_id;
1271 mutex_init(&disk->open_mutex);
1272 xa_init(&disk->part_tbl);
1273 if (xa_insert(&disk->part_tbl, 0, disk->part0, GFP_KERNEL))
1274 goto out_destroy_part_tbl;
1276 disk->minors = minors;
1277 rand_initialize_disk(disk);
1278 disk_to_dev(disk)->class = &block_class;
1279 disk_to_dev(disk)->type = &disk_type;
1280 device_initialize(disk_to_dev(disk));
1285 out_destroy_part_tbl:
1286 xa_destroy(&disk->part_tbl);
1287 iput(disk->part0->bd_inode);
1292 EXPORT_SYMBOL(__alloc_disk_node);
1294 struct gendisk *__blk_alloc_disk(int node)
1296 struct request_queue *q;
1297 struct gendisk *disk;
1299 q = blk_alloc_queue(node);
1303 disk = __alloc_disk_node(0, node);
1305 blk_cleanup_queue(q);
1311 EXPORT_SYMBOL(__blk_alloc_disk);
1314 * put_disk - decrements the gendisk refcount
1315 * @disk: the struct gendisk to decrement the refcount for
1317 * This decrements the refcount for the struct gendisk. When this reaches 0
1318 * we'll have disk_release() called.
1320 * Context: Any context, but the last reference must not be dropped from
1323 void put_disk(struct gendisk *disk)
1326 put_device(disk_to_dev(disk));
1328 EXPORT_SYMBOL(put_disk);
1331 * blk_cleanup_disk - shutdown a gendisk allocated by blk_alloc_disk
1332 * @disk: gendisk to shutdown
1334 * Mark the queue hanging off @disk DYING, drain all pending requests, then mark
1335 * the queue DEAD, destroy and put it and the gendisk structure.
1337 * Context: can sleep
1339 void blk_cleanup_disk(struct gendisk *disk)
1341 blk_cleanup_queue(disk->queue);
1344 EXPORT_SYMBOL(blk_cleanup_disk);
1346 static void set_disk_ro_uevent(struct gendisk *gd, int ro)
1348 char event[] = "DISK_RO=1";
1349 char *envp[] = { event, NULL };
1353 kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
1357 * set_disk_ro - set a gendisk read-only
1358 * @disk: gendisk to operate on
1359 * @read_only: %true to set the disk read-only, %false set the disk read/write
1361 * This function is used to indicate whether a given disk device should have its
1362 * read-only flag set. set_disk_ro() is typically used by device drivers to
1363 * indicate whether the underlying physical device is write-protected.
1365 void set_disk_ro(struct gendisk *disk, bool read_only)
1368 if (test_and_set_bit(GD_READ_ONLY, &disk->state))
1371 if (!test_and_clear_bit(GD_READ_ONLY, &disk->state))
1374 set_disk_ro_uevent(disk, read_only);
1376 EXPORT_SYMBOL(set_disk_ro);
1378 int bdev_read_only(struct block_device *bdev)
1380 return bdev->bd_read_only || get_disk_ro(bdev->bd_disk);
1382 EXPORT_SYMBOL(bdev_read_only);
1384 void inc_diskseq(struct gendisk *disk)
1386 disk->diskseq = atomic64_inc_return(&diskseq);