1 /*
2 * gendisk handling
3 */
4
5 #include <linux/config.h>
6 #include <linux/module.h>
7 #include <linux/fs.h>
8 #include <linux/genhd.h>
9 #include <linux/kernel.h>
10 #include <linux/blkdev.h>
11 #include <linux/init.h>
12 #include <linux/spinlock.h>
13 #include <linux/seq_file.h>
14 #include <linux/slab.h>
15 #include <linux/kmod.h>
16 #include <linux/kobj_map.h>
17
18 #define MAX_PROBE_HASH 255 /* random */
19
20 static struct subsystem block_subsys;
21
22 static DECLARE_MUTEX(block_subsys_sem);
23
24 /*
25 * Can be deleted altogether. Later.
26 *
27 */
28 static struct blk_major_name {
29 struct blk_major_name *next;
30 int major;
31 char name[16];
32 } *major_names[MAX_PROBE_HASH];
33
34 /* index in the above - for now: assume no multimajor ranges */
35 static inline int major_to_index(int major)
36 {
37 return major % MAX_PROBE_HASH;
38 }
39
40 #ifdef CONFIG_PROC_FS
41 /* get block device names in somewhat random order */
42 int get_blkdev_list(char *p)
43 {
44 struct blk_major_name *n;
45 int i, len;
46
47 len = sprintf(p, "\nBlock devices:\n");
48
49 down(&block_subsys_sem);
50 for (i = 0; i < ARRAY_SIZE(major_names); i++) {
51 for (n = major_names[i]; n; n = n->next)
52 len += sprintf(p+len, "%3d %s\n",
53 n->major, n->name);
54 }
55 up(&block_subsys_sem);
56
57 return len;
58 }
59 #endif
60
61 int register_blkdev(unsigned int major, const char *name)
62 {
63 struct blk_major_name **n, *p;
64 int index, ret = 0;
65
66 down(&block_subsys_sem);
67
68 /* temporary */
69 if (major == 0) {
70 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
71 if (major_names[index] == NULL)
72 break;
73 }
74
75 if (index == 0) {
76 printk("register_blkdev: failed to get major for %s\n",
77 name);
78 ret = -EBUSY;
79 goto out;
80 }
81 major = index;
82 ret = major;
83 }
84
85 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
86 if (p == NULL) {
87 ret = -ENOMEM;
88 goto out;
89 }
90
91 p->major = major;
92 strlcpy(p->name, name, sizeof(p->name));
93 p->next = NULL;
94 index = major_to_index(major);
95
96 for (n = &major_names[index]; *n; n = &(*n)->next) {
97 if ((*n)->major == major)
98 break;
99 }
100 if (!*n)
101 *n = p;
102 else
103 ret = -EBUSY;
104
105 if (ret < 0) {
106 printk("register_blkdev: cannot get major %d for %s\n",
107 major, name);
108 kfree(p);
109 }
110 out:
111 up(&block_subsys_sem);
112 return ret;
113 }
114
115 EXPORT_SYMBOL(register_blkdev);
116
117 /* todo: make void - error printk here */
118 int unregister_blkdev(unsigned int major, const char *name)
119 {
120 struct blk_major_name **n;
121 struct blk_major_name *p = NULL;
122 int index = major_to_index(major);
123 int ret = 0;
124
125 down(&block_subsys_sem);
126 for (n = &major_names[index]; *n; n = &(*n)->next)
127 if ((*n)->major == major)
128 break;
129 if (!*n || strcmp((*n)->name, name))
130 ret = -EINVAL;
131 else {
132 p = *n;
133 *n = p->next;
134 }
135 up(&block_subsys_sem);
136 kfree(p);
137
138 return ret;
139 }
140
141 EXPORT_SYMBOL(unregister_blkdev);
142
143 static struct kobj_map *bdev_map;
144
145 /*
146 * Register device numbers dev..(dev+range-1)
147 * range must be nonzero
148 * The hash chain is sorted on range, so that subranges can override.
149 */
150 void blk_register_region(dev_t dev, unsigned long range, struct module *module,
151 struct kobject *(*probe)(dev_t, int *, void *),
152 int (*lock)(dev_t, void *), void *data)
153 {
154 kobj_map(bdev_map, dev, range, module, probe, lock, data);
155 }
156
157 EXPORT_SYMBOL(blk_register_region);
158
159 void blk_unregister_region(dev_t dev, unsigned long range)
160 {
161 kobj_unmap(bdev_map, dev, range);
162 }
163
164 EXPORT_SYMBOL(blk_unregister_region);
165
166 static struct kobject *exact_match(dev_t dev, int *part, void *data)
167 {
168 struct gendisk *p = data;
169 return &p->kobj;
170 }
171
172 static int exact_lock(dev_t dev, void *data)
173 {
174 struct gendisk *p = data;
175
176 if (!get_disk(p))
177 return -1;
178 return 0;
179 }
180
181 /**
182 * add_disk - add partitioning information to kernel list
183 * @disk: per-device partitioning information
184 *
185 * This function registers the partitioning information in @disk
186 * with the kernel.
187 */
188 void add_disk(struct gendisk *disk)
189 {
190 disk->flags |= GENHD_FL_UP;
191 blk_register_region(MKDEV(disk->major, disk->first_minor),
192 disk->minors, NULL, exact_match, exact_lock, disk);
193 register_disk(disk);
194 blk_register_queue(disk);
195 }
196
197 EXPORT_SYMBOL(add_disk);
198 EXPORT_SYMBOL(del_gendisk); /* in partitions/check.c */
199
200 void unlink_gendisk(struct gendisk *disk)
201 {
202 blk_unregister_queue(disk);
203 blk_unregister_region(MKDEV(disk->major, disk->first_minor),
204 disk->minors);
205 }
206
207 #define to_disk(obj) container_of(obj,struct gendisk,kobj)
208
209 /**
210 * get_gendisk - get partitioning information for a given device
211 * @dev: device to get partitioning information for
212 *
213 * This function gets the structure containing partitioning
214 * information for the given device @dev.
215 */
216 struct gendisk *get_gendisk(dev_t dev, int *part)
217 {
218 struct kobject *kobj = kobj_lookup(bdev_map, dev, part);
219 return kobj ? to_disk(kobj) : NULL;
220 }
221
222 #ifdef CONFIG_PROC_FS
223 /* iterator */
224 static void *part_start(struct seq_file *part, loff_t *pos)
225 {
226 struct list_head *p;
227 loff_t l = *pos;
228
229 down(&block_subsys_sem);
230 list_for_each(p, &block_subsys.kset.list)
231 if (!l--)
232 return list_entry(p, struct gendisk, kobj.entry);
233 return NULL;
234 }
235
236 static void *part_next(struct seq_file *part, void *v, loff_t *pos)
237 {
238 struct list_head *p = ((struct gendisk *)v)->kobj.entry.next;
239 ++*pos;
240 return p==&block_subsys.kset.list ? NULL :
241 list_entry(p, struct gendisk, kobj.entry);
242 }
243
244 static void part_stop(struct seq_file *part, void *v)
245 {
246 up(&block_subsys_sem);
247 }
248
249 static int show_partition(struct seq_file *part, void *v)
250 {
251 struct gendisk *sgp = v;
252 int n;
253 char buf[BDEVNAME_SIZE];
254
255 if (&sgp->kobj.entry == block_subsys.kset.list.next)
256 seq_puts(part, "major minor #blocks name\n\n");
257
258 /* Don't show non-partitionable removeable devices or empty devices */
259 if (!get_capacity(sgp) ||
260 (sgp->minors == 1 && (sgp->flags & GENHD_FL_REMOVABLE)))
261 return 0;
262 if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
263 return 0;
264
265 /* show the full disk and all non-0 size partitions of it */
266 seq_printf(part, "%4d %4d %10llu %s\n",
267 sgp->major, sgp->first_minor,
268 (unsigned long long)get_capacity(sgp) >> 1,
269 disk_name(sgp, 0, buf));
270 for (n = 0; n < sgp->minors - 1; n++) {
271 if (!sgp->part[n])
272 continue;
273 if (sgp->part[n]->nr_sects == 0)
274 continue;
275 seq_printf(part, "%4d %4d %10llu %s\n",
276 sgp->major, n + 1 + sgp->first_minor,
277 (unsigned long long)sgp->part[n]->nr_sects >> 1 ,
278 disk_name(sgp, n + 1, buf));
279 }
280
281 return 0;
282 }
283
284 struct seq_operations partitions_op = {
285 .start =part_start,
286 .next = part_next,
287 .stop = part_stop,
288 .show = show_partition
289 };
290 #endif
291
292
293 extern int blk_dev_init(void);
294
295 static struct kobject *base_probe(dev_t dev, int *part, void *data)
296 {
297 if (request_module("block-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
298 /* Make old-style 2.4 aliases work */
299 request_module("block-major-%d", MAJOR(dev));
300 return NULL;
301 }
302
303 static int __init genhd_device_init(void)
304 {
305 bdev_map = kobj_map_init(base_probe, &block_subsys);
306 blk_dev_init();
307 subsystem_register(&block_subsys);
308 return 0;
309 }
310
311 subsys_initcall(genhd_device_init);
312
313
314
315 /*
316 * kobject & sysfs bindings for block devices
317 */
318 static ssize_t disk_attr_show(struct kobject *kobj, struct attribute *attr,
319 char *page)
320 {
321 struct gendisk *disk = to_disk(kobj);
322 struct disk_attribute *disk_attr =
323 container_of(attr,struct disk_attribute,attr);
324 ssize_t ret = 0;
325
326 if (disk_attr->show)
327 ret = disk_attr->show(disk,page);
328 return ret;
329 }
330
331 static struct sysfs_ops disk_sysfs_ops = {
332 .show = &disk_attr_show,
333 };
334
335 static ssize_t disk_dev_read(struct gendisk * disk, char *page)
336 {
337 dev_t base = MKDEV(disk->major, disk->first_minor);
338 return print_dev_t(page, base);
339 }
340 static ssize_t disk_range_read(struct gendisk * disk, char *page)
341 {
342 return sprintf(page, "%d\n", disk->minors);
343 }
344 static ssize_t disk_removable_read(struct gendisk * disk, char *page)
345 {
346 return sprintf(page, "%d\n",
347 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
348
349 }
350 static ssize_t disk_size_read(struct gendisk * disk, char *page)
351 {
352 return sprintf(page, "%llu\n", (unsigned long long)get_capacity(disk));
353 }
354
355 static ssize_t disk_stats_read(struct gendisk * disk, char *page)
356 {
357 preempt_disable();
358 disk_round_stats(disk);
359 preempt_enable();
360 return sprintf(page,
361 "%8u %8u %8llu %8u "
362 "%8u %8u %8llu %8u "
363 "%8u %8u %8u"
364 "\n",
365 disk_stat_read(disk, reads), disk_stat_read(disk, read_merges),
366 (unsigned long long)disk_stat_read(disk, read_sectors),
367 jiffies_to_msecs(disk_stat_read(disk, read_ticks)),
368 disk_stat_read(disk, writes),
369 disk_stat_read(disk, write_merges),
370 (unsigned long long)disk_stat_read(disk, write_sectors),
371 jiffies_to_msecs(disk_stat_read(disk, write_ticks)),
372 disk->in_flight,
373 jiffies_to_msecs(disk_stat_read(disk, io_ticks)),
374 jiffies_to_msecs(disk_stat_read(disk, time_in_queue)));
375 }
376 static struct disk_attribute disk_attr_dev = {
377 .attr = {.name = "dev", .mode = S_IRUGO },
378 .show = disk_dev_read
379 };
380 static struct disk_attribute disk_attr_range = {
381 .attr = {.name = "range", .mode = S_IRUGO },
382 .show = disk_range_read
383 };
384 static struct disk_attribute disk_attr_removable = {
385 .attr = {.name = "removable", .mode = S_IRUGO },
386 .show = disk_removable_read
387 };
388 static struct disk_attribute disk_attr_size = {
389 .attr = {.name = "size", .mode = S_IRUGO },
390 .show = disk_size_read
391 };
392 static struct disk_attribute disk_attr_stat = {
393 .attr = {.name = "stat", .mode = S_IRUGO },
394 .show = disk_stats_read
395 };
396
397 static struct attribute * default_attrs[] = {
398 &disk_attr_dev.attr,
399 &disk_attr_range.attr,
400 &disk_attr_removable.attr,
401 &disk_attr_size.attr,
402 &disk_attr_stat.attr,
403 NULL,
404 };
405
406 static void disk_release(struct kobject * kobj)
407 {
408 struct gendisk *disk = to_disk(kobj);
409 kfree(disk->random);
410 kfree(disk->part);
411 free_disk_stats(disk);
412 kfree(disk);
413 }
414
415 static struct kobj_type ktype_block = {
416 .release = disk_release,
417 .sysfs_ops = &disk_sysfs_ops,
418 .default_attrs = default_attrs,
419 };
420
421 extern struct kobj_type ktype_part;
422
423 static int block_hotplug_filter(struct kset *kset, struct kobject *kobj)
424 {
425 struct kobj_type *ktype = get_ktype(kobj);
426
427 return ((ktype == &ktype_block) || (ktype == &ktype_part));
428 }
429
430 static int block_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
431 int num_envp, char *buffer, int buffer_size)
432 {
433 struct device *dev = NULL;
434 struct kobj_type *ktype = get_ktype(kobj);
435 int length = 0;
436 int i = 0;
437
438 /* get physical device backing disk or partition */
439 if (ktype == &ktype_block) {
440 struct gendisk *disk = container_of(kobj, struct gendisk, kobj);
441 dev = disk->driverfs_dev;
442 } else if (ktype == &ktype_part) {
443 struct gendisk *disk = container_of(kobj->parent, struct gendisk, kobj);
444 dev = disk->driverfs_dev;
445 }
446
447 if (dev) {
448 /* add physical device, backing this device */
449 char *path = kobject_get_path(&dev->kobj, GFP_KERNEL);
450
451 add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size,
452 &length, "PHYSDEVPATH=%s", path);
453 kfree(path);
454
455 /* add bus name of physical device */
456 if (dev->bus)
457 add_hotplug_env_var(envp, num_envp, &i,
458 buffer, buffer_size, &length,
459 "PHYSDEVBUS=%s", dev->bus->name);
460
461 /* add driver name of physical device */
462 if (dev->driver)
463 add_hotplug_env_var(envp, num_envp, &i,
464 buffer, buffer_size, &length,
465 "PHYSDEVDRIVER=%s", dev->driver->name);
466
467 envp[i] = NULL;
468 }
469
470 return 0;
471 }
472
473 static struct kset_hotplug_ops block_hotplug_ops = {
474 .filter = block_hotplug_filter,
475 .hotplug = block_hotplug,
476 };
477
478 /* declare block_subsys. */
479 static decl_subsys(block, &ktype_block, &block_hotplug_ops);
480
481
482 /*
483 * aggregate disk stat collector. Uses the same stats that the sysfs
484 * entries do, above, but makes them available through one seq_file.
485 * Watching a few disks may be efficient through sysfs, but watching
486 * all of them will be more efficient through this interface.
487 *
488 * The output looks suspiciously like /proc/partitions with a bunch of
489 * extra fields.
490 */
491
492 /* iterator */
493 static void *diskstats_start(struct seq_file *part, loff_t *pos)
494 {
495 loff_t k = *pos;
496 struct list_head *p;
497
498 down(&block_subsys_sem);
499 list_for_each(p, &block_subsys.kset.list)
500 if (!k--)
501 return list_entry(p, struct gendisk, kobj.entry);
502 return NULL;
503 }
504
505 static void *diskstats_next(struct seq_file *part, void *v, loff_t *pos)
506 {
507 struct list_head *p = ((struct gendisk *)v)->kobj.entry.next;
508 ++*pos;
509 return p==&block_subsys.kset.list ? NULL :
510 list_entry(p, struct gendisk, kobj.entry);
511 }
512
513 static void diskstats_stop(struct seq_file *part, void *v)
514 {
515 up(&block_subsys_sem);
516 }
517
518 static int diskstats_show(struct seq_file *s, void *v)
519 {
520 struct gendisk *gp = v;
521 char buf[BDEVNAME_SIZE];
522 int n = 0;
523
524 /*
525 if (&sgp->kobj.entry == block_subsys.kset.list.next)
526 seq_puts(s, "major minor name"
527 " rio rmerge rsect ruse wio wmerge "
528 "wsect wuse running use aveq"
529 "\n\n");
530 */
531
532 preempt_disable();
533 disk_round_stats(gp);
534 preempt_enable();
535 seq_printf(s, "%4d %4d %s %u %u %llu %u %u %u %llu %u %u %u %u\n",
536 gp->major, n + gp->first_minor, disk_name(gp, n, buf),
537 disk_stat_read(gp, reads), disk_stat_read(gp, read_merges),
538 (unsigned long long)disk_stat_read(gp, read_sectors),
539 jiffies_to_msecs(disk_stat_read(gp, read_ticks)),
540 disk_stat_read(gp, writes), disk_stat_read(gp, write_merges),
541 (unsigned long long)disk_stat_read(gp, write_sectors),
542 jiffies_to_msecs(disk_stat_read(gp, write_ticks)),
543 gp->in_flight,
544 jiffies_to_msecs(disk_stat_read(gp, io_ticks)),
545 jiffies_to_msecs(disk_stat_read(gp, time_in_queue)));
546
547 /* now show all non-0 size partitions of it */
548 for (n = 0; n < gp->minors - 1; n++) {
549 struct hd_struct *hd = gp->part[n];
550
551 if (hd && hd->nr_sects)
552 seq_printf(s, "%4d %4d %s %u %u %u %u\n",
553 gp->major, n + gp->first_minor + 1,
554 disk_name(gp, n + 1, buf),
555 hd->reads, hd->read_sectors,
556 hd->writes, hd->write_sectors);
557 }
558
559 return 0;
560 }
561
562 struct seq_operations diskstats_op = {
563 .start = diskstats_start,
564 .next = diskstats_next,
565 .stop = diskstats_stop,
566 .show = diskstats_show
567 };
568
569
570 struct gendisk *alloc_disk(int minors)
571 {
572 struct gendisk *disk = kmalloc(sizeof(struct gendisk), GFP_KERNEL);
573 if (disk) {
574 memset(disk, 0, sizeof(struct gendisk));
575 if (!init_disk_stats(disk)) {
576 kfree(disk);
577 return NULL;
578 }
579 if (minors > 1) {
580 int size = (minors - 1) * sizeof(struct hd_struct *);
581 disk->part = kmalloc(size, GFP_KERNEL);
582 if (!disk->part) {
583 kfree(disk);
584 return NULL;
585 }
586 memset(disk->part, 0, size);
587 }
588 disk->minors = minors;
589 kobj_set_kset_s(disk,block_subsys);
590 kobject_init(&disk->kobj);
591 rand_initialize_disk(disk);
592 }
593 return disk;
594 }
595
596 EXPORT_SYMBOL(alloc_disk);
597
598 struct kobject *get_disk(struct gendisk *disk)
599 {
600 struct module *owner;
601 struct kobject *kobj;
602
603 if (!disk->fops)
604 return NULL;
605 owner = disk->fops->owner;
606 if (owner && !try_module_get(owner))
607 return NULL;
608 kobj = kobject_get(&disk->kobj);
609 if (kobj == NULL) {
610 module_put(owner);
611 return NULL;
612 }
613 return kobj;
614
615 }
616
617 EXPORT_SYMBOL(get_disk);
618
619 void put_disk(struct gendisk *disk)
620 {
621 if (disk)
622 kobject_put(&disk->kobj);
623 }
624
625 EXPORT_SYMBOL(put_disk);
626
627 void set_device_ro(struct block_device *bdev, int flag)
628 {
629 if (bdev->bd_contains != bdev)
630 bdev->bd_part->policy = flag;
631 else
632 bdev->bd_disk->policy = flag;
633 }
634
635 EXPORT_SYMBOL(set_device_ro);
636
637 void set_disk_ro(struct gendisk *disk, int flag)
638 {
639 int i;
640 disk->policy = flag;
641 for (i = 0; i < disk->minors - 1; i++)
642 if (disk->part[i]) disk->part[i]->policy = flag;
643 }
644
645 EXPORT_SYMBOL(set_disk_ro);
646
647 int bdev_read_only(struct block_device *bdev)
648 {
649 if (!bdev)
650 return 0;
651 else if (bdev->bd_contains != bdev)
652 return bdev->bd_part->policy;
653 else
654 return bdev->bd_disk->policy;
655 }
656
657 EXPORT_SYMBOL(bdev_read_only);
658
659 int invalidate_partition(struct gendisk *disk, int index)
660 {
661 int res = 0;
662 struct block_device *bdev = bdget_disk(disk, index);
663 if (bdev) {
664 res = __invalidate_device(bdev, 1);
665 bdput(bdev);
666 }
667 return res;
668 }
669
670 EXPORT_SYMBOL(invalidate_partition);
671
|
This page was automatically generated by the
LXR engine.
|