5 #include <linux/module.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/seq_file.h>
14 #include <linux/slab.h>
15 #include <linux/kmod.h>
16 #include <linux/kobj_map.h>
17 #include <linux/buffer_head.h>
18 #include <linux/mutex.h>
22 static DEFINE_MUTEX(block_class_lock
);
23 #ifndef CONFIG_SYSFS_DEPRECATED
24 struct kobject
*block_depr
;
27 static struct device_type disk_type
;
30 * Can be deleted altogether. Later.
33 static struct blk_major_name
{
34 struct blk_major_name
*next
;
37 } *major_names
[BLKDEV_MAJOR_HASH_SIZE
];
39 /* index in the above - for now: assume no multimajor ranges */
40 static inline int major_to_index(int major
)
42 return major
% BLKDEV_MAJOR_HASH_SIZE
;
46 void blkdev_show(struct seq_file
*f
, off_t offset
)
48 struct blk_major_name
*dp
;
50 if (offset
< BLKDEV_MAJOR_HASH_SIZE
) {
51 mutex_lock(&block_class_lock
);
52 for (dp
= major_names
[offset
]; dp
; dp
= dp
->next
)
53 seq_printf(f
, "%3d %s\n", dp
->major
, dp
->name
);
54 mutex_unlock(&block_class_lock
);
57 #endif /* CONFIG_PROC_FS */
59 int register_blkdev(unsigned int major
, const char *name
)
61 struct blk_major_name
**n
, *p
;
64 mutex_lock(&block_class_lock
);
68 for (index
= ARRAY_SIZE(major_names
)-1; index
> 0; index
--) {
69 if (major_names
[index
] == NULL
)
74 printk("register_blkdev: failed to get major for %s\n",
83 p
= kmalloc(sizeof(struct blk_major_name
), GFP_KERNEL
);
90 strlcpy(p
->name
, name
, sizeof(p
->name
));
92 index
= major_to_index(major
);
94 for (n
= &major_names
[index
]; *n
; n
= &(*n
)->next
) {
95 if ((*n
)->major
== major
)
104 printk("register_blkdev: cannot get major %d for %s\n",
109 mutex_unlock(&block_class_lock
);
113 EXPORT_SYMBOL(register_blkdev
);
115 void unregister_blkdev(unsigned int major
, const char *name
)
117 struct blk_major_name
**n
;
118 struct blk_major_name
*p
= NULL
;
119 int index
= major_to_index(major
);
121 mutex_lock(&block_class_lock
);
122 for (n
= &major_names
[index
]; *n
; n
= &(*n
)->next
)
123 if ((*n
)->major
== major
)
125 if (!*n
|| strcmp((*n
)->name
, name
)) {
131 mutex_unlock(&block_class_lock
);
135 EXPORT_SYMBOL(unregister_blkdev
);
137 static struct kobj_map
*bdev_map
;
140 * Register device numbers dev..(dev+range-1)
141 * range must be nonzero
142 * The hash chain is sorted on range, so that subranges can override.
144 void blk_register_region(dev_t devt
, unsigned long range
, struct module
*module
,
145 struct kobject
*(*probe
)(dev_t
, int *, void *),
146 int (*lock
)(dev_t
, void *), void *data
)
148 kobj_map(bdev_map
, devt
, range
, module
, probe
, lock
, data
);
151 EXPORT_SYMBOL(blk_register_region
);
153 void blk_unregister_region(dev_t devt
, unsigned long range
)
155 kobj_unmap(bdev_map
, devt
, range
);
158 EXPORT_SYMBOL(blk_unregister_region
);
160 static struct kobject
*exact_match(dev_t devt
, int *part
, void *data
)
162 struct gendisk
*p
= data
;
167 static int exact_lock(dev_t devt
, void *data
)
169 struct gendisk
*p
= data
;
177 * add_disk - add partitioning information to kernel list
178 * @disk: per-device partitioning information
180 * This function registers the partitioning information in @disk
183 void add_disk(struct gendisk
*disk
)
185 struct backing_dev_info
*bdi
;
187 disk
->flags
|= GENHD_FL_UP
;
188 blk_register_region(MKDEV(disk
->major
, disk
->first_minor
),
189 disk
->minors
, NULL
, exact_match
, exact_lock
, disk
);
191 blk_register_queue(disk
);
192 blk_register_filter(disk
);
194 bdi
= &disk
->queue
->backing_dev_info
;
195 bdi_register_dev(bdi
, MKDEV(disk
->major
, disk
->first_minor
));
196 sysfs_create_link(&disk
->dev
.kobj
, &bdi
->dev
->kobj
, "bdi");
199 EXPORT_SYMBOL(add_disk
);
200 EXPORT_SYMBOL(del_gendisk
); /* in partitions/check.c */
202 void unlink_gendisk(struct gendisk
*disk
)
204 blk_unregister_filter(disk
);
205 sysfs_remove_link(&disk
->dev
.kobj
, "bdi");
206 bdi_unregister(&disk
->queue
->backing_dev_info
);
207 blk_unregister_queue(disk
);
208 blk_unregister_region(MKDEV(disk
->major
, disk
->first_minor
),
213 * get_gendisk - get partitioning information for a given device
214 * @dev: device to get partitioning information for
216 * This function gets the structure containing partitioning
217 * information for the given device @dev.
219 struct gendisk
*get_gendisk(dev_t devt
, int *part
)
221 struct kobject
*kobj
= kobj_lookup(bdev_map
, devt
, part
);
222 struct device
*dev
= kobj_to_dev(kobj
);
224 return kobj
? dev_to_disk(dev
) : NULL
;
228 * print a full list of all partitions - intended for places where the root
229 * filesystem can't be mounted and thus to give the victim some idea of what
232 void __init
printk_all_partitions(void)
236 char buf
[BDEVNAME_SIZE
];
239 mutex_lock(&block_class_lock
);
240 /* For each block device... */
241 list_for_each_entry(dev
, &block_class
.devices
, node
) {
242 if (dev
->type
!= &disk_type
)
244 sgp
= dev_to_disk(dev
);
246 * Don't show empty devices or things that have been surpressed
248 if (get_capacity(sgp
) == 0 ||
249 (sgp
->flags
& GENHD_FL_SUPPRESS_PARTITION_INFO
))
253 * Note, unlike /proc/partitions, I am showing the numbers in
254 * hex - the same format as the root= option takes.
256 printk("%02x%02x %10llu %s",
257 sgp
->major
, sgp
->first_minor
,
258 (unsigned long long)get_capacity(sgp
) >> 1,
259 disk_name(sgp
, 0, buf
));
260 if (sgp
->driverfs_dev
!= NULL
&&
261 sgp
->driverfs_dev
->driver
!= NULL
)
262 printk(" driver: %s\n",
263 sgp
->driverfs_dev
->driver
->name
);
265 printk(" (driver?)\n");
267 /* now show the partitions */
268 for (n
= 0; n
< sgp
->minors
- 1; ++n
) {
269 if (sgp
->part
[n
] == NULL
)
271 if (sgp
->part
[n
]->nr_sects
== 0)
273 printk(" %02x%02x %10llu %s\n",
274 sgp
->major
, n
+ 1 + sgp
->first_minor
,
275 (unsigned long long)sgp
->part
[n
]->nr_sects
>> 1,
276 disk_name(sgp
, n
+ 1, buf
));
280 mutex_unlock(&block_class_lock
);
283 #ifdef CONFIG_PROC_FS
285 static void *part_start(struct seq_file
*part
, loff_t
*pos
)
290 mutex_lock(&block_class_lock
);
291 list_for_each_entry(dev
, &block_class
.devices
, node
) {
292 if (dev
->type
!= &disk_type
)
295 return dev_to_disk(dev
);
300 static void *part_next(struct seq_file
*part
, void *v
, loff_t
*pos
)
302 struct gendisk
*gp
= v
;
305 list_for_each_entry(dev
, &gp
->dev
.node
, node
) {
306 if (&dev
->node
== &block_class
.devices
)
308 if (dev
->type
== &disk_type
)
309 return dev_to_disk(dev
);
314 static void part_stop(struct seq_file
*part
, void *v
)
316 mutex_unlock(&block_class_lock
);
319 static int show_partition(struct seq_file
*part
, void *v
)
321 struct gendisk
*sgp
= v
;
323 char buf
[BDEVNAME_SIZE
];
325 if (&sgp
->dev
.node
== block_class
.devices
.next
)
326 seq_puts(part
, "major minor #blocks name\n\n");
328 /* Don't show non-partitionable removeable devices or empty devices */
329 if (!get_capacity(sgp
) ||
330 (sgp
->minors
== 1 && (sgp
->flags
& GENHD_FL_REMOVABLE
)))
332 if (sgp
->flags
& GENHD_FL_SUPPRESS_PARTITION_INFO
)
335 /* show the full disk and all non-0 size partitions of it */
336 seq_printf(part
, "%4d %4d %10llu %s\n",
337 sgp
->major
, sgp
->first_minor
,
338 (unsigned long long)get_capacity(sgp
) >> 1,
339 disk_name(sgp
, 0, buf
));
340 for (n
= 0; n
< sgp
->minors
- 1; n
++) {
343 if (sgp
->part
[n
]->nr_sects
== 0)
345 seq_printf(part
, "%4d %4d %10llu %s\n",
346 sgp
->major
, n
+ 1 + sgp
->first_minor
,
347 (unsigned long long)sgp
->part
[n
]->nr_sects
>> 1 ,
348 disk_name(sgp
, n
+ 1, buf
));
354 const struct seq_operations partitions_op
= {
358 .show
= show_partition
363 static struct kobject
*base_probe(dev_t devt
, int *part
, void *data
)
365 if (request_module("block-major-%d-%d", MAJOR(devt
), MINOR(devt
)) > 0)
366 /* Make old-style 2.4 aliases work */
367 request_module("block-major-%d", MAJOR(devt
));
371 static int __init
genhd_device_init(void)
375 block_class
.dev_kobj
= sysfs_dev_block_kobj
;
376 error
= class_register(&block_class
);
379 bdev_map
= kobj_map_init(base_probe
, &block_class_lock
);
382 #ifndef CONFIG_SYSFS_DEPRECATED
383 /* create top-level block dir */
384 block_depr
= kobject_create_and_add("block", NULL
);
389 subsys_initcall(genhd_device_init
);
391 static ssize_t
disk_range_show(struct device
*dev
,
392 struct device_attribute
*attr
, char *buf
)
394 struct gendisk
*disk
= dev_to_disk(dev
);
396 return sprintf(buf
, "%d\n", disk
->minors
);
399 static ssize_t
disk_removable_show(struct device
*dev
,
400 struct device_attribute
*attr
, char *buf
)
402 struct gendisk
*disk
= dev_to_disk(dev
);
404 return sprintf(buf
, "%d\n",
405 (disk
->flags
& GENHD_FL_REMOVABLE
? 1 : 0));
408 static ssize_t
disk_ro_show(struct device
*dev
,
409 struct device_attribute
*attr
, char *buf
)
411 struct gendisk
*disk
= dev_to_disk(dev
);
413 return sprintf(buf
, "%d\n", disk
->policy
? 1 : 0);
416 static ssize_t
disk_size_show(struct device
*dev
,
417 struct device_attribute
*attr
, char *buf
)
419 struct gendisk
*disk
= dev_to_disk(dev
);
421 return sprintf(buf
, "%llu\n", (unsigned long long)get_capacity(disk
));
424 static ssize_t
disk_capability_show(struct device
*dev
,
425 struct device_attribute
*attr
, char *buf
)
427 struct gendisk
*disk
= dev_to_disk(dev
);
429 return sprintf(buf
, "%x\n", disk
->flags
);
432 static ssize_t
disk_stat_show(struct device
*dev
,
433 struct device_attribute
*attr
, char *buf
)
435 struct gendisk
*disk
= dev_to_disk(dev
);
438 disk_round_stats(disk
);
441 "%8lu %8lu %8llu %8u "
442 "%8lu %8lu %8llu %8u "
445 disk_stat_read(disk
, ios
[READ
]),
446 disk_stat_read(disk
, merges
[READ
]),
447 (unsigned long long)disk_stat_read(disk
, sectors
[READ
]),
448 jiffies_to_msecs(disk_stat_read(disk
, ticks
[READ
])),
449 disk_stat_read(disk
, ios
[WRITE
]),
450 disk_stat_read(disk
, merges
[WRITE
]),
451 (unsigned long long)disk_stat_read(disk
, sectors
[WRITE
]),
452 jiffies_to_msecs(disk_stat_read(disk
, ticks
[WRITE
])),
454 jiffies_to_msecs(disk_stat_read(disk
, io_ticks
)),
455 jiffies_to_msecs(disk_stat_read(disk
, time_in_queue
)));
458 #ifdef CONFIG_FAIL_MAKE_REQUEST
459 static ssize_t
disk_fail_show(struct device
*dev
,
460 struct device_attribute
*attr
, char *buf
)
462 struct gendisk
*disk
= dev_to_disk(dev
);
464 return sprintf(buf
, "%d\n", disk
->flags
& GENHD_FL_FAIL
? 1 : 0);
467 static ssize_t
disk_fail_store(struct device
*dev
,
468 struct device_attribute
*attr
,
469 const char *buf
, size_t count
)
471 struct gendisk
*disk
= dev_to_disk(dev
);
474 if (count
> 0 && sscanf(buf
, "%d", &i
) > 0) {
476 disk
->flags
&= ~GENHD_FL_FAIL
;
478 disk
->flags
|= GENHD_FL_FAIL
;
486 static DEVICE_ATTR(range
, S_IRUGO
, disk_range_show
, NULL
);
487 static DEVICE_ATTR(removable
, S_IRUGO
, disk_removable_show
, NULL
);
488 static DEVICE_ATTR(ro
, S_IRUGO
, disk_ro_show
, NULL
);
489 static DEVICE_ATTR(size
, S_IRUGO
, disk_size_show
, NULL
);
490 static DEVICE_ATTR(capability
, S_IRUGO
, disk_capability_show
, NULL
);
491 static DEVICE_ATTR(stat
, S_IRUGO
, disk_stat_show
, NULL
);
492 #ifdef CONFIG_FAIL_MAKE_REQUEST
493 static struct device_attribute dev_attr_fail
=
494 __ATTR(make
-it
-fail
, S_IRUGO
|S_IWUSR
, disk_fail_show
, disk_fail_store
);
497 static struct attribute
*disk_attrs
[] = {
498 &dev_attr_range
.attr
,
499 &dev_attr_removable
.attr
,
502 &dev_attr_capability
.attr
,
504 #ifdef CONFIG_FAIL_MAKE_REQUEST
510 static struct attribute_group disk_attr_group
= {
514 static struct attribute_group
*disk_attr_groups
[] = {
519 static void disk_release(struct device
*dev
)
521 struct gendisk
*disk
= dev_to_disk(dev
);
525 free_disk_stats(disk
);
528 struct class block_class
= {
532 static struct device_type disk_type
= {
534 .groups
= disk_attr_groups
,
535 .release
= disk_release
,
539 * aggregate disk stat collector. Uses the same stats that the sysfs
540 * entries do, above, but makes them available through one seq_file.
542 * The output looks suspiciously like /proc/partitions with a bunch of
546 static void *diskstats_start(struct seq_file
*part
, loff_t
*pos
)
551 mutex_lock(&block_class_lock
);
552 list_for_each_entry(dev
, &block_class
.devices
, node
) {
553 if (dev
->type
!= &disk_type
)
556 return dev_to_disk(dev
);
561 static void *diskstats_next(struct seq_file
*part
, void *v
, loff_t
*pos
)
563 struct gendisk
*gp
= v
;
567 list_for_each_entry(dev
, &gp
->dev
.node
, node
) {
568 if (&dev
->node
== &block_class
.devices
)
570 if (dev
->type
== &disk_type
)
571 return dev_to_disk(dev
);
576 static void diskstats_stop(struct seq_file
*part
, void *v
)
578 mutex_unlock(&block_class_lock
);
581 static int diskstats_show(struct seq_file
*s
, void *v
)
583 struct gendisk
*gp
= v
;
584 char buf
[BDEVNAME_SIZE
];
588 if (&gp->dev.kobj.entry == block_class.devices.next)
589 seq_puts(s, "major minor name"
590 " rio rmerge rsect ruse wio wmerge "
591 "wsect wuse running use aveq"
596 disk_round_stats(gp
);
598 seq_printf(s
, "%4d %4d %s %lu %lu %llu %u %lu %lu %llu %u %u %u %u\n",
599 gp
->major
, n
+ gp
->first_minor
, disk_name(gp
, n
, buf
),
600 disk_stat_read(gp
, ios
[0]), disk_stat_read(gp
, merges
[0]),
601 (unsigned long long)disk_stat_read(gp
, sectors
[0]),
602 jiffies_to_msecs(disk_stat_read(gp
, ticks
[0])),
603 disk_stat_read(gp
, ios
[1]), disk_stat_read(gp
, merges
[1]),
604 (unsigned long long)disk_stat_read(gp
, sectors
[1]),
605 jiffies_to_msecs(disk_stat_read(gp
, ticks
[1])),
607 jiffies_to_msecs(disk_stat_read(gp
, io_ticks
)),
608 jiffies_to_msecs(disk_stat_read(gp
, time_in_queue
)));
610 /* now show all non-0 size partitions of it */
611 for (n
= 0; n
< gp
->minors
- 1; n
++) {
612 struct hd_struct
*hd
= gp
->part
[n
];
614 if (!hd
|| !hd
->nr_sects
)
618 part_round_stats(hd
);
620 seq_printf(s
, "%4d %4d %s %lu %lu %llu "
621 "%u %lu %lu %llu %u %u %u %u\n",
622 gp
->major
, n
+ gp
->first_minor
+ 1,
623 disk_name(gp
, n
+ 1, buf
),
624 part_stat_read(hd
, ios
[0]),
625 part_stat_read(hd
, merges
[0]),
626 (unsigned long long)part_stat_read(hd
, sectors
[0]),
627 jiffies_to_msecs(part_stat_read(hd
, ticks
[0])),
628 part_stat_read(hd
, ios
[1]),
629 part_stat_read(hd
, merges
[1]),
630 (unsigned long long)part_stat_read(hd
, sectors
[1]),
631 jiffies_to_msecs(part_stat_read(hd
, ticks
[1])),
633 jiffies_to_msecs(part_stat_read(hd
, io_ticks
)),
634 jiffies_to_msecs(part_stat_read(hd
, time_in_queue
))
641 const struct seq_operations diskstats_op
= {
642 .start
= diskstats_start
,
643 .next
= diskstats_next
,
644 .stop
= diskstats_stop
,
645 .show
= diskstats_show
648 static void media_change_notify_thread(struct work_struct
*work
)
650 struct gendisk
*gd
= container_of(work
, struct gendisk
, async_notify
);
651 char event
[] = "MEDIA_CHANGE=1";
652 char *envp
[] = { event
, NULL
};
655 * set enviroment vars to indicate which event this is for
656 * so that user space will know to go check the media status.
658 kobject_uevent_env(&gd
->dev
.kobj
, KOBJ_CHANGE
, envp
);
659 put_device(gd
->driverfs_dev
);
663 void genhd_media_change_notify(struct gendisk
*disk
)
665 get_device(disk
->driverfs_dev
);
666 schedule_work(&disk
->async_notify
);
668 EXPORT_SYMBOL_GPL(genhd_media_change_notify
);
671 dev_t
blk_lookup_devt(const char *name
, int part
)
674 dev_t devt
= MKDEV(0, 0);
676 mutex_lock(&block_class_lock
);
677 list_for_each_entry(dev
, &block_class
.devices
, node
) {
678 if (dev
->type
!= &disk_type
)
680 if (strcmp(dev
->bus_id
, name
) == 0) {
681 struct gendisk
*disk
= dev_to_disk(dev
);
683 if (part
< disk
->minors
)
684 devt
= MKDEV(MAJOR(dev
->devt
),
685 MINOR(dev
->devt
) + part
);
689 mutex_unlock(&block_class_lock
);
693 EXPORT_SYMBOL(blk_lookup_devt
);
695 struct gendisk
*alloc_disk(int minors
)
697 return alloc_disk_node(minors
, -1);
700 struct gendisk
*alloc_disk_node(int minors
, int node_id
)
702 struct gendisk
*disk
;
704 disk
= kmalloc_node(sizeof(struct gendisk
),
705 GFP_KERNEL
| __GFP_ZERO
, node_id
);
707 if (!init_disk_stats(disk
)) {
712 int size
= (minors
- 1) * sizeof(struct hd_struct
*);
713 disk
->part
= kmalloc_node(size
,
714 GFP_KERNEL
| __GFP_ZERO
, node_id
);
716 free_disk_stats(disk
);
721 disk
->minors
= minors
;
722 rand_initialize_disk(disk
);
723 disk
->dev
.class = &block_class
;
724 disk
->dev
.type
= &disk_type
;
725 device_initialize(&disk
->dev
);
726 INIT_WORK(&disk
->async_notify
,
727 media_change_notify_thread
);
732 EXPORT_SYMBOL(alloc_disk
);
733 EXPORT_SYMBOL(alloc_disk_node
);
735 struct kobject
*get_disk(struct gendisk
*disk
)
737 struct module
*owner
;
738 struct kobject
*kobj
;
742 owner
= disk
->fops
->owner
;
743 if (owner
&& !try_module_get(owner
))
745 kobj
= kobject_get(&disk
->dev
.kobj
);
754 EXPORT_SYMBOL(get_disk
);
756 void put_disk(struct gendisk
*disk
)
759 kobject_put(&disk
->dev
.kobj
);
762 EXPORT_SYMBOL(put_disk
);
764 void set_device_ro(struct block_device
*bdev
, int flag
)
766 if (bdev
->bd_contains
!= bdev
)
767 bdev
->bd_part
->policy
= flag
;
769 bdev
->bd_disk
->policy
= flag
;
772 EXPORT_SYMBOL(set_device_ro
);
774 void set_disk_ro(struct gendisk
*disk
, int flag
)
778 for (i
= 0; i
< disk
->minors
- 1; i
++)
779 if (disk
->part
[i
]) disk
->part
[i
]->policy
= flag
;
782 EXPORT_SYMBOL(set_disk_ro
);
784 int bdev_read_only(struct block_device
*bdev
)
788 else if (bdev
->bd_contains
!= bdev
)
789 return bdev
->bd_part
->policy
;
791 return bdev
->bd_disk
->policy
;
794 EXPORT_SYMBOL(bdev_read_only
);
796 int invalidate_partition(struct gendisk
*disk
, int index
)
799 struct block_device
*bdev
= bdget_disk(disk
, index
);
802 res
= __invalidate_device(bdev
);
808 EXPORT_SYMBOL(invalidate_partition
);