blob: bb29a68e1d67662533653d8e74742554ae09b39a [file] [log] [blame]
Christoph Hellwig3dcf60bc2019-04-30 14:42:43 -04001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * gendisk handling
Christoph Hellwig7b51e702020-12-10 08:55:44 +01004 *
5 * Portions Copyright (C) 2020 Christoph Hellwig
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
7
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/module.h>
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01009#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/fs.h>
Andrew Mortonb446b602007-02-20 13:57:48 -080011#include <linux/kdev_t.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/kernel.h>
13#include <linux/blkdev.h>
Tejun Heo66114ca2015-05-22 17:13:32 -040014#include <linux/backing-dev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/init.h>
16#include <linux/spinlock.h>
Alexey Dobriyanf5009752008-10-04 23:53:21 +040017#include <linux/proc_fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/seq_file.h>
19#include <linux/slab.h>
20#include <linux/kmod.h>
Christoph Hellwigb81e0c22021-09-20 14:33:25 +020021#include <linux/major.h>
Jes Sorensen58383af2006-02-06 14:12:43 -080022#include <linux/mutex.h>
Tejun Heobcce3de2008-08-25 19:47:22 +090023#include <linux/idr.h>
Tejun Heo77ea8872010-12-08 20:57:37 +010024#include <linux/log2.h>
Ming Lei25e823c2013-02-22 16:34:13 -080025#include <linux/pm_runtime.h>
Vishal Verma99e66082016-01-09 08:36:51 -080026#include <linux/badblocks.h>
Christoph Hellwig82d981d2021-11-23 19:53:12 +010027#include <linux/part_stat.h>
Yu Kuaidd7de372023-06-10 10:20:03 +080028#include <linux/blktrace_api.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Yu Kuaidd7de372023-06-10 10:20:03 +080030#include "blk-throttle.h"
Adrian Bunkff889722008-03-04 11:23:45 +010031#include "blk.h"
Christoph Hellwig2aa77452021-11-23 19:53:08 +010032#include "blk-mq-sched.h"
Christoph Hellwig8e141f92021-09-29 09:12:40 +020033#include "blk-rq-qos.h"
Ming Lei10596992022-03-08 06:51:55 +010034#include "blk-cgroup.h"
Adrian Bunkff889722008-03-04 11:23:45 +010035
Christoph Hellwig31eb6182020-03-25 16:48:35 +010036static struct kobject *block_depr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Matteo Crocecf179942021-07-13 01:05:25 +020038/*
39 * Unique, monotonically increasing sequential number associated with block
40 * devices instances (i.e. incremented each time a device is attached).
41 * Associating uevents with block devices in userspace is difficult and racy:
42 * the uevent netlink socket is lossy, and on slow and overloaded systems has
43 * a very high latency.
44 * Block devices do not have exclusive owners in userspace, any process can set
45 * one up (e.g. loop devices). Moreover, device names can be reused (e.g. loop0
46 * can be reused again and again).
47 * A userspace process setting up a block device and watching for its events
48 * cannot thus reliably tell whether an event relates to the device it just set
49 * up or another earlier instance with the same name.
50 * This sequential number allows userspace processes to solve this problem, and
51 * uniquely associate an uevent to the lifetime to a device.
52 */
53static atomic64_t diskseq;
54
Tejun Heobcce3de2008-08-25 19:47:22 +090055/* for extended dynamic devt allocation, currently only one major is used */
Tejun Heoce23bba2013-02-27 17:03:56 -080056#define NR_EXT_DEVT (1 << MINORBITS)
Christoph Hellwig22ae8ce2020-11-26 09:23:26 +010057static DEFINE_IDA(ext_devt_ida);
Tejun Heobcce3de2008-08-25 19:47:22 +090058
Christoph Hellwiga7824832020-11-26 18:43:37 +010059void set_capacity(struct gendisk *disk, sector_t sectors)
60{
Damien Le Moal83794362023-04-24 22:13:18 +090061 bdev_set_nr_sectors(disk->part0, sectors);
Christoph Hellwiga7824832020-11-26 18:43:37 +010062}
63EXPORT_SYMBOL(set_capacity);
64
Balbir Singhe598a722020-03-13 05:30:05 +000065/*
Christoph Hellwig449f4ec2020-11-16 15:56:56 +010066 * Set disk capacity and notify if the size is not currently zero and will not
67 * be set to zero. Returns true if a uevent was sent, otherwise false.
Balbir Singhe598a722020-03-13 05:30:05 +000068 */
Christoph Hellwig449f4ec2020-11-16 15:56:56 +010069bool set_capacity_and_notify(struct gendisk *disk, sector_t size)
Balbir Singhe598a722020-03-13 05:30:05 +000070{
71 sector_t capacity = get_capacity(disk);
Christoph Hellwiga7824832020-11-26 18:43:37 +010072 char *envp[] = { "RESIZE=1", NULL };
Balbir Singhe598a722020-03-13 05:30:05 +000073
74 set_capacity(disk, size);
Balbir Singhe598a722020-03-13 05:30:05 +000075
Christoph Hellwiga7824832020-11-26 18:43:37 +010076 /*
77 * Only print a message and send a uevent if the gendisk is user visible
78 * and alive. This avoids spamming the log and udev when setting the
79 * initial capacity during probing.
80 */
81 if (size == capacity ||
Christoph Hellwig50b4aec2021-08-09 08:40:28 +020082 !disk_live(disk) ||
83 (disk->flags & GENHD_FL_HIDDEN))
Christoph Hellwiga7824832020-11-26 18:43:37 +010084 return false;
Balbir Singhe598a722020-03-13 05:30:05 +000085
Christoph Hellwiga7824832020-11-26 18:43:37 +010086 pr_info("%s: detected capacity change from %lld to %lld\n",
Ming Lei452c0bf2021-02-23 16:50:15 +080087 disk->disk_name, capacity, size);
Christoph Hellwig7e890c32020-11-12 17:50:04 +010088
Christoph Hellwiga7824832020-11-26 18:43:37 +010089 /*
90 * Historically we did not send a uevent for changes to/from an empty
91 * device.
92 */
93 if (!capacity || !size)
94 return false;
95 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
96 return true;
Balbir Singhe598a722020-03-13 05:30:05 +000097}
Christoph Hellwig449f4ec2020-11-16 15:56:56 +010098EXPORT_SYMBOL_GPL(set_capacity_and_notify);
Balbir Singhe598a722020-03-13 05:30:05 +000099
Christoph Hellwig0d021292020-11-27 16:43:51 +0100100static void part_stat_read_all(struct block_device *part,
101 struct disk_stats *stat)
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300102{
103 int cpu;
104
105 memset(stat, 0, sizeof(struct disk_stats));
106 for_each_possible_cpu(cpu) {
Christoph Hellwig0d021292020-11-27 16:43:51 +0100107 struct disk_stats *ptr = per_cpu_ptr(part->bd_stats, cpu);
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300108 int group;
109
110 for (group = 0; group < NR_STAT_GROUPS; group++) {
111 stat->nsecs[group] += ptr->nsecs[group];
112 stat->sectors[group] += ptr->sectors[group];
113 stat->ios[group] += ptr->ios[group];
114 stat->merges[group] += ptr->merges[group];
115 }
116
117 stat->io_ticks += ptr->io_ticks;
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300118 }
119}
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300120
Christoph Hellwig8446fe92020-11-24 09:36:54 +0100121static unsigned int part_in_flight(struct block_device *part)
Jens Axboef299b7c2017-08-08 17:51:45 -0600122{
Christoph Hellwigb2f609e2020-05-13 12:49:33 +0200123 unsigned int inflight = 0;
Mikulas Patocka1226b8d2018-12-06 11:41:20 -0500124 int cpu;
125
Mikulas Patocka1226b8d2018-12-06 11:41:20 -0500126 for_each_possible_cpu(cpu) {
Mikulas Patockae016b782018-12-06 11:41:21 -0500127 inflight += part_stat_local_read_cpu(part, in_flight[0], cpu) +
128 part_stat_local_read_cpu(part, in_flight[1], cpu);
Mikulas Patocka1226b8d2018-12-06 11:41:20 -0500129 }
Mikulas Patockae016b782018-12-06 11:41:21 -0500130 if ((int)inflight < 0)
131 inflight = 0;
Mikulas Patocka1226b8d2018-12-06 11:41:20 -0500132
Mikulas Patockae016b782018-12-06 11:41:21 -0500133 return inflight;
Jens Axboef299b7c2017-08-08 17:51:45 -0600134}
135
Christoph Hellwig8446fe92020-11-24 09:36:54 +0100136static void part_in_flight_rw(struct block_device *part,
137 unsigned int inflight[2])
Omar Sandovalbf0ddab2018-04-26 00:21:59 -0700138{
Mikulas Patocka1226b8d2018-12-06 11:41:20 -0500139 int cpu;
140
Mikulas Patocka1226b8d2018-12-06 11:41:20 -0500141 inflight[0] = 0;
142 inflight[1] = 0;
143 for_each_possible_cpu(cpu) {
144 inflight[0] += part_stat_local_read_cpu(part, in_flight[0], cpu);
145 inflight[1] += part_stat_local_read_cpu(part, in_flight[1], cpu);
146 }
147 if ((int)inflight[0] < 0)
148 inflight[0] = 0;
149 if ((int)inflight[1] < 0)
150 inflight[1] = 0;
Omar Sandovalbf0ddab2018-04-26 00:21:59 -0700151}
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153/*
154 * Can be deleted altogether. Later.
155 *
156 */
Logan Gunthorpe133d55c2017-06-16 17:48:21 -0600157#define BLKDEV_MAJOR_HASH_SIZE 255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158static struct blk_major_name {
159 struct blk_major_name *next;
160 int major;
161 char name[16];
Christoph Hellwigfbdee712022-01-04 08:16:47 +0100162#ifdef CONFIG_BLOCK_LEGACY_AUTOLOAD
Christoph Hellwiga160c612020-10-29 15:58:28 +0100163 void (*probe)(dev_t devt);
Christoph Hellwigfbdee712022-01-04 08:16:47 +0100164#endif
Joe Korty68eef3b2006-03-31 02:30:32 -0800165} *major_names[BLKDEV_MAJOR_HASH_SIZE];
Christoph Hellwige49fbbb2020-10-29 15:58:26 +0100166static DEFINE_MUTEX(major_names_lock);
Tetsuo Handadfbb3402021-09-07 20:52:13 +0900167static DEFINE_SPINLOCK(major_names_spinlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
169/* index in the above - for now: assume no multimajor ranges */
Yang Zhange61eb2e2010-12-17 09:00:18 +0100170static inline int major_to_index(unsigned major)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
Joe Korty68eef3b2006-03-31 02:30:32 -0800172 return major % BLKDEV_MAJOR_HASH_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173}
174
Joe Korty68eef3b2006-03-31 02:30:32 -0800175#ifdef CONFIG_PROC_FS
Tejun Heocf771cb2008-09-03 09:01:09 +0200176void blkdev_show(struct seq_file *seqf, off_t offset)
Neil Horman7170be52006-01-14 13:20:38 -0800177{
Joe Korty68eef3b2006-03-31 02:30:32 -0800178 struct blk_major_name *dp;
Neil Horman7170be52006-01-14 13:20:38 -0800179
Tetsuo Handadfbb3402021-09-07 20:52:13 +0900180 spin_lock(&major_names_spinlock);
Logan Gunthorpe133d55c2017-06-16 17:48:21 -0600181 for (dp = major_names[major_to_index(offset)]; dp; dp = dp->next)
182 if (dp->major == offset)
Tejun Heocf771cb2008-09-03 09:01:09 +0200183 seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
Tetsuo Handadfbb3402021-09-07 20:52:13 +0900184 spin_unlock(&major_names_spinlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185}
Joe Korty68eef3b2006-03-31 02:30:32 -0800186#endif /* CONFIG_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Márton Németh9e8c0bc2009-02-20 08:12:51 +0100188/**
Christoph Hellwige2b6b302020-11-14 18:08:21 +0100189 * __register_blkdev - register a new block device
Márton Németh9e8c0bc2009-02-20 08:12:51 +0100190 *
Srivatsa S. Bhatf33ff112018-02-05 18:25:27 -0800191 * @major: the requested major device number [1..BLKDEV_MAJOR_MAX-1]. If
192 * @major = 0, try to allocate any unused major number.
Márton Németh9e8c0bc2009-02-20 08:12:51 +0100193 * @name: the name of the new block device as a zero terminated string
Luis Chamberlain26e06f52021-11-03 16:04:34 -0700194 * @probe: pre-devtmpfs / pre-udev callback used to create disks when their
195 * pre-created device node is accessed. When a probe call uses
196 * add_disk() and it fails the driver must cleanup resources. This
197 * interface may soon be removed.
Márton Németh9e8c0bc2009-02-20 08:12:51 +0100198 *
199 * The @name must be unique within the system.
200 *
mchehab@s-opensource.com0e056eb2017-03-30 17:11:36 -0300201 * The return value depends on the @major input parameter:
202 *
Srivatsa S. Bhatf33ff112018-02-05 18:25:27 -0800203 * - if a major device number was requested in range [1..BLKDEV_MAJOR_MAX-1]
204 * then the function returns zero on success, or a negative error code
mchehab@s-opensource.com0e056eb2017-03-30 17:11:36 -0300205 * - if any unused major number was requested with @major = 0 parameter
Márton Németh9e8c0bc2009-02-20 08:12:51 +0100206 * then the return value is the allocated major number in range
Srivatsa S. Bhatf33ff112018-02-05 18:25:27 -0800207 * [1..BLKDEV_MAJOR_MAX-1] or a negative error code otherwise
208 *
209 * See Documentation/admin-guide/devices.txt for the list of allocated
210 * major numbers.
Christoph Hellwige2b6b302020-11-14 18:08:21 +0100211 *
212 * Use register_blkdev instead for any new code.
Márton Németh9e8c0bc2009-02-20 08:12:51 +0100213 */
Christoph Hellwiga160c612020-10-29 15:58:28 +0100214int __register_blkdev(unsigned int major, const char *name,
215 void (*probe)(dev_t devt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
217 struct blk_major_name **n, *p;
218 int index, ret = 0;
219
Christoph Hellwige49fbbb2020-10-29 15:58:26 +0100220 mutex_lock(&major_names_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 /* temporary */
223 if (major == 0) {
224 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
225 if (major_names[index] == NULL)
226 break;
227 }
228
229 if (index == 0) {
Keyur Pateldfc76d12019-02-17 10:21:56 -0500230 printk("%s: failed to get major for %s\n",
231 __func__, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 ret = -EBUSY;
233 goto out;
234 }
235 major = index;
236 ret = major;
237 }
238
Logan Gunthorpe133d55c2017-06-16 17:48:21 -0600239 if (major >= BLKDEV_MAJOR_MAX) {
Keyur Pateldfc76d12019-02-17 10:21:56 -0500240 pr_err("%s: major requested (%u) is greater than the maximum (%u) for %s\n",
241 __func__, major, BLKDEV_MAJOR_MAX-1, name);
Logan Gunthorpe133d55c2017-06-16 17:48:21 -0600242
243 ret = -EINVAL;
244 goto out;
245 }
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
248 if (p == NULL) {
249 ret = -ENOMEM;
250 goto out;
251 }
252
253 p->major = major;
Christoph Hellwigfbdee712022-01-04 08:16:47 +0100254#ifdef CONFIG_BLOCK_LEGACY_AUTOLOAD
Christoph Hellwiga160c612020-10-29 15:58:28 +0100255 p->probe = probe;
Christoph Hellwigfbdee712022-01-04 08:16:47 +0100256#endif
Azeem Shaikh20d09972023-05-30 15:56:08 +0000257 strscpy(p->name, name, sizeof(p->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 p->next = NULL;
259 index = major_to_index(major);
260
Tetsuo Handadfbb3402021-09-07 20:52:13 +0900261 spin_lock(&major_names_spinlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 for (n = &major_names[index]; *n; n = &(*n)->next) {
263 if ((*n)->major == major)
264 break;
265 }
266 if (!*n)
267 *n = p;
268 else
269 ret = -EBUSY;
Tetsuo Handadfbb3402021-09-07 20:52:13 +0900270 spin_unlock(&major_names_spinlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
272 if (ret < 0) {
Srivatsa S. Bhatf33ff112018-02-05 18:25:27 -0800273 printk("register_blkdev: cannot get major %u for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 major, name);
275 kfree(p);
276 }
277out:
Christoph Hellwige49fbbb2020-10-29 15:58:26 +0100278 mutex_unlock(&major_names_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return ret;
280}
Christoph Hellwiga160c612020-10-29 15:58:28 +0100281EXPORT_SYMBOL(__register_blkdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Akinobu Mitaf4480242007-07-17 04:03:47 -0700283void unregister_blkdev(unsigned int major, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284{
285 struct blk_major_name **n;
286 struct blk_major_name *p = NULL;
287 int index = major_to_index(major);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Christoph Hellwige49fbbb2020-10-29 15:58:26 +0100289 mutex_lock(&major_names_lock);
Tetsuo Handadfbb3402021-09-07 20:52:13 +0900290 spin_lock(&major_names_spinlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 for (n = &major_names[index]; *n; n = &(*n)->next)
292 if ((*n)->major == major)
293 break;
Akinobu Mita294462a2007-07-17 04:03:45 -0700294 if (!*n || strcmp((*n)->name, name)) {
295 WARN_ON(1);
Akinobu Mita294462a2007-07-17 04:03:45 -0700296 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 p = *n;
298 *n = p->next;
299 }
Tetsuo Handadfbb3402021-09-07 20:52:13 +0900300 spin_unlock(&major_names_spinlock);
Christoph Hellwige49fbbb2020-10-29 15:58:26 +0100301 mutex_unlock(&major_names_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 kfree(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303}
304
305EXPORT_SYMBOL(unregister_blkdev);
306
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200307int blk_alloc_ext_minor(void)
Tejun Heobcce3de2008-08-25 19:47:22 +0900308{
Tejun Heobab998d2013-02-27 17:03:57 -0800309 int idx;
Tejun Heobcce3de2008-08-25 19:47:22 +0900310
Christophe JAILLETd1868322022-03-26 15:50:46 +0100311 idx = ida_alloc_range(&ext_devt_ida, 0, NR_EXT_DEVT - 1, GFP_KERNEL);
Christoph Hellwigc4b2b7d2021-08-24 09:52:16 +0200312 if (idx == -ENOSPC)
313 return -EBUSY;
314 return idx;
Tejun Heobcce3de2008-08-25 19:47:22 +0900315}
316
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200317void blk_free_ext_minor(unsigned int minor)
Tejun Heobcce3de2008-08-25 19:47:22 +0900318{
Christoph Hellwigc4b2b7d2021-08-24 09:52:16 +0200319 ida_free(&ext_devt_ida, minor);
Yufen Yu6fcc44d2019-04-02 20:06:34 +0800320}
321
Christoph Hellwigbc359d02021-01-24 11:02:39 +0100322void disk_uevent(struct gendisk *disk, enum kobject_action action)
323{
Christoph Hellwigbc359d02021-01-24 11:02:39 +0100324 struct block_device *part;
Christoph Hellwig32121352021-04-06 08:23:02 +0200325 unsigned long idx;
Christoph Hellwigbc359d02021-01-24 11:02:39 +0100326
Christoph Hellwig32121352021-04-06 08:23:02 +0200327 rcu_read_lock();
328 xa_for_each(&disk->part_tbl, idx, part) {
329 if (bdev_is_partition(part) && !bdev_nr_sectors(part))
330 continue;
Christoph Hellwig498dcc12021-07-01 10:16:37 +0200331 if (!kobject_get_unless_zero(&part->bd_device.kobj))
Christoph Hellwig32121352021-04-06 08:23:02 +0200332 continue;
333
334 rcu_read_unlock();
Christoph Hellwigbc359d02021-01-24 11:02:39 +0100335 kobject_uevent(bdev_kobj(part), action);
Christoph Hellwig498dcc12021-07-01 10:16:37 +0200336 put_device(&part->bd_device);
Christoph Hellwig32121352021-04-06 08:23:02 +0200337 rcu_read_lock();
338 }
339 rcu_read_unlock();
Christoph Hellwigbc359d02021-01-24 11:02:39 +0100340}
341EXPORT_SYMBOL_GPL(disk_uevent);
342
Christoph Hellwig05bdb992023-06-08 13:02:55 +0200343int disk_scan_partitions(struct gendisk *disk, blk_mode_t mode)
Christoph Hellwig9301fe72020-09-21 09:19:46 +0200344{
Christian Brauner190f6762024-01-23 14:26:20 +0100345 struct file *file;
Yu Kuaie5cfefa2023-02-17 10:22:00 +0800346 int ret = 0;
Christoph Hellwig9301fe72020-09-21 09:19:46 +0200347
Christoph Hellwig9f18db52021-11-22 14:06:23 +0100348 if (disk->flags & (GENHD_FL_NO_PART | GENHD_FL_HIDDEN))
Christoph Hellwige16e5062021-11-22 14:06:16 +0100349 return -EINVAL;
Christoph Hellwigb9684a72022-05-27 07:58:06 +0200350 if (test_bit(GD_SUPPRESS_PART_SCAN, &disk->state))
351 return -EINVAL;
Christoph Hellwige16e5062021-11-22 14:06:16 +0100352 if (disk->open_partitions)
353 return -EBUSY;
Christoph Hellwig9301fe72020-09-21 09:19:46 +0200354
Yu Kuaie5cfefa2023-02-17 10:22:00 +0800355 /*
356 * If the device is opened exclusively by current thread already, it's
357 * safe to scan partitons, otherwise, use bd_prepare_to_claim() to
358 * synchronize with other exclusive openers and other partition
359 * scanners.
360 */
Christoph Hellwig05bdb992023-06-08 13:02:55 +0200361 if (!(mode & BLK_OPEN_EXCL)) {
Christoph Hellwig0718afd2023-06-01 11:44:52 +0200362 ret = bd_prepare_to_claim(disk->part0, disk_scan_partitions,
363 NULL);
Yu Kuaie5cfefa2023-02-17 10:22:00 +0800364 if (ret)
365 return ret;
366 }
367
Yu Kuai37230912023-03-22 11:59:26 +0800368 set_bit(GD_NEED_PART_SCAN, &disk->state);
Christian Brauner190f6762024-01-23 14:26:20 +0100369 file = bdev_file_open_by_dev(disk_devt(disk), mode & ~BLK_OPEN_EXCL,
370 NULL, NULL);
371 if (IS_ERR(file))
372 ret = PTR_ERR(file);
Yu Kuaie5cfefa2023-02-17 10:22:00 +0800373 else
Christian Brauner190f6762024-01-23 14:26:20 +0100374 fput(file);
Yu Kuaie5cfefa2023-02-17 10:22:00 +0800375
Yu Kuai37230912023-03-22 11:59:26 +0800376 /*
377 * If blkdev_get_by_dev() failed early, GD_NEED_PART_SCAN is still set,
378 * and this will cause that re-assemble partitioned raid device will
379 * creat partition for underlying disk.
380 */
381 clear_bit(GD_NEED_PART_SCAN, &disk->state);
Christoph Hellwig05bdb992023-06-08 13:02:55 +0200382 if (!(mode & BLK_OPEN_EXCL))
Yu Kuaie5cfefa2023-02-17 10:22:00 +0800383 bd_abort_claiming(disk->part0, disk_scan_partitions);
384 return ret;
Christoph Hellwig9301fe72020-09-21 09:19:46 +0200385}
386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387/**
Christoph Hellwigd1254a82021-08-04 11:41:47 +0200388 * device_add_disk - add disk information to kernel list
Dan Williamse63a46b2016-06-15 18:17:27 -0700389 * @parent: parent device for the disk
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 * @disk: per-device partitioning information
Hannes Reineckefef912b2018-09-28 08:17:19 +0200391 * @groups: Additional per-device sysfs groups
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 *
393 * This function registers the partitioning information in @disk
394 * with the kernel.
395 */
Luis Chamberlain278167f2021-11-09 16:29:49 -0800396int __must_check device_add_disk(struct device *parent, struct gendisk *disk,
397 const struct attribute_group **groups)
Christoph Hellwigd1254a82021-08-04 11:41:47 +0200398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399{
Christoph Hellwig52b85902021-08-18 16:45:33 +0200400 struct device *ddev = disk_to_dev(disk);
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200401 int ret;
Peter Zijlstracf0ca9f2008-04-30 00:54:32 -0700402
Ming Lei69fe0f22022-03-04 21:08:03 -0500403 /* Only makes sense for bio-based to set ->poll_bio */
404 if (queue_is_mq(disk->queue) && disk->fops->poll_bio)
405 return -EINVAL;
406
Damien Le Moal737eb782019-09-05 18:51:33 +0900407 /*
408 * The disk queue should now be all set with enough information about
409 * the device for the elevator code to pick an adequate default
410 * elevator if one is needed, that is, for devices requesting queue
411 * registration.
412 */
Christoph Hellwigd1254a82021-08-04 11:41:47 +0200413 elevator_init_mq(disk->queue);
Damien Le Moal737eb782019-09-05 18:51:33 +0900414
Jens Axboe9f4107b2023-04-14 07:32:02 -0600415 /* Mark bdev as having a submit_bio, if needed */
416 disk->part0->bd_has_submit_bio = disk->fops->submit_bio != NULL;
417
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200418 /*
419 * If the driver provides an explicit major number it also must provide
420 * the number of minors numbers supported, and those will be used to
421 * setup the gendisk.
422 * Otherwise just allocate the device numbers for both the whole device
423 * and all partitions from the extended dev_t space.
Tejun Heo3e1a7ff2008-08-25 19:56:17 +0900424 */
Yu Kuai02341a02022-10-22 10:16:15 +0800425 ret = -EINVAL;
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200426 if (disk->major) {
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200427 if (WARN_ON(!disk->minors))
Yu Kuai02341a02022-10-22 10:16:15 +0800428 goto out_exit_elevator;
Christoph Hellwig2e3c73f2021-05-21 07:50:52 +0200429
430 if (disk->minors > DISK_MAX_PARTS) {
431 pr_err("block: can't allocate more than %d partitions\n",
432 DISK_MAX_PARTS);
433 disk->minors = DISK_MAX_PARTS;
434 }
Li Nan4c434392023-12-19 15:59:42 +0800435 if (disk->first_minor > MINORMASK ||
436 disk->minors > MINORMASK + 1 ||
437 disk->first_minor + disk->minors > MINORMASK + 1)
Yu Kuai02341a02022-10-22 10:16:15 +0800438 goto out_exit_elevator;
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200439 } else {
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200440 if (WARN_ON(disk->minors))
Yu Kuai02341a02022-10-22 10:16:15 +0800441 goto out_exit_elevator;
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200442
443 ret = blk_alloc_ext_minor();
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200444 if (ret < 0)
Yu Kuai02341a02022-10-22 10:16:15 +0800445 goto out_exit_elevator;
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200446 disk->major = BLOCK_EXT_MAJOR;
Christoph Hellwig539711d2021-08-24 09:52:15 +0200447 disk->first_minor = ret;
Christoph Hellwig7c3f8282021-05-21 07:50:51 +0200448 }
Tejun Heo3e1a7ff2008-08-25 19:56:17 +0900449
Christoph Hellwig52b85902021-08-18 16:45:33 +0200450 /* delay uevents, until we scanned partition table */
451 dev_set_uevent_suppress(ddev, 1);
452
453 ddev->parent = parent;
454 ddev->groups = groups;
455 dev_set_name(ddev, "%s", disk->disk_name);
Christoph Hellwig8235b5c2021-08-18 16:45:34 +0200456 if (!(disk->flags & GENHD_FL_HIDDEN))
457 ddev->devt = MKDEV(disk->major, disk->first_minor);
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200458 ret = device_add(ddev);
459 if (ret)
Christoph Hellwig99d86902021-12-21 17:18:51 +0100460 goto out_free_ext_minor;
461
462 ret = disk_alloc_events(disk);
463 if (ret)
464 goto out_device_del;
465
Greg Kroah-Hartman721da5c2023-02-23 08:33:26 +0100466 ret = sysfs_create_link(block_depr, &ddev->kobj,
467 kobject_name(&ddev->kobj));
468 if (ret)
469 goto out_device_del;
Christoph Hellwig52b85902021-08-18 16:45:33 +0200470
471 /*
472 * avoid probable deadlock caused by allocating memory with
473 * GFP_KERNEL in runtime_resume callback of its all ancestor
474 * devices
475 */
476 pm_runtime_set_memalloc_noio(ddev, true);
477
478 disk->part0->bd_holder_dir =
479 kobject_create_and_add("holders", &ddev->kobj);
Luis Chamberlainfe7d0642021-11-03 09:40:23 -0700480 if (!disk->part0->bd_holder_dir) {
481 ret = -ENOMEM;
Thomas Weißschuhff53cd52023-03-18 17:36:25 +0000482 goto out_del_block_link;
Luis Chamberlainfe7d0642021-11-03 09:40:23 -0700483 }
Christoph Hellwig52b85902021-08-18 16:45:33 +0200484 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
Luis Chamberlainfe7d0642021-11-03 09:40:23 -0700485 if (!disk->slave_dir) {
486 ret = -ENOMEM;
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200487 goto out_put_holder_dir;
Luis Chamberlainfe7d0642021-11-03 09:40:23 -0700488 }
Christoph Hellwig52b85902021-08-18 16:45:33 +0200489
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200490 ret = blk_register_queue(disk);
491 if (ret)
492 goto out_put_slave_dir;
Christoph Hellwig75f4dca2021-08-18 16:45:37 +0200493
Christoph Hellwig9f18db52021-11-22 14:06:23 +0100494 if (!(disk->flags & GENHD_FL_HIDDEN)) {
Christoph Hellwig8235b5c2021-08-18 16:45:34 +0200495 ret = bdi_register(disk->bdi, "%u:%u",
496 disk->major, disk->first_minor);
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200497 if (ret)
498 goto out_unregister_queue;
Christoph Hellwig8235b5c2021-08-18 16:45:34 +0200499 bdi_set_owner(disk->bdi, ddev);
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200500 ret = sysfs_create_link(&ddev->kobj,
501 &disk->bdi->dev->kobj, "bdi");
502 if (ret)
503 goto out_unregister_bdi;
Christoph Hellwig8235b5c2021-08-18 16:45:34 +0200504
Yu Kuaie5cfefa2023-02-17 10:22:00 +0800505 /* Make sure the first partition scan will be proceed */
506 if (get_capacity(disk) && !(disk->flags & GENHD_FL_NO_PART) &&
507 !test_bit(GD_SUPPRESS_PART_SCAN, &disk->state))
508 set_bit(GD_NEED_PART_SCAN, &disk->state);
509
Christoph Hellwig9d5ee672021-08-18 16:45:35 +0200510 bdev_add(disk->part0, ddev->devt);
Christoph Hellwige16e5062021-11-22 14:06:16 +0100511 if (get_capacity(disk))
Christoph Hellwig05bdb992023-06-08 13:02:55 +0200512 disk_scan_partitions(disk, BLK_OPEN_READ);
Christoph Hellwig52b85902021-08-18 16:45:33 +0200513
514 /*
515 * Announce the disk and partitions after all partitions are
Christoph Hellwig8235b5c2021-08-18 16:45:34 +0200516 * created. (for hidden disks uevents remain suppressed forever)
Christoph Hellwig52b85902021-08-18 16:45:33 +0200517 */
518 dev_set_uevent_suppress(ddev, 0);
519 disk_uevent(disk, KOBJ_ADD);
Christoph Hellwiga0a63142022-10-10 15:18:57 +0200520 } else {
521 /*
522 * Even if the block_device for a hidden gendisk is not
523 * registered, it needs to have a valid bd_dev so that the
524 * freeing of the dynamic major works.
525 */
526 disk->part0->bd_dev = MKDEV(disk->major, disk->first_minor);
Christoph Hellwig52b85902021-08-18 16:45:33 +0200527 }
528
Christoph Hellwig75f4dca2021-08-18 16:45:37 +0200529 disk_update_readahead(disk);
Tejun Heo77ea8872010-12-08 20:57:37 +0100530 disk_add_events(disk);
Christoph Hellwig76792052022-02-15 10:45:10 +0100531 set_bit(GD_ADDED, &disk->state);
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200532 return 0;
533
534out_unregister_bdi:
535 if (!(disk->flags & GENHD_FL_HIDDEN))
536 bdi_unregister(disk->bdi);
537out_unregister_queue:
538 blk_unregister_queue(disk);
Chen Zhongjinfa81cba2022-10-29 15:13:55 +0800539 rq_qos_exit(disk->queue);
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200540out_put_slave_dir:
541 kobject_put(disk->slave_dir);
Christoph Hellwigd90db3b2022-11-15 22:10:45 +0800542 disk->slave_dir = NULL;
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200543out_put_holder_dir:
544 kobject_put(disk->part0->bd_holder_dir);
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200545out_del_block_link:
Greg Kroah-Hartman721da5c2023-02-23 08:33:26 +0100546 sysfs_remove_link(block_depr, dev_name(ddev));
Li Nan5fa3d1a2023-12-11 15:53:56 +0800547 pm_runtime_set_memalloc_noio(ddev, false);
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200548out_device_del:
549 device_del(ddev);
Luis Chamberlain83cbce92021-08-18 16:45:40 +0200550out_free_ext_minor:
551 if (disk->major == BLOCK_EXT_MAJOR)
552 blk_free_ext_minor(disk->first_minor);
Yu Kuai02341a02022-10-22 10:16:15 +0800553out_exit_elevator:
554 if (disk->queue->elevator)
555 elevator_exit(disk->queue);
Luis Chamberlain278167f2021-11-09 16:29:49 -0800556 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557}
Dan Williamse63a46b2016-06-15 18:17:27 -0700558EXPORT_SYMBOL(device_add_disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Christoph Hellwigd8530de2023-08-11 12:08:25 +0200560static void blk_report_disk_dead(struct gendisk *disk, bool surprise)
Christoph Hellwigf55e0172023-06-01 11:44:53 +0200561{
562 struct block_device *bdev;
563 unsigned long idx;
564
Christian Braunerf6103332023-10-17 20:48:22 +0200565 /*
566 * On surprise disk removal, bdev_mark_dead() may call into file
567 * systems below. Make it clear that we're expecting to not hold
568 * disk->open_mutex.
569 */
570 lockdep_assert_not_held(&disk->open_mutex);
571
Christoph Hellwigf55e0172023-06-01 11:44:53 +0200572 rcu_read_lock();
573 xa_for_each(&disk->part_tbl, idx, bdev) {
574 if (!kobject_get_unless_zero(&bdev->bd_device.kobj))
575 continue;
576 rcu_read_unlock();
577
Christoph Hellwigd8530de2023-08-11 12:08:25 +0200578 bdev_mark_dead(bdev, surprise);
Christoph Hellwigf55e0172023-06-01 11:44:53 +0200579
580 put_device(&bdev->bd_device);
581 rcu_read_lock();
582 }
583 rcu_read_unlock();
584}
585
Christoph Hellwigd8530de2023-08-11 12:08:25 +0200586static void __blk_mark_disk_dead(struct gendisk *disk)
Christoph Hellwig7a5428d2022-02-17 08:52:31 +0100587{
Christoph Hellwig66fddc22023-06-01 11:44:47 +0200588 /*
589 * Fail any new I/O.
590 */
Christoph Hellwiga4f75762023-06-01 11:44:48 +0200591 if (test_and_set_bit(GD_DEAD, &disk->state))
592 return;
593
Christoph Hellwig66fddc22023-06-01 11:44:47 +0200594 if (test_bit(GD_OWNS_QUEUE, &disk->state))
595 blk_queue_flag_set(QUEUE_FLAG_DYING, disk->queue);
Christoph Hellwig71b26082022-11-01 16:00:37 +0100596
597 /*
598 * Stop buffered writers from dirtying pages that can't be written out.
599 */
Christoph Hellwig66fddc22023-06-01 11:44:47 +0200600 set_capacity(disk, 0);
601
602 /*
603 * Prevent new I/O from crossing bio_queue_enter().
604 */
605 blk_queue_start_drain(disk->queue);
Christoph Hellwigd8530de2023-08-11 12:08:25 +0200606}
Christoph Hellwigf55e0172023-06-01 11:44:53 +0200607
Christoph Hellwigd8530de2023-08-11 12:08:25 +0200608/**
609 * blk_mark_disk_dead - mark a disk as dead
610 * @disk: disk to mark as dead
611 *
612 * Mark as disk as dead (e.g. surprise removed) and don't accept any new I/O
613 * to this disk.
614 */
615void blk_mark_disk_dead(struct gendisk *disk)
616{
617 __blk_mark_disk_dead(disk);
618 blk_report_disk_dead(disk, true);
Christoph Hellwig7a5428d2022-02-17 08:52:31 +0100619}
620EXPORT_SYMBOL_GPL(blk_mark_disk_dead);
621
622/**
Luis Chamberlainb5bd3572020-06-19 20:47:23 +0000623 * del_gendisk - remove the gendisk
624 * @disk: the struct gendisk to remove
625 *
626 * Removes the gendisk and all its associated resources. This deletes the
627 * partitions associated with the gendisk, and unregisters the associated
628 * request_queue.
629 *
630 * This is the counter to the respective __device_add_disk() call.
631 *
632 * The final removal of the struct gendisk happens when its refcount reaches 0
633 * with put_disk(), which should be called after del_gendisk(), if
634 * __device_add_disk() was used.
Luis Chamberlaine8c7d142020-06-19 20:47:25 +0000635 *
636 * Drivers exist which depend on the release of the gendisk to be synchronous,
637 * it should not be deferred.
638 *
639 * Context: can sleep
Luis Chamberlainb5bd3572020-06-19 20:47:23 +0000640 */
Tejun Heod2bf1b62010-12-08 20:57:36 +0100641void del_gendisk(struct gendisk *disk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
Christoph Hellwig8e141f92021-09-29 09:12:40 +0200643 struct request_queue *q = disk->queue;
Christoph Hellwigeec1be42023-06-01 11:44:50 +0200644 struct block_device *part;
645 unsigned long idx;
Christoph Hellwig8e141f92021-09-29 09:12:40 +0200646
Luis Chamberlaine8c7d142020-06-19 20:47:25 +0000647 might_sleep();
648
Christoph Hellwig9f286992021-08-24 16:43:10 +0200649 if (WARN_ON_ONCE(!disk_live(disk) && !(disk->flags & GENHD_FL_HIDDEN)))
Christoph Hellwig6b3ba972020-10-29 15:58:24 +0100650 return;
651
Tejun Heo77ea8872010-12-08 20:57:37 +0100652 disk_del_events(disk);
653
Christoph Hellwigeec1be42023-06-01 11:44:50 +0200654 /*
Christoph Hellwigd8530de2023-08-11 12:08:25 +0200655 * Prevent new openers by unlinked the bdev inode.
Christoph Hellwigeec1be42023-06-01 11:44:50 +0200656 */
Christoph Hellwiga8698702021-05-25 08:12:56 +0200657 mutex_lock(&disk->open_mutex);
Christoph Hellwigd8530de2023-08-11 12:08:25 +0200658 xa_for_each(&disk->part_tbl, idx, part)
Christoph Hellwigeec1be42023-06-01 11:44:50 +0200659 remove_inode_hash(part->bd_inode);
Christoph Hellwiga8698702021-05-25 08:12:56 +0200660 mutex_unlock(&disk->open_mutex);
Christoph Hellwigc76f48e2021-04-06 08:22:56 +0200661
Christoph Hellwigd8530de2023-08-11 12:08:25 +0200662 /*
663 * Tell the file system to write back all dirty data and shut down if
664 * it hasn't been notified earlier.
665 */
666 if (!test_bit(GD_DEAD, &disk->state))
667 blk_report_disk_dead(disk, false);
668 __blk_mark_disk_dead(disk);
Christoph Hellwig8e141f92021-09-29 09:12:40 +0200669
Christoph Hellwigeec1be42023-06-01 11:44:50 +0200670 /*
671 * Drop all partitions now that the disk is marked dead.
672 */
673 mutex_lock(&disk->open_mutex);
674 xa_for_each_start(&disk->part_tbl, idx, part, 1)
675 drop_partition(part);
676 mutex_unlock(&disk->open_mutex);
677
Christoph Hellwig6b3ba972020-10-29 15:58:24 +0100678 if (!(disk->flags & GENHD_FL_HIDDEN)) {
Christoph Hellwig8ddcd652017-11-02 21:29:53 +0300679 sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
Christoph Hellwig6b3ba972020-10-29 15:58:24 +0100680
Jan Kara90f16fd2017-03-08 17:48:33 +0100681 /*
682 * Unregister bdi before releasing device numbers (as they can
683 * get reused and we'd get clashes in sysfs).
684 */
Christoph Hellwigedb08722021-08-09 16:17:43 +0200685 bdi_unregister(disk->bdi);
Jan Kara90f16fd2017-03-08 17:48:33 +0100686 }
Tejun Heod2bf1b62010-12-08 20:57:36 +0100687
Christoph Hellwig6b3ba972020-10-29 15:58:24 +0100688 blk_unregister_queue(disk);
Tejun Heod2bf1b62010-12-08 20:57:36 +0100689
Christoph Hellwigcb8432d2020-11-26 18:47:17 +0100690 kobject_put(disk->part0->bd_holder_dir);
Tejun Heod2bf1b62010-12-08 20:57:36 +0100691 kobject_put(disk->slave_dir);
Christoph Hellwigd90db3b2022-11-15 22:10:45 +0800692 disk->slave_dir = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Christoph Hellwig8446fe92020-11-24 09:36:54 +0100694 part_stat_set_all(disk->part0, 0);
Christoph Hellwigcb8432d2020-11-26 18:47:17 +0100695 disk->part0->bd_stamp = 0;
Greg Kroah-Hartman721da5c2023-02-23 08:33:26 +0100696 sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
Ming Lei25e823c2013-02-22 16:34:13 -0800697 pm_runtime_set_memalloc_noio(disk_to_dev(disk), false);
Tejun Heod2bf1b62010-12-08 20:57:36 +0100698 device_del(disk_to_dev(disk));
Ming Leid308ae02021-10-26 18:12:04 +0800699
Christoph Hellwig4c66a322022-09-19 16:40:49 +0200700 blk_mq_freeze_queue_wait(q);
701
Christoph Hellwigcad92662022-09-21 20:04:58 +0200702 blk_throtl_cancel_bios(disk);
Yu Kuai8f9e7b652022-03-18 21:01:44 +0800703
Ming Leid308ae02021-10-26 18:12:04 +0800704 blk_sync_queue(q);
705 blk_flush_integrity();
Jinlong Chen219cf432022-10-30 17:47:30 +0800706
707 if (queue_is_mq(q))
708 blk_mq_cancel_work_sync(q);
Christoph Hellwig50e34d72022-06-14 09:48:24 +0200709
710 blk_mq_quiesce_queue(q);
711 if (q->elevator) {
712 mutex_lock(&q->sysfs_lock);
713 elevator_exit(q);
714 mutex_unlock(&q->sysfs_lock);
715 }
716 rq_qos_exit(q);
717 blk_mq_unquiesce_queue(q);
718
Ming Leid308ae02021-10-26 18:12:04 +0800719 /*
Christoph Hellwig6f8191f2022-06-19 08:05:51 +0200720 * If the disk does not own the queue, allow using passthrough requests
721 * again. Else leave the queue frozen to fail all I/O.
Ming Leid308ae02021-10-26 18:12:04 +0800722 */
Christoph Hellwig6f8191f2022-06-19 08:05:51 +0200723 if (!test_bit(GD_OWNS_QUEUE, &disk->state)) {
724 blk_queue_flag_clear(QUEUE_FLAG_INIT_DONE, q);
725 __blk_mq_unfreeze_queue(q, true);
726 } else {
727 if (queue_is_mq(q))
728 blk_mq_exit_queue(q);
729 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730}
Tejun Heod2bf1b62010-12-08 20:57:36 +0100731EXPORT_SYMBOL(del_gendisk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
Xie Yongjif059a1d2021-09-22 20:37:08 +0800733/**
734 * invalidate_disk - invalidate the disk
735 * @disk: the struct gendisk to invalidate
736 *
737 * A helper to invalidates the disk. It will clean the disk's associated
738 * buffer/page caches and reset its internal states so that the disk
739 * can be reused by the drivers.
740 *
741 * Context: can sleep
742 */
743void invalidate_disk(struct gendisk *disk)
744{
745 struct block_device *bdev = disk->part0;
746
747 invalidate_bdev(bdev);
748 bdev->bd_inode->i_mapping->wb_err = 0;
749 set_capacity(disk, 0);
750}
751EXPORT_SYMBOL(invalidate_disk);
752
Vishal Verma99e66082016-01-09 08:36:51 -0800753/* sysfs access to bad-blocks list. */
754static ssize_t disk_badblocks_show(struct device *dev,
755 struct device_attribute *attr,
756 char *page)
757{
758 struct gendisk *disk = dev_to_disk(dev);
759
760 if (!disk->bb)
761 return sprintf(page, "\n");
762
763 return badblocks_show(disk->bb, page, 0);
764}
765
766static ssize_t disk_badblocks_store(struct device *dev,
767 struct device_attribute *attr,
768 const char *page, size_t len)
769{
770 struct gendisk *disk = dev_to_disk(dev);
771
772 if (!disk->bb)
773 return -ENXIO;
774
775 return badblocks_store(disk->bb, page, len, 0);
776}
777
Christoph Hellwigfbdee712022-01-04 08:16:47 +0100778#ifdef CONFIG_BLOCK_LEGACY_AUTOLOAD
Christoph Hellwig22ae8ce2020-11-26 09:23:26 +0100779void blk_request_module(dev_t devt)
Christoph Hellwigbd8eff32020-10-29 15:58:27 +0100780{
Christoph Hellwiga160c612020-10-29 15:58:28 +0100781 unsigned int major = MAJOR(devt);
782 struct blk_major_name **n;
783
784 mutex_lock(&major_names_lock);
785 for (n = &major_names[major_to_index(major)]; *n; n = &(*n)->next) {
786 if ((*n)->major == major && (*n)->probe) {
787 (*n)->probe(devt);
788 mutex_unlock(&major_names_lock);
789 return;
790 }
791 }
792 mutex_unlock(&major_names_lock);
793
Christoph Hellwigbd8eff32020-10-29 15:58:27 +0100794 if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
795 /* Make old-style 2.4 aliases work */
796 request_module("block-major-%d", MAJOR(devt));
797}
Christoph Hellwigfbdee712022-01-04 08:16:47 +0100798#endif /* CONFIG_BLOCK_LEGACY_AUTOLOAD */
Christoph Hellwigbd8eff32020-10-29 15:58:27 +0100799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800#ifdef CONFIG_PROC_FS
801/* iterator */
Tejun Heodef4e382008-09-03 08:57:12 +0200802static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
Greg Kroah-Hartman68c4d4a2008-05-22 17:21:08 -0400803{
Tejun Heodef4e382008-09-03 08:57:12 +0200804 loff_t skip = *pos;
805 struct class_dev_iter *iter;
806 struct device *dev;
Greg Kroah-Hartman68c4d4a2008-05-22 17:21:08 -0400807
Harvey Harrisonaeb3d3a2008-08-28 09:27:42 +0200808 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
Tejun Heodef4e382008-09-03 08:57:12 +0200809 if (!iter)
810 return ERR_PTR(-ENOMEM);
811
812 seqf->private = iter;
813 class_dev_iter_init(iter, &block_class, NULL, &disk_type);
814 do {
815 dev = class_dev_iter_next(iter);
816 if (!dev)
817 return NULL;
818 } while (skip--);
819
820 return dev_to_disk(dev);
Greg Kroah-Hartman68c4d4a2008-05-22 17:21:08 -0400821}
822
Tejun Heodef4e382008-09-03 08:57:12 +0200823static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200825 struct device *dev;
Greg Kroah-Hartman66c64af2008-05-22 17:21:08 -0400826
Tejun Heodef4e382008-09-03 08:57:12 +0200827 (*pos)++;
828 dev = class_dev_iter_next(seqf->private);
Tejun Heo2ac3cee2008-09-03 08:53:37 +0200829 if (dev)
Greg Kroah-Hartman68c4d4a2008-05-22 17:21:08 -0400830 return dev_to_disk(dev);
Tejun Heo2ac3cee2008-09-03 08:53:37 +0200831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 return NULL;
833}
834
Tejun Heodef4e382008-09-03 08:57:12 +0200835static void disk_seqf_stop(struct seq_file *seqf, void *v)
Greg Kroah-Hartman27f30252008-05-22 17:21:08 -0400836{
Tejun Heodef4e382008-09-03 08:57:12 +0200837 struct class_dev_iter *iter = seqf->private;
Greg Kroah-Hartman27f30252008-05-22 17:21:08 -0400838
Tejun Heodef4e382008-09-03 08:57:12 +0200839 /* stop is called even after start failed :-( */
840 if (iter) {
841 class_dev_iter_exit(iter);
842 kfree(iter);
Vegard Nossum77da1602016-07-29 10:40:31 +0200843 seqf->private = NULL;
Kay Sievers5c0ef6d2008-08-16 14:30:30 +0200844 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845}
846
Tejun Heodef4e382008-09-03 08:57:12 +0200847static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
Jianpeng Ma06768062012-08-03 10:42:00 +0200849 void *p;
Tejun Heodef4e382008-09-03 08:57:12 +0200850
851 p = disk_seqf_start(seqf, pos);
Yang Zhangb9f985b2010-12-17 08:58:36 +0100852 if (!IS_ERR_OR_NULL(p) && !*pos)
Tejun Heodef4e382008-09-03 08:57:12 +0200853 seq_puts(seqf, "major minor #blocks name\n\n");
854 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855}
856
Tejun Heocf771cb2008-09-03 09:01:09 +0200857static int show_partition(struct seq_file *seqf, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858{
859 struct gendisk *sgp = v;
Christoph Hellwigad1eaa52020-11-24 09:52:59 +0100860 struct block_device *part;
Christoph Hellwigecc75a92021-04-06 08:23:00 +0200861 unsigned long idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Christoph Hellwig3b5149a2021-11-22 14:06:21 +0100863 if (!get_capacity(sgp) || (sgp->flags & GENHD_FL_HIDDEN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 return 0;
865
Christoph Hellwigecc75a92021-04-06 08:23:00 +0200866 rcu_read_lock();
867 xa_for_each(&sgp->part_tbl, idx, part) {
868 if (!bdev_nr_sectors(part))
869 continue;
Christoph Hellwiga291bb432021-07-27 08:25:15 +0200870 seq_printf(seqf, "%4d %7d %10llu %pg\n",
Christoph Hellwigad1eaa52020-11-24 09:52:59 +0100871 MAJOR(part->bd_dev), MINOR(part->bd_dev),
Christoph Hellwiga291bb432021-07-27 08:25:15 +0200872 bdev_nr_sectors(part) >> 1, part);
Christoph Hellwigecc75a92021-04-06 08:23:00 +0200873 }
874 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 return 0;
876}
877
Alexey Dobriyanf5009752008-10-04 23:53:21 +0400878static const struct seq_operations partitions_op = {
Tejun Heodef4e382008-09-03 08:57:12 +0200879 .start = show_partition_start,
880 .next = disk_seqf_next,
881 .stop = disk_seqf_stop,
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200882 .show = show_partition
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883};
884#endif
885
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886static int __init genhd_device_init(void)
887{
Dan Williamse105b8b2008-04-21 10:51:07 -0700888 int error;
889
Dan Williamse105b8b2008-04-21 10:51:07 -0700890 error = class_register(&block_class);
Roland McGrathee27a552008-03-11 17:13:15 -0700891 if (unlikely(error))
892 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 blk_dev_init();
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200894
Zhang, Yanmin561ec682008-11-14 08:26:30 +0100895 register_blkdev(BLOCK_EXT_MAJOR, "blkext");
896
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200897 /* create top-level block dir */
Greg Kroah-Hartman721da5c2023-02-23 08:33:26 +0100898 block_depr = kobject_create_and_add("block", NULL);
Greg Kroah-Hartman830d3cf2007-11-06 10:36:58 -0800899 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900}
901
902subsys_initcall(genhd_device_init);
903
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200904static ssize_t disk_range_show(struct device *dev,
905 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200907 struct gendisk *disk = dev_to_disk(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200909 return sprintf(buf, "%d\n", disk->minors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910}
911
Tejun Heo1f014292008-08-25 19:47:23 +0900912static ssize_t disk_ext_range_show(struct device *dev,
913 struct device_attribute *attr, char *buf)
914{
915 struct gendisk *disk = dev_to_disk(dev);
916
Christoph Hellwig1ebe2e52021-11-22 14:06:22 +0100917 return sprintf(buf, "%d\n",
918 (disk->flags & GENHD_FL_NO_PART) ? 1 : DISK_MAX_PARTS);
Tejun Heo1f014292008-08-25 19:47:23 +0900919}
920
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200921static ssize_t disk_removable_show(struct device *dev,
922 struct device_attribute *attr, char *buf)
Kay Sieversa7fd6702005-10-01 14:49:43 +0200923{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200924 struct gendisk *disk = dev_to_disk(dev);
Kay Sieversa7fd6702005-10-01 14:49:43 +0200925
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200926 return sprintf(buf, "%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200928}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Christoph Hellwig8ddcd652017-11-02 21:29:53 +0300930static ssize_t disk_hidden_show(struct device *dev,
931 struct device_attribute *attr, char *buf)
932{
933 struct gendisk *disk = dev_to_disk(dev);
934
935 return sprintf(buf, "%d\n",
936 (disk->flags & GENHD_FL_HIDDEN ? 1 : 0));
937}
938
Kay Sievers1c9ce522008-06-13 09:41:00 +0200939static ssize_t disk_ro_show(struct device *dev,
940 struct device_attribute *attr, char *buf)
941{
942 struct gendisk *disk = dev_to_disk(dev);
943
Tejun Heob7db9952008-08-25 19:56:10 +0900944 return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
Kay Sievers1c9ce522008-06-13 09:41:00 +0200945}
946
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +0100947ssize_t part_size_show(struct device *dev,
948 struct device_attribute *attr, char *buf)
949{
Christoph Hellwig0d021292020-11-27 16:43:51 +0100950 return sprintf(buf, "%llu\n", bdev_nr_sectors(dev_to_bdev(dev)));
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +0100951}
952
953ssize_t part_stat_show(struct device *dev,
954 struct device_attribute *attr, char *buf)
955{
Christoph Hellwig0d021292020-11-27 16:43:51 +0100956 struct block_device *bdev = dev_to_bdev(dev);
Pavel Begunkoved6cdde2021-10-14 15:03:30 +0100957 struct request_queue *q = bdev_get_queue(bdev);
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300958 struct disk_stats stat;
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +0100959 unsigned int inflight;
960
Christoph Hellwigb2f609e2020-05-13 12:49:33 +0200961 if (queue_is_mq(q))
Christoph Hellwig0d021292020-11-27 16:43:51 +0100962 inflight = blk_mq_in_flight(q, bdev);
Christoph Hellwigb2f609e2020-05-13 12:49:33 +0200963 else
Christoph Hellwig0d021292020-11-27 16:43:51 +0100964 inflight = part_in_flight(bdev);
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300965
Zhang Wensheng86d73312022-02-17 14:42:47 +0800966 if (inflight) {
967 part_stat_lock();
968 update_io_ticks(bdev, jiffies, true);
969 part_stat_unlock();
970 }
971 part_stat_read_all(bdev, &stat);
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +0100972 return sprintf(buf,
973 "%8lu %8lu %8llu %8u "
974 "%8lu %8lu %8llu %8u "
975 "%8u %8u %8u "
976 "%8lu %8lu %8llu %8u "
977 "%8lu %8u"
978 "\n",
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300979 stat.ios[STAT_READ],
980 stat.merges[STAT_READ],
981 (unsigned long long)stat.sectors[STAT_READ],
982 (unsigned int)div_u64(stat.nsecs[STAT_READ], NSEC_PER_MSEC),
983 stat.ios[STAT_WRITE],
984 stat.merges[STAT_WRITE],
985 (unsigned long long)stat.sectors[STAT_WRITE],
986 (unsigned int)div_u64(stat.nsecs[STAT_WRITE], NSEC_PER_MSEC),
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +0100987 inflight,
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300988 jiffies_to_msecs(stat.io_ticks),
Konstantin Khlebnikov8cd5b8f2020-03-25 16:07:08 +0300989 (unsigned int)div_u64(stat.nsecs[STAT_READ] +
990 stat.nsecs[STAT_WRITE] +
991 stat.nsecs[STAT_DISCARD] +
992 stat.nsecs[STAT_FLUSH],
993 NSEC_PER_MSEC),
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +0300994 stat.ios[STAT_DISCARD],
995 stat.merges[STAT_DISCARD],
996 (unsigned long long)stat.sectors[STAT_DISCARD],
997 (unsigned int)div_u64(stat.nsecs[STAT_DISCARD], NSEC_PER_MSEC),
998 stat.ios[STAT_FLUSH],
999 (unsigned int)div_u64(stat.nsecs[STAT_FLUSH], NSEC_PER_MSEC));
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001000}
1001
1002ssize_t part_inflight_show(struct device *dev, struct device_attribute *attr,
1003 char *buf)
1004{
Christoph Hellwig0d021292020-11-27 16:43:51 +01001005 struct block_device *bdev = dev_to_bdev(dev);
Pavel Begunkoved6cdde2021-10-14 15:03:30 +01001006 struct request_queue *q = bdev_get_queue(bdev);
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001007 unsigned int inflight[2];
1008
Christoph Hellwigb2f609e2020-05-13 12:49:33 +02001009 if (queue_is_mq(q))
Christoph Hellwig0d021292020-11-27 16:43:51 +01001010 blk_mq_in_flight_rw(q, bdev, inflight);
Christoph Hellwigb2f609e2020-05-13 12:49:33 +02001011 else
Christoph Hellwig0d021292020-11-27 16:43:51 +01001012 part_in_flight_rw(bdev, inflight);
Christoph Hellwigb2f609e2020-05-13 12:49:33 +02001013
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001014 return sprintf(buf, "%8u %8u\n", inflight[0], inflight[1]);
1015}
1016
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001017static ssize_t disk_capability_show(struct device *dev,
1018 struct device_attribute *attr, char *buf)
Kristen Carlson Accardi86ce18d2007-05-23 13:57:38 -07001019{
Christoph Hellwige81cd5a2023-02-03 16:02:09 +01001020 dev_warn_once(dev, "the capability attribute has been deprecated.\n");
1021 return sprintf(buf, "0\n");
Kristen Carlson Accardi86ce18d2007-05-23 13:57:38 -07001022}
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001023
Martin K. Petersenc72758f2009-05-22 17:17:53 -04001024static ssize_t disk_alignment_offset_show(struct device *dev,
1025 struct device_attribute *attr,
1026 char *buf)
1027{
1028 struct gendisk *disk = dev_to_disk(dev);
1029
Christoph Hellwig640f2a22022-04-15 06:52:48 +02001030 return sprintf(buf, "%d\n", bdev_alignment_offset(disk->part0));
Martin K. Petersenc72758f2009-05-22 17:17:53 -04001031}
1032
Martin K. Petersen86b37282009-11-10 11:50:21 +01001033static ssize_t disk_discard_alignment_show(struct device *dev,
1034 struct device_attribute *attr,
1035 char *buf)
1036{
1037 struct gendisk *disk = dev_to_disk(dev);
1038
Christoph Hellwig4e1462f2022-04-15 06:52:50 +02001039 return sprintf(buf, "%d\n", bdev_alignment_offset(disk->part0));
Martin K. Petersen86b37282009-11-10 11:50:21 +01001040}
1041
Matteo Croce13927b32021-07-13 01:05:28 +02001042static ssize_t diskseq_show(struct device *dev,
1043 struct device_attribute *attr, char *buf)
1044{
1045 struct gendisk *disk = dev_to_disk(dev);
1046
1047 return sprintf(buf, "%llu\n", disk->diskseq);
1048}
1049
Joe Perches5657a812018-05-24 13:38:59 -06001050static DEVICE_ATTR(range, 0444, disk_range_show, NULL);
1051static DEVICE_ATTR(ext_range, 0444, disk_ext_range_show, NULL);
1052static DEVICE_ATTR(removable, 0444, disk_removable_show, NULL);
1053static DEVICE_ATTR(hidden, 0444, disk_hidden_show, NULL);
1054static DEVICE_ATTR(ro, 0444, disk_ro_show, NULL);
1055static DEVICE_ATTR(size, 0444, part_size_show, NULL);
1056static DEVICE_ATTR(alignment_offset, 0444, disk_alignment_offset_show, NULL);
1057static DEVICE_ATTR(discard_alignment, 0444, disk_discard_alignment_show, NULL);
1058static DEVICE_ATTR(capability, 0444, disk_capability_show, NULL);
1059static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
1060static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
1061static DEVICE_ATTR(badblocks, 0644, disk_badblocks_show, disk_badblocks_store);
Matteo Croce13927b32021-07-13 01:05:28 +02001062static DEVICE_ATTR(diskseq, 0444, diskseq_show, NULL);
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001063
Akinobu Mitac17bb492006-12-08 02:39:46 -08001064#ifdef CONFIG_FAIL_MAKE_REQUEST
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001065ssize_t part_fail_show(struct device *dev,
1066 struct device_attribute *attr, char *buf)
1067{
Christoph Hellwig0d021292020-11-27 16:43:51 +01001068 return sprintf(buf, "%d\n", dev_to_bdev(dev)->bd_make_it_fail);
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001069}
1070
1071ssize_t part_fail_store(struct device *dev,
1072 struct device_attribute *attr,
1073 const char *buf, size_t count)
1074{
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001075 int i;
1076
1077 if (count > 0 && sscanf(buf, "%d", &i) > 0)
Christoph Hellwig0d021292020-11-27 16:43:51 +01001078 dev_to_bdev(dev)->bd_make_it_fail = i;
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001079
1080 return count;
1081}
1082
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001083static struct device_attribute dev_attr_fail =
Joe Perches5657a812018-05-24 13:38:59 -06001084 __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
Christoph Hellwig3ad5cee2020-03-24 08:25:13 +01001085#endif /* CONFIG_FAIL_MAKE_REQUEST */
1086
Jens Axboe581d4e22008-09-14 05:56:33 -07001087#ifdef CONFIG_FAIL_IO_TIMEOUT
1088static struct device_attribute dev_attr_fail_timeout =
Joe Perches5657a812018-05-24 13:38:59 -06001089 __ATTR(io-timeout-fail, 0644, part_timeout_show, part_timeout_store);
Jens Axboe581d4e22008-09-14 05:56:33 -07001090#endif
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001091
1092static struct attribute *disk_attrs[] = {
1093 &dev_attr_range.attr,
Tejun Heo1f014292008-08-25 19:47:23 +09001094 &dev_attr_ext_range.attr,
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001095 &dev_attr_removable.attr,
Christoph Hellwig8ddcd652017-11-02 21:29:53 +03001096 &dev_attr_hidden.attr,
Kay Sievers1c9ce522008-06-13 09:41:00 +02001097 &dev_attr_ro.attr,
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001098 &dev_attr_size.attr,
Martin K. Petersenc72758f2009-05-22 17:17:53 -04001099 &dev_attr_alignment_offset.attr,
Martin K. Petersen86b37282009-11-10 11:50:21 +01001100 &dev_attr_discard_alignment.attr,
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001101 &dev_attr_capability.attr,
1102 &dev_attr_stat.attr,
Nikanth Karthikesan316d3152009-10-06 20:16:55 +02001103 &dev_attr_inflight.attr,
Vishal Verma99e66082016-01-09 08:36:51 -08001104 &dev_attr_badblocks.attr,
Christoph Hellwig2bc8cda2021-06-24 09:38:43 +02001105 &dev_attr_events.attr,
1106 &dev_attr_events_async.attr,
1107 &dev_attr_events_poll_msecs.attr,
Matteo Croce13927b32021-07-13 01:05:28 +02001108 &dev_attr_diskseq.attr,
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001109#ifdef CONFIG_FAIL_MAKE_REQUEST
1110 &dev_attr_fail.attr,
1111#endif
Jens Axboe581d4e22008-09-14 05:56:33 -07001112#ifdef CONFIG_FAIL_IO_TIMEOUT
1113 &dev_attr_fail_timeout.attr,
1114#endif
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001115 NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116};
1117
Dan Williams9438b3e02017-04-27 14:46:26 -07001118static umode_t disk_visible(struct kobject *kobj, struct attribute *a, int n)
1119{
1120 struct device *dev = container_of(kobj, typeof(*dev), kobj);
1121 struct gendisk *disk = dev_to_disk(dev);
1122
1123 if (a == &dev_attr_badblocks.attr && !disk->bb)
1124 return 0;
1125 return a->mode;
1126}
1127
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001128static struct attribute_group disk_attr_group = {
1129 .attrs = disk_attrs,
Dan Williams9438b3e02017-04-27 14:46:26 -07001130 .is_visible = disk_visible,
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001131};
1132
David Brownella4dbd672009-06-24 10:06:31 -07001133static const struct attribute_group *disk_attr_groups[] = {
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001134 &disk_attr_group,
Christoph Hellwigcc5c516d2022-06-28 19:18:45 +02001135#ifdef CONFIG_BLK_DEV_IO_TRACE
1136 &blk_trace_attr_group,
1137#endif
Thomas Weißschuhff53cd52023-03-18 17:36:25 +00001138#ifdef CONFIG_BLK_DEV_INTEGRITY
1139 &blk_integrity_attr_group,
1140#endif
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001141 NULL
1142};
1143
Tejun Heo540eed52008-08-25 19:56:15 +09001144/**
Luis Chamberlainb5bd3572020-06-19 20:47:23 +00001145 * disk_release - releases all allocated resources of the gendisk
1146 * @dev: the device representing this disk
1147 *
1148 * This function releases all allocated resources of the gendisk.
1149 *
Luis Chamberlainb5bd3572020-06-19 20:47:23 +00001150 * Drivers which used __device_add_disk() have a gendisk with a request_queue
1151 * assigned. Since the request_queue sits on top of the gendisk for these
1152 * drivers we also call blk_put_queue() for them, and we expect the
1153 * request_queue refcount to reach 0 at this point, and so the request_queue
1154 * will also be freed prior to the disk.
Luis Chamberlaine8c7d142020-06-19 20:47:25 +00001155 *
1156 * Context: can sleep
Luis Chamberlainb5bd3572020-06-19 20:47:23 +00001157 */
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001158static void disk_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159{
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001160 struct gendisk *disk = dev_to_disk(dev);
1161
Luis Chamberlaine8c7d142020-06-19 20:47:25 +00001162 might_sleep();
Christoph Hellwiga2041762021-10-14 15:02:31 +02001163 WARN_ON_ONCE(disk_live(disk));
Luis Chamberlaine8c7d142020-06-19 20:47:25 +00001164
Yu Kuaidd7de372023-06-10 10:20:03 +08001165 blk_trace_remove(disk->queue);
1166
Christoph Hellwigc5db2cf2022-07-20 15:05:41 +02001167 /*
1168 * To undo the all initialization from blk_mq_init_allocated_queue in
1169 * case of a probe failure where add_disk is never called we have to
1170 * call blk_mq_exit_queue here. We can't do this for the more common
1171 * teardown case (yet) as the tagset can be gone by the time the disk
1172 * is released once it was added.
1173 */
1174 if (queue_is_mq(disk->queue) &&
1175 test_bit(GD_OWNS_QUEUE, &disk->state) &&
1176 !test_bit(GD_ADDED, &disk->state))
1177 blk_mq_exit_queue(disk->queue);
1178
Christoph Hellwigb6553bef2023-02-14 19:33:06 +01001179 blkcg_exit_disk(disk);
1180
Christoph Hellwig46754bd2022-07-27 12:22:57 -04001181 bioset_exit(&disk->bio_split);
Ming Lei2a19b282021-11-16 09:43:43 +08001182
Tejun Heo77ea8872010-12-08 20:57:37 +01001183 disk_release_events(disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 kfree(disk->random);
Christoph Hellwig5d400662022-07-06 09:03:42 +02001185 disk_free_zone_bitmaps(disk);
Christoph Hellwiga33df752021-01-24 11:02:41 +01001186 xa_destroy(&disk->part_tbl);
Ming Lei10596992022-03-08 06:51:55 +01001187
Christoph Hellwigd152c682021-08-16 15:46:24 +02001188 disk->queue->disk = NULL;
Christoph Hellwig61a35cf2021-08-16 15:19:09 +02001189 blk_put_queue(disk->queue);
Christoph Hellwig76792052022-02-15 10:45:10 +01001190
1191 if (test_bit(GD_ADDED, &disk->state) && disk->fops->free_disk)
1192 disk->fops->free_disk(disk);
1193
Christoph Hellwig2f4731d2021-07-22 09:54:02 +02001194 iput(disk->part0->bd_inode); /* frees the disk */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195}
Matteo Croce87eb7102021-07-13 01:05:26 +02001196
Greg Kroah-Hartman23680f02022-11-23 13:25:19 +01001197static int block_uevent(const struct device *dev, struct kobj_uevent_env *env)
Matteo Croce87eb7102021-07-13 01:05:26 +02001198{
Greg Kroah-Hartman23680f02022-11-23 13:25:19 +01001199 const struct gendisk *disk = dev_to_disk(dev);
Matteo Croce87eb7102021-07-13 01:05:26 +02001200
1201 return add_uevent_var(env, "DISKSEQ=%llu", disk->diskseq);
1202}
1203
Ricardo B. Marlieref8c75112024-03-05 16:32:16 -03001204const struct class block_class = {
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001205 .name = "block",
Matteo Croce87eb7102021-07-13 01:05:26 +02001206 .dev_uevent = block_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207};
1208
Greg Kroah-Hartmana9b12f8b2023-01-11 12:30:08 +01001209static char *block_devnode(const struct device *dev, umode_t *mode,
Jens Axboe050a4f32023-01-04 14:44:02 -07001210 kuid_t *uid, kgid_t *gid)
1211{
1212 struct gendisk *disk = dev_to_disk(dev);
1213
1214 if (disk->fops->devnode)
1215 return disk->fops->devnode(disk, mode);
1216 return NULL;
1217}
1218
Boris Burkovef45fe42020-06-01 13:12:05 -07001219const struct device_type disk_type = {
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001220 .name = "disk",
1221 .groups = disk_attr_groups,
1222 .release = disk_release,
Jens Axboe050a4f32023-01-04 14:44:02 -07001223 .devnode = block_devnode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224};
1225
Randy Dunlapa6e2ba82008-05-23 09:44:11 -07001226#ifdef CONFIG_PROC_FS
Tejun Heocf771cb2008-09-03 09:01:09 +02001227/*
1228 * aggregate disk stat collector. Uses the same stats that the sysfs
1229 * entries do, above, but makes them available through one seq_file.
1230 *
1231 * The output looks suspiciously like /proc/partitions with a bunch of
1232 * extra fields.
1233 */
1234static int diskstats_show(struct seq_file *seqf, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235{
1236 struct gendisk *gp = v;
Christoph Hellwigad1eaa52020-11-24 09:52:59 +01001237 struct block_device *hd;
Mikulas Patockae016b782018-12-06 11:41:21 -05001238 unsigned int inflight;
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +03001239 struct disk_stats stat;
Christoph Hellwig7fae67c2021-04-06 08:23:01 +02001240 unsigned long idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
1242 /*
Tejun Heoed9e1982008-08-25 19:56:05 +09001243 if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
Tejun Heocf771cb2008-09-03 09:01:09 +02001244 seq_puts(seqf, "major minor name"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 " rio rmerge rsect ruse wio wmerge "
1246 "wsect wuse running use aveq"
1247 "\n\n");
1248 */
Wanlong Gao9f5e4862011-06-13 10:45:43 +02001249
Christoph Hellwig7fae67c2021-04-06 08:23:01 +02001250 rcu_read_lock();
1251 xa_for_each(&gp->part_tbl, idx, hd) {
1252 if (bdev_is_partition(hd) && !bdev_nr_sectors(hd))
1253 continue;
Christoph Hellwigb2f609e2020-05-13 12:49:33 +02001254 if (queue_is_mq(gp->queue))
Christoph Hellwigad1eaa52020-11-24 09:52:59 +01001255 inflight = blk_mq_in_flight(gp->queue, hd);
Christoph Hellwigb2f609e2020-05-13 12:49:33 +02001256 else
Christoph Hellwigad1eaa52020-11-24 09:52:59 +01001257 inflight = part_in_flight(hd);
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +03001258
Zhang Wensheng86d73312022-02-17 14:42:47 +08001259 if (inflight) {
1260 part_stat_lock();
1261 update_io_ticks(hd, jiffies, true);
1262 part_stat_unlock();
1263 }
1264 part_stat_read_all(hd, &stat);
Abd-Alrhman Masalkhi26e2d7a2021-07-27 08:25:13 +02001265 seq_printf(seqf, "%4d %7d %pg "
Michael Callahanbdca3c82018-07-18 04:47:40 -07001266 "%lu %lu %lu %u "
1267 "%lu %lu %lu %u "
1268 "%u %u %u "
Konstantin Khlebnikovb6866312019-11-21 13:40:26 +03001269 "%lu %lu %lu %u "
1270 "%lu %u"
1271 "\n",
Abd-Alrhman Masalkhi26e2d7a2021-07-27 08:25:13 +02001272 MAJOR(hd->bd_dev), MINOR(hd->bd_dev), hd,
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +03001273 stat.ios[STAT_READ],
1274 stat.merges[STAT_READ],
1275 stat.sectors[STAT_READ],
1276 (unsigned int)div_u64(stat.nsecs[STAT_READ],
1277 NSEC_PER_MSEC),
1278 stat.ios[STAT_WRITE],
1279 stat.merges[STAT_WRITE],
1280 stat.sectors[STAT_WRITE],
1281 (unsigned int)div_u64(stat.nsecs[STAT_WRITE],
1282 NSEC_PER_MSEC),
Mikulas Patockae016b782018-12-06 11:41:21 -05001283 inflight,
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +03001284 jiffies_to_msecs(stat.io_ticks),
Konstantin Khlebnikov8cd5b8f2020-03-25 16:07:08 +03001285 (unsigned int)div_u64(stat.nsecs[STAT_READ] +
1286 stat.nsecs[STAT_WRITE] +
1287 stat.nsecs[STAT_DISCARD] +
1288 stat.nsecs[STAT_FLUSH],
1289 NSEC_PER_MSEC),
Konstantin Khlebnikovea18e0f2020-03-25 16:07:06 +03001290 stat.ios[STAT_DISCARD],
1291 stat.merges[STAT_DISCARD],
1292 stat.sectors[STAT_DISCARD],
1293 (unsigned int)div_u64(stat.nsecs[STAT_DISCARD],
1294 NSEC_PER_MSEC),
1295 stat.ios[STAT_FLUSH],
1296 (unsigned int)div_u64(stat.nsecs[STAT_FLUSH],
1297 NSEC_PER_MSEC)
Jerome Marchand28f39d52008-02-08 11:04:56 +01001298 );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
Christoph Hellwig7fae67c2021-04-06 08:23:01 +02001300 rcu_read_unlock();
Wanlong Gao9f5e4862011-06-13 10:45:43 +02001301
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 return 0;
1303}
1304
Alexey Dobriyan31d85ab2008-10-06 12:55:38 +04001305static const struct seq_operations diskstats_op = {
Tejun Heodef4e382008-09-03 08:57:12 +02001306 .start = disk_seqf_start,
1307 .next = disk_seqf_next,
1308 .stop = disk_seqf_stop,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 .show = diskstats_show
1310};
Alexey Dobriyanf5009752008-10-04 23:53:21 +04001311
1312static int __init proc_genhd_init(void)
1313{
Christoph Hellwigfddda2b2018-04-13 19:44:18 +02001314 proc_create_seq("diskstats", 0, NULL, &diskstats_op);
1315 proc_create_seq("partitions", 0, NULL, &partitions_op);
Alexey Dobriyanf5009752008-10-04 23:53:21 +04001316 return 0;
1317}
1318module_init(proc_genhd_init);
Randy Dunlapa6e2ba82008-05-23 09:44:11 -07001319#endif /* CONFIG_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320
Christoph Hellwigc97d93c2021-05-25 08:13:00 +02001321dev_t part_devt(struct gendisk *disk, u8 partno)
1322{
Christoph Hellwig0e0ccde2021-05-25 08:13:01 +02001323 struct block_device *part;
Christoph Hellwigc97d93c2021-05-25 08:13:00 +02001324 dev_t devt = 0;
1325
Christoph Hellwig0e0ccde2021-05-25 08:13:01 +02001326 rcu_read_lock();
1327 part = xa_load(&disk->part_tbl, partno);
1328 if (part)
Christoph Hellwigc97d93c2021-05-25 08:13:00 +02001329 devt = part->bd_dev;
Christoph Hellwig0e0ccde2021-05-25 08:13:01 +02001330 rcu_read_unlock();
Christoph Hellwigc97d93c2021-05-25 08:13:00 +02001331
1332 return devt;
1333}
1334
Christoph Hellwig4a1fa412021-08-16 15:19:08 +02001335struct gendisk *__alloc_disk_node(struct request_queue *q, int node_id,
1336 struct lock_class_key *lkclass)
Christoph Lameter19460892005-06-23 00:08:19 -07001337{
1338 struct gendisk *disk;
1339
Joe Perchesc1b511e2013-08-29 15:21:42 -07001340 disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);
Christoph Hellwigf93af2a2020-08-31 20:02:37 +02001341 if (!disk)
Rafael Mendoncaaa0c6802022-08-11 20:23:37 -03001342 return NULL;
Jens Axboe6c23a962011-01-07 08:43:37 +01001343
Christoph Hellwig46754bd2022-07-27 12:22:57 -04001344 if (bioset_init(&disk->bio_split, BIO_POOL_SIZE, 0, 0))
1345 goto out_free_disk;
1346
Christoph Hellwigedb08722021-08-09 16:17:43 +02001347 disk->bdi = bdi_alloc(node_id);
1348 if (!disk->bdi)
Christoph Hellwig46754bd2022-07-27 12:22:57 -04001349 goto out_free_bioset;
Christoph Hellwigedb08722021-08-09 16:17:43 +02001350
Pavel Begunkov17220ca2021-10-14 15:03:26 +01001351 /* bdev_alloc() might need the queue, set before the first call */
1352 disk->queue = q;
1353
Christoph Hellwigcb8432d2020-11-26 18:47:17 +01001354 disk->part0 = bdev_alloc(disk, 0);
1355 if (!disk->part0)
Christoph Hellwigedb08722021-08-09 16:17:43 +02001356 goto out_free_bdi;
Tejun Heob5d0b9d2008-09-03 09:06:42 +02001357
Christoph Hellwigf93af2a2020-08-31 20:02:37 +02001358 disk->node_id = node_id;
Christoph Hellwiga8698702021-05-25 08:12:56 +02001359 mutex_init(&disk->open_mutex);
Christoph Hellwiga33df752021-01-24 11:02:41 +01001360 xa_init(&disk->part_tbl);
1361 if (xa_insert(&disk->part_tbl, 0, disk->part0, GFP_KERNEL))
1362 goto out_destroy_part_tbl;
Christoph Hellwigf93af2a2020-08-31 20:02:37 +02001363
Christoph Hellwigb6553bef2023-02-14 19:33:06 +01001364 if (blkcg_init_disk(disk))
1365 goto out_erase_part0;
1366
Christoph Hellwigf93af2a2020-08-31 20:02:37 +02001367 rand_initialize_disk(disk);
1368 disk_to_dev(disk)->class = &block_class;
1369 disk_to_dev(disk)->type = &disk_type;
1370 device_initialize(disk_to_dev(disk));
Matteo Crocecf179942021-07-13 01:05:25 +02001371 inc_diskseq(disk);
Christoph Hellwigd152c682021-08-16 15:46:24 +02001372 q->disk = disk;
Christoph Hellwig4dcc48742021-08-16 15:19:05 +02001373 lockdep_init_map(&disk->lockdep_map, "(bio completion)", lkclass, 0);
Christoph Hellwig0dbcfe22021-08-04 11:41:42 +02001374#ifdef CONFIG_BLOCK_HOLDER_DEPRECATED
1375 INIT_LIST_HEAD(&disk->slave_bdevs);
1376#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 return disk;
Christoph Hellwigf93af2a2020-08-31 20:02:37 +02001378
Christoph Hellwigb6553bef2023-02-14 19:33:06 +01001379out_erase_part0:
1380 xa_erase(&disk->part_tbl, 0);
Christoph Hellwiga33df752021-01-24 11:02:41 +01001381out_destroy_part_tbl:
1382 xa_destroy(&disk->part_tbl);
Tetsuo Handa06cc9782021-10-02 18:23:02 +09001383 disk->part0->bd_disk = NULL;
Christoph Hellwig2f4731d2021-07-22 09:54:02 +02001384 iput(disk->part0->bd_inode);
Christoph Hellwigedb08722021-08-09 16:17:43 +02001385out_free_bdi:
1386 bdi_put(disk->bdi);
Christoph Hellwig46754bd2022-07-27 12:22:57 -04001387out_free_bioset:
1388 bioset_exit(&disk->bio_split);
Christoph Hellwigf93af2a2020-08-31 20:02:37 +02001389out_free_disk:
1390 kfree(disk);
1391 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Christoph Hellwig74fa8f92024-02-15 08:10:47 +01001394struct gendisk *__blk_alloc_disk(struct queue_limits *lim, int node,
1395 struct lock_class_key *lkclass)
Christoph Hellwigf5254642021-05-21 07:50:55 +02001396{
Christoph Hellwig74fa8f92024-02-15 08:10:47 +01001397 struct queue_limits default_lim = { };
Christoph Hellwigf5254642021-05-21 07:50:55 +02001398 struct request_queue *q;
1399 struct gendisk *disk;
1400
Christoph Hellwig74fa8f92024-02-15 08:10:47 +01001401 q = blk_alloc_queue(lim ? lim : &default_lim, node);
Christoph Hellwigad751ba2024-02-13 08:34:18 +01001402 if (IS_ERR(q))
Christoph Hellwig74fa8f92024-02-15 08:10:47 +01001403 return ERR_CAST(q);
Christoph Hellwigf5254642021-05-21 07:50:55 +02001404
Christoph Hellwig4a1fa412021-08-16 15:19:08 +02001405 disk = __alloc_disk_node(q, node, lkclass);
Christoph Hellwigf5254642021-05-21 07:50:55 +02001406 if (!disk) {
Christoph Hellwig6f8191f2022-06-19 08:05:51 +02001407 blk_put_queue(q);
Christoph Hellwig74fa8f92024-02-15 08:10:47 +01001408 return ERR_PTR(-ENOMEM);
Christoph Hellwigf5254642021-05-21 07:50:55 +02001409 }
Christoph Hellwig6f8191f2022-06-19 08:05:51 +02001410 set_bit(GD_OWNS_QUEUE, &disk->state);
Christoph Hellwigf5254642021-05-21 07:50:55 +02001411 return disk;
1412}
1413EXPORT_SYMBOL(__blk_alloc_disk);
1414
Luis Chamberlainb5bd3572020-06-19 20:47:23 +00001415/**
Luis Chamberlainb5bd3572020-06-19 20:47:23 +00001416 * put_disk - decrements the gendisk refcount
Randy Dunlap0d20dcc2020-07-30 18:42:30 -07001417 * @disk: the struct gendisk to decrement the refcount for
Luis Chamberlainb5bd3572020-06-19 20:47:23 +00001418 *
1419 * This decrements the refcount for the struct gendisk. When this reaches 0
1420 * we'll have disk_release() called.
Luis Chamberlaine8c7d142020-06-19 20:47:25 +00001421 *
Christoph Hellwigc5db2cf2022-07-20 15:05:41 +02001422 * Note: for blk-mq disk put_disk must be called before freeing the tag_set
1423 * when handling probe errors (that is before add_disk() is called).
1424 *
Luis Chamberlaine8c7d142020-06-19 20:47:25 +00001425 * Context: Any context, but the last reference must not be dropped from
1426 * atomic context.
Luis Chamberlainb5bd3572020-06-19 20:47:23 +00001427 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428void put_disk(struct gendisk *disk)
1429{
1430 if (disk)
Christoph Hellwigefdc41c2020-11-10 07:25:37 +01001431 put_device(disk_to_dev(disk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433EXPORT_SYMBOL(put_disk);
1434
Hannes Reineckee3264a42009-07-28 09:13:13 +02001435static void set_disk_ro_uevent(struct gendisk *gd, int ro)
1436{
1437 char event[] = "DISK_RO=1";
1438 char *envp[] = { event, NULL };
1439
1440 if (!ro)
1441 event[8] = '0';
1442 kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
1443}
1444
Christoph Hellwig52f019d2021-01-09 11:42:51 +01001445/**
1446 * set_disk_ro - set a gendisk read-only
1447 * @disk: gendisk to operate on
Lukas Bulwahn7f31bee2021-01-29 05:55:05 +01001448 * @read_only: %true to set the disk read-only, %false set the disk read/write
Christoph Hellwig52f019d2021-01-09 11:42:51 +01001449 *
1450 * This function is used to indicate whether a given disk device should have its
1451 * read-only flag set. set_disk_ro() is typically used by device drivers to
1452 * indicate whether the underlying physical device is write-protected.
1453 */
1454void set_disk_ro(struct gendisk *disk, bool read_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455{
Christoph Hellwig52f019d2021-01-09 11:42:51 +01001456 if (read_only) {
1457 if (test_and_set_bit(GD_READ_ONLY, &disk->state))
1458 return;
1459 } else {
1460 if (!test_and_clear_bit(GD_READ_ONLY, &disk->state))
1461 return;
Hannes Reineckee3264a42009-07-28 09:13:13 +02001462 }
Christoph Hellwig52f019d2021-01-09 11:42:51 +01001463 set_disk_ro_uevent(disk, read_only);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465EXPORT_SYMBOL(set_disk_ro);
1466
Matteo Crocecf179942021-07-13 01:05:25 +02001467void inc_diskseq(struct gendisk *disk)
1468{
1469 disk->diskseq = atomic64_inc_return(&diskseq);
1470}