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