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>
20 struct kset block_subsys
;
21 static DEFINE_MUTEX(block_subsys_lock
);
24 * Can be deleted altogether. Later.
27 static struct blk_major_name
{
28 struct blk_major_name
*next
;
31 } *major_names
[BLKDEV_MAJOR_HASH_SIZE
];
33 /* index in the above - for now: assume no multimajor ranges */
34 static inline int major_to_index(int major
)
36 return major
% BLKDEV_MAJOR_HASH_SIZE
;
41 void blkdev_show(struct seq_file
*f
, off_t offset
)
43 struct blk_major_name
*dp
;
45 if (offset
< BLKDEV_MAJOR_HASH_SIZE
) {
46 mutex_lock(&block_subsys_lock
);
47 for (dp
= major_names
[offset
]; dp
; dp
= dp
->next
)
48 seq_printf(f
, "%3d %s\n", dp
->major
, dp
->name
);
49 mutex_unlock(&block_subsys_lock
);
53 #endif /* CONFIG_PROC_FS */
55 int register_blkdev(unsigned int major
, const char *name
)
57 struct blk_major_name
**n
, *p
;
60 mutex_lock(&block_subsys_lock
);
64 for (index
= ARRAY_SIZE(major_names
)-1; index
> 0; index
--) {
65 if (major_names
[index
] == NULL
)
70 printk("register_blkdev: failed to get major for %s\n",
79 p
= kmalloc(sizeof(struct blk_major_name
), GFP_KERNEL
);
86 strlcpy(p
->name
, name
, sizeof(p
->name
));
88 index
= major_to_index(major
);
90 for (n
= &major_names
[index
]; *n
; n
= &(*n
)->next
) {
91 if ((*n
)->major
== major
)
100 printk("register_blkdev: cannot get major %d for %s\n",
105 mutex_unlock(&block_subsys_lock
);
109 EXPORT_SYMBOL(register_blkdev
);
111 /* todo: make void - error printk here */
112 int unregister_blkdev(unsigned int major
, const char *name
)
114 struct blk_major_name
**n
;
115 struct blk_major_name
*p
= NULL
;
116 int index
= major_to_index(major
);
119 mutex_lock(&block_subsys_lock
);
120 for (n
= &major_names
[index
]; *n
; n
= &(*n
)->next
)
121 if ((*n
)->major
== major
)
123 if (!*n
|| strcmp((*n
)->name
, name
))
129 mutex_unlock(&block_subsys_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 dev
, 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
, dev
, range
, module
, probe
, lock
, data
);
151 EXPORT_SYMBOL(blk_register_region
);
153 void blk_unregister_region(dev_t dev
, unsigned long range
)
155 kobj_unmap(bdev_map
, dev
, range
);
158 EXPORT_SYMBOL(blk_unregister_region
);
160 static struct kobject
*exact_match(dev_t dev
, int *part
, void *data
)
162 struct gendisk
*p
= data
;
166 static int exact_lock(dev_t dev
, void *data
)
168 struct gendisk
*p
= data
;
176 * add_disk - add partitioning information to kernel list
177 * @disk: per-device partitioning information
179 * This function registers the partitioning information in @disk
182 void add_disk(struct gendisk
*disk
)
184 disk
->flags
|= GENHD_FL_UP
;
185 blk_register_region(MKDEV(disk
->major
, disk
->first_minor
),
186 disk
->minors
, NULL
, exact_match
, exact_lock
, disk
);
188 blk_register_queue(disk
);
191 EXPORT_SYMBOL(add_disk
);
192 EXPORT_SYMBOL(del_gendisk
); /* in partitions/check.c */
194 void unlink_gendisk(struct gendisk
*disk
)
196 blk_unregister_queue(disk
);
197 blk_unregister_region(MKDEV(disk
->major
, disk
->first_minor
),
201 #define to_disk(obj) container_of(obj,struct gendisk,kobj)
204 * get_gendisk - get partitioning information for a given device
205 * @dev: device to get partitioning information for
207 * This function gets the structure containing partitioning
208 * information for the given device @dev.
210 struct gendisk
*get_gendisk(dev_t dev
, int *part
)
212 struct kobject
*kobj
= kobj_lookup(bdev_map
, dev
, part
);
213 return kobj
? to_disk(kobj
) : NULL
;
217 * print a full list of all partitions - intended for places where the root
218 * filesystem can't be mounted and thus to give the victim some idea of what
221 void __init
printk_all_partitions(void)
226 mutex_lock(&block_subsys_lock
);
227 /* For each block device... */
228 list_for_each_entry(sgp
, &block_subsys
.list
, kobj
.entry
) {
229 char buf
[BDEVNAME_SIZE
];
231 * Don't show empty devices or things that have been surpressed
233 if (get_capacity(sgp
) == 0 ||
234 (sgp
->flags
& GENHD_FL_SUPPRESS_PARTITION_INFO
))
238 * Note, unlike /proc/partitions, I am showing the numbers in
239 * hex - the same format as the root= option takes.
241 printk("%02x%02x %10llu %s",
242 sgp
->major
, sgp
->first_minor
,
243 (unsigned long long)get_capacity(sgp
) >> 1,
244 disk_name(sgp
, 0, buf
));
245 if (sgp
->driverfs_dev
!= NULL
&&
246 sgp
->driverfs_dev
->driver
!= NULL
)
247 printk(" driver: %s\n",
248 sgp
->driverfs_dev
->driver
->name
);
250 printk(" (driver?)\n");
252 /* now show the partitions */
253 for (n
= 0; n
< sgp
->minors
- 1; ++n
) {
254 if (sgp
->part
[n
] == NULL
)
256 if (sgp
->part
[n
]->nr_sects
== 0)
258 printk(" %02x%02x %10llu %s\n",
259 sgp
->major
, n
+ 1 + sgp
->first_minor
,
260 (unsigned long long)sgp
->part
[n
]->nr_sects
>> 1,
261 disk_name(sgp
, n
+ 1, buf
));
262 } /* partition subloop */
263 } /* Block device loop */
265 mutex_unlock(&block_subsys_lock
);
269 #ifdef CONFIG_PROC_FS
271 static void *part_start(struct seq_file
*part
, loff_t
*pos
)
276 mutex_lock(&block_subsys_lock
);
277 list_for_each(p
, &block_subsys
.list
)
279 return list_entry(p
, struct gendisk
, kobj
.entry
);
283 static void *part_next(struct seq_file
*part
, void *v
, loff_t
*pos
)
285 struct list_head
*p
= ((struct gendisk
*)v
)->kobj
.entry
.next
;
287 return p
==&block_subsys
.list
? NULL
:
288 list_entry(p
, struct gendisk
, kobj
.entry
);
291 static void part_stop(struct seq_file
*part
, void *v
)
293 mutex_unlock(&block_subsys_lock
);
296 static int show_partition(struct seq_file
*part
, void *v
)
298 struct gendisk
*sgp
= v
;
300 char buf
[BDEVNAME_SIZE
];
302 if (&sgp
->kobj
.entry
== block_subsys
.list
.next
)
303 seq_puts(part
, "major minor #blocks name\n\n");
305 /* Don't show non-partitionable removeable devices or empty devices */
306 if (!get_capacity(sgp
) ||
307 (sgp
->minors
== 1 && (sgp
->flags
& GENHD_FL_REMOVABLE
)))
309 if (sgp
->flags
& GENHD_FL_SUPPRESS_PARTITION_INFO
)
312 /* show the full disk and all non-0 size partitions of it */
313 seq_printf(part
, "%4d %4d %10llu %s\n",
314 sgp
->major
, sgp
->first_minor
,
315 (unsigned long long)get_capacity(sgp
) >> 1,
316 disk_name(sgp
, 0, buf
));
317 for (n
= 0; n
< sgp
->minors
- 1; n
++) {
320 if (sgp
->part
[n
]->nr_sects
== 0)
322 seq_printf(part
, "%4d %4d %10llu %s\n",
323 sgp
->major
, n
+ 1 + sgp
->first_minor
,
324 (unsigned long long)sgp
->part
[n
]->nr_sects
>> 1 ,
325 disk_name(sgp
, n
+ 1, buf
));
331 struct seq_operations partitions_op
= {
335 .show
= show_partition
340 extern int blk_dev_init(void);
342 static struct kobject
*base_probe(dev_t dev
, int *part
, void *data
)
344 if (request_module("block-major-%d-%d", MAJOR(dev
), MINOR(dev
)) > 0)
345 /* Make old-style 2.4 aliases work */
346 request_module("block-major-%d", MAJOR(dev
));
350 static int __init
genhd_device_init(void)
354 bdev_map
= kobj_map_init(base_probe
, &block_subsys_lock
);
356 err
= subsystem_register(&block_subsys
);
358 printk(KERN_WARNING
"%s: subsystem_register error: %d\n",
363 subsys_initcall(genhd_device_init
);
368 * kobject & sysfs bindings for block devices
370 static ssize_t
disk_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
373 struct gendisk
*disk
= to_disk(kobj
);
374 struct disk_attribute
*disk_attr
=
375 container_of(attr
,struct disk_attribute
,attr
);
379 ret
= disk_attr
->show(disk
,page
);
383 static ssize_t
disk_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
384 const char *page
, size_t count
)
386 struct gendisk
*disk
= to_disk(kobj
);
387 struct disk_attribute
*disk_attr
=
388 container_of(attr
,struct disk_attribute
,attr
);
391 if (disk_attr
->store
)
392 ret
= disk_attr
->store(disk
, page
, count
);
396 static struct sysfs_ops disk_sysfs_ops
= {
397 .show
= &disk_attr_show
,
398 .store
= &disk_attr_store
,
401 static ssize_t
disk_uevent_store(struct gendisk
* disk
,
402 const char *buf
, size_t count
)
404 kobject_uevent(&disk
->kobj
, KOBJ_ADD
);
407 static ssize_t
disk_dev_read(struct gendisk
* disk
, char *page
)
409 dev_t base
= MKDEV(disk
->major
, disk
->first_minor
);
410 return print_dev_t(page
, base
);
412 static ssize_t
disk_range_read(struct gendisk
* disk
, char *page
)
414 return sprintf(page
, "%d\n", disk
->minors
);
416 static ssize_t
disk_removable_read(struct gendisk
* disk
, char *page
)
418 return sprintf(page
, "%d\n",
419 (disk
->flags
& GENHD_FL_REMOVABLE
? 1 : 0));
422 static ssize_t
disk_size_read(struct gendisk
* disk
, char *page
)
424 return sprintf(page
, "%llu\n", (unsigned long long)get_capacity(disk
));
426 static ssize_t
disk_capability_read(struct gendisk
*disk
, char *page
)
428 return sprintf(page
, "%x\n", disk
->flags
);
430 static ssize_t
disk_stats_read(struct gendisk
* disk
, char *page
)
433 disk_round_stats(disk
);
436 "%8lu %8lu %8llu %8u "
437 "%8lu %8lu %8llu %8u "
440 disk_stat_read(disk
, ios
[READ
]),
441 disk_stat_read(disk
, merges
[READ
]),
442 (unsigned long long)disk_stat_read(disk
, sectors
[READ
]),
443 jiffies_to_msecs(disk_stat_read(disk
, ticks
[READ
])),
444 disk_stat_read(disk
, ios
[WRITE
]),
445 disk_stat_read(disk
, merges
[WRITE
]),
446 (unsigned long long)disk_stat_read(disk
, sectors
[WRITE
]),
447 jiffies_to_msecs(disk_stat_read(disk
, ticks
[WRITE
])),
449 jiffies_to_msecs(disk_stat_read(disk
, io_ticks
)),
450 jiffies_to_msecs(disk_stat_read(disk
, time_in_queue
)));
452 static struct disk_attribute disk_attr_uevent
= {
453 .attr
= {.name
= "uevent", .mode
= S_IWUSR
},
454 .store
= disk_uevent_store
456 static struct disk_attribute disk_attr_dev
= {
457 .attr
= {.name
= "dev", .mode
= S_IRUGO
},
458 .show
= disk_dev_read
460 static struct disk_attribute disk_attr_range
= {
461 .attr
= {.name
= "range", .mode
= S_IRUGO
},
462 .show
= disk_range_read
464 static struct disk_attribute disk_attr_removable
= {
465 .attr
= {.name
= "removable", .mode
= S_IRUGO
},
466 .show
= disk_removable_read
468 static struct disk_attribute disk_attr_size
= {
469 .attr
= {.name
= "size", .mode
= S_IRUGO
},
470 .show
= disk_size_read
472 static struct disk_attribute disk_attr_capability
= {
473 .attr
= {.name
= "capability", .mode
= S_IRUGO
},
474 .show
= disk_capability_read
476 static struct disk_attribute disk_attr_stat
= {
477 .attr
= {.name
= "stat", .mode
= S_IRUGO
},
478 .show
= disk_stats_read
481 #ifdef CONFIG_FAIL_MAKE_REQUEST
483 static ssize_t
disk_fail_store(struct gendisk
* disk
,
484 const char *buf
, size_t count
)
488 if (count
> 0 && sscanf(buf
, "%d", &i
) > 0) {
490 disk
->flags
&= ~GENHD_FL_FAIL
;
492 disk
->flags
|= GENHD_FL_FAIL
;
497 static ssize_t
disk_fail_read(struct gendisk
* disk
, char *page
)
499 return sprintf(page
, "%d\n", disk
->flags
& GENHD_FL_FAIL
? 1 : 0);
501 static struct disk_attribute disk_attr_fail
= {
502 .attr
= {.name
= "make-it-fail", .mode
= S_IRUGO
| S_IWUSR
},
503 .store
= disk_fail_store
,
504 .show
= disk_fail_read
509 static struct attribute
* default_attrs
[] = {
510 &disk_attr_uevent
.attr
,
512 &disk_attr_range
.attr
,
513 &disk_attr_removable
.attr
,
514 &disk_attr_size
.attr
,
515 &disk_attr_stat
.attr
,
516 &disk_attr_capability
.attr
,
517 #ifdef CONFIG_FAIL_MAKE_REQUEST
518 &disk_attr_fail
.attr
,
523 static void disk_release(struct kobject
* kobj
)
525 struct gendisk
*disk
= to_disk(kobj
);
528 free_disk_stats(disk
);
532 static struct kobj_type ktype_block
= {
533 .release
= disk_release
,
534 .sysfs_ops
= &disk_sysfs_ops
,
535 .default_attrs
= default_attrs
,
538 extern struct kobj_type ktype_part
;
540 static int block_uevent_filter(struct kset
*kset
, struct kobject
*kobj
)
542 struct kobj_type
*ktype
= get_ktype(kobj
);
544 return ((ktype
== &ktype_block
) || (ktype
== &ktype_part
));
547 static int block_uevent(struct kset
*kset
, struct kobject
*kobj
, char **envp
,
548 int num_envp
, char *buffer
, int buffer_size
)
550 struct kobj_type
*ktype
= get_ktype(kobj
);
551 struct device
*physdev
;
552 struct gendisk
*disk
;
553 struct hd_struct
*part
;
557 if (ktype
== &ktype_block
) {
558 disk
= container_of(kobj
, struct gendisk
, kobj
);
559 add_uevent_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
560 &length
, "MINOR=%u", disk
->first_minor
);
561 } else if (ktype
== &ktype_part
) {
562 disk
= container_of(kobj
->parent
, struct gendisk
, kobj
);
563 part
= container_of(kobj
, struct hd_struct
, kobj
);
564 add_uevent_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
566 disk
->first_minor
+ part
->partno
);
570 add_uevent_var(envp
, num_envp
, &i
, buffer
, buffer_size
, &length
,
571 "MAJOR=%u", disk
->major
);
573 /* add physical device, backing this device */
574 physdev
= disk
->driverfs_dev
;
576 char *path
= kobject_get_path(&physdev
->kobj
, GFP_KERNEL
);
578 add_uevent_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
579 &length
, "PHYSDEVPATH=%s", path
);
583 add_uevent_var(envp
, num_envp
, &i
,
584 buffer
, buffer_size
, &length
,
589 add_uevent_var(envp
, num_envp
, &i
,
590 buffer
, buffer_size
, &length
,
592 physdev
->driver
->name
);
595 /* terminate, set to next free slot, shrink available space */
599 buffer
= &buffer
[length
];
600 buffer_size
-= length
;
605 static struct kset_uevent_ops block_uevent_ops
= {
606 .filter
= block_uevent_filter
,
607 .uevent
= block_uevent
,
610 decl_subsys(block
, &ktype_block
, &block_uevent_ops
);
613 * aggregate disk stat collector. Uses the same stats that the sysfs
614 * entries do, above, but makes them available through one seq_file.
615 * Watching a few disks may be efficient through sysfs, but watching
616 * all of them will be more efficient through this interface.
618 * The output looks suspiciously like /proc/partitions with a bunch of
623 static void *diskstats_start(struct seq_file
*part
, loff_t
*pos
)
628 mutex_lock(&block_subsys_lock
);
629 list_for_each(p
, &block_subsys
.list
)
631 return list_entry(p
, struct gendisk
, kobj
.entry
);
635 static void *diskstats_next(struct seq_file
*part
, void *v
, loff_t
*pos
)
637 struct list_head
*p
= ((struct gendisk
*)v
)->kobj
.entry
.next
;
639 return p
==&block_subsys
.list
? NULL
:
640 list_entry(p
, struct gendisk
, kobj
.entry
);
643 static void diskstats_stop(struct seq_file
*part
, void *v
)
645 mutex_unlock(&block_subsys_lock
);
648 static int diskstats_show(struct seq_file
*s
, void *v
)
650 struct gendisk
*gp
= v
;
651 char buf
[BDEVNAME_SIZE
];
655 if (&sgp->kobj.entry == block_subsys.kset.list.next)
656 seq_puts(s, "major minor name"
657 " rio rmerge rsect ruse wio wmerge "
658 "wsect wuse running use aveq"
663 disk_round_stats(gp
);
665 seq_printf(s
, "%4d %4d %s %lu %lu %llu %u %lu %lu %llu %u %u %u %u\n",
666 gp
->major
, n
+ gp
->first_minor
, disk_name(gp
, n
, buf
),
667 disk_stat_read(gp
, ios
[0]), disk_stat_read(gp
, merges
[0]),
668 (unsigned long long)disk_stat_read(gp
, sectors
[0]),
669 jiffies_to_msecs(disk_stat_read(gp
, ticks
[0])),
670 disk_stat_read(gp
, ios
[1]), disk_stat_read(gp
, merges
[1]),
671 (unsigned long long)disk_stat_read(gp
, sectors
[1]),
672 jiffies_to_msecs(disk_stat_read(gp
, ticks
[1])),
674 jiffies_to_msecs(disk_stat_read(gp
, io_ticks
)),
675 jiffies_to_msecs(disk_stat_read(gp
, time_in_queue
)));
677 /* now show all non-0 size partitions of it */
678 for (n
= 0; n
< gp
->minors
- 1; n
++) {
679 struct hd_struct
*hd
= gp
->part
[n
];
681 if (hd
&& hd
->nr_sects
)
682 seq_printf(s
, "%4d %4d %s %u %u %u %u\n",
683 gp
->major
, n
+ gp
->first_minor
+ 1,
684 disk_name(gp
, n
+ 1, buf
),
685 hd
->ios
[0], hd
->sectors
[0],
686 hd
->ios
[1], hd
->sectors
[1]);
692 struct seq_operations diskstats_op
= {
693 .start
= diskstats_start
,
694 .next
= diskstats_next
,
695 .stop
= diskstats_stop
,
696 .show
= diskstats_show
699 struct gendisk
*alloc_disk(int minors
)
701 return alloc_disk_node(minors
, -1);
704 struct gendisk
*alloc_disk_node(int minors
, int node_id
)
706 struct gendisk
*disk
;
708 disk
= kmalloc_node(sizeof(struct gendisk
), GFP_KERNEL
, node_id
);
710 memset(disk
, 0, sizeof(struct gendisk
));
711 if (!init_disk_stats(disk
)) {
716 int size
= (minors
- 1) * sizeof(struct hd_struct
*);
717 disk
->part
= kmalloc_node(size
, GFP_KERNEL
, node_id
);
722 memset(disk
->part
, 0, size
);
724 disk
->minors
= minors
;
725 kobj_set_kset_s(disk
,block_subsys
);
726 kobject_init(&disk
->kobj
);
727 rand_initialize_disk(disk
);
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
->kobj
);
754 EXPORT_SYMBOL(get_disk
);
756 void put_disk(struct gendisk
*disk
)
759 kobject_put(&disk
->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
);