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