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