5 #include <linux/config.h>
6 #include <linux/module.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 #include <linux/buffer_head.h>
19 #define MAX_PROBE_HASH 255 /* random */
21 static struct subsystem block_subsys
;
23 static DECLARE_MUTEX(block_subsys_sem
);
26 * Can be deleted altogether. Later.
29 static struct blk_major_name
{
30 struct blk_major_name
*next
;
33 } *major_names
[MAX_PROBE_HASH
];
35 /* index in the above - for now: assume no multimajor ranges */
36 static inline int major_to_index(int major
)
38 return major
% MAX_PROBE_HASH
;
42 /* get block device names in somewhat random order */
43 int get_blkdev_list(char *p
, int used
)
45 struct blk_major_name
*n
;
48 len
= snprintf(p
, (PAGE_SIZE
-used
), "\nBlock devices:\n");
50 down(&block_subsys_sem
);
51 for (i
= 0; i
< ARRAY_SIZE(major_names
); i
++) {
52 for (n
= major_names
[i
]; n
; n
= n
->next
) {
54 * If the curent string plus the 5 extra characters
55 * in the line would run us off the page, then we're done
57 if ((len
+ used
+ strlen(n
->name
) + 5) >= PAGE_SIZE
)
59 len
+= sprintf(p
+len
, "%3d %s\n",
64 up(&block_subsys_sem
);
70 int register_blkdev(unsigned int major
, const char *name
)
72 struct blk_major_name
**n
, *p
;
75 down(&block_subsys_sem
);
79 for (index
= ARRAY_SIZE(major_names
)-1; index
> 0; index
--) {
80 if (major_names
[index
] == NULL
)
85 printk("register_blkdev: failed to get major for %s\n",
94 p
= kmalloc(sizeof(struct blk_major_name
), GFP_KERNEL
);
101 strlcpy(p
->name
, name
, sizeof(p
->name
));
103 index
= major_to_index(major
);
105 for (n
= &major_names
[index
]; *n
; n
= &(*n
)->next
) {
106 if ((*n
)->major
== major
)
115 printk("register_blkdev: cannot get major %d for %s\n",
120 up(&block_subsys_sem
);
124 EXPORT_SYMBOL(register_blkdev
);
126 /* todo: make void - error printk here */
127 int unregister_blkdev(unsigned int major
, const char *name
)
129 struct blk_major_name
**n
;
130 struct blk_major_name
*p
= NULL
;
131 int index
= major_to_index(major
);
134 down(&block_subsys_sem
);
135 for (n
= &major_names
[index
]; *n
; n
= &(*n
)->next
)
136 if ((*n
)->major
== major
)
138 if (!*n
|| strcmp((*n
)->name
, name
))
144 up(&block_subsys_sem
);
150 EXPORT_SYMBOL(unregister_blkdev
);
152 static struct kobj_map
*bdev_map
;
155 * Register device numbers dev..(dev+range-1)
156 * range must be nonzero
157 * The hash chain is sorted on range, so that subranges can override.
159 void blk_register_region(dev_t dev
, unsigned long range
, struct module
*module
,
160 struct kobject
*(*probe
)(dev_t
, int *, void *),
161 int (*lock
)(dev_t
, void *), void *data
)
163 kobj_map(bdev_map
, dev
, range
, module
, probe
, lock
, data
);
166 EXPORT_SYMBOL(blk_register_region
);
168 void blk_unregister_region(dev_t dev
, unsigned long range
)
170 kobj_unmap(bdev_map
, dev
, range
);
173 EXPORT_SYMBOL(blk_unregister_region
);
175 static struct kobject
*exact_match(dev_t dev
, int *part
, void *data
)
177 struct gendisk
*p
= data
;
181 static int exact_lock(dev_t dev
, void *data
)
183 struct gendisk
*p
= data
;
191 * add_disk - add partitioning information to kernel list
192 * @disk: per-device partitioning information
194 * This function registers the partitioning information in @disk
197 void add_disk(struct gendisk
*disk
)
199 disk
->flags
|= GENHD_FL_UP
;
200 blk_register_region(MKDEV(disk
->major
, disk
->first_minor
),
201 disk
->minors
, NULL
, exact_match
, exact_lock
, disk
);
203 blk_register_queue(disk
);
206 EXPORT_SYMBOL(add_disk
);
207 EXPORT_SYMBOL(del_gendisk
); /* in partitions/check.c */
209 void unlink_gendisk(struct gendisk
*disk
)
211 blk_unregister_queue(disk
);
212 blk_unregister_region(MKDEV(disk
->major
, disk
->first_minor
),
216 #define to_disk(obj) container_of(obj,struct gendisk,kobj)
219 * get_gendisk - get partitioning information for a given device
220 * @dev: device to get partitioning information for
222 * This function gets the structure containing partitioning
223 * information for the given device @dev.
225 struct gendisk
*get_gendisk(dev_t dev
, int *part
)
227 struct kobject
*kobj
= kobj_lookup(bdev_map
, dev
, part
);
228 return kobj
? to_disk(kobj
) : NULL
;
231 #ifdef CONFIG_PROC_FS
233 static void *part_start(struct seq_file
*part
, loff_t
*pos
)
238 down(&block_subsys_sem
);
239 list_for_each(p
, &block_subsys
.kset
.list
)
241 return list_entry(p
, struct gendisk
, kobj
.entry
);
245 static void *part_next(struct seq_file
*part
, void *v
, loff_t
*pos
)
247 struct list_head
*p
= ((struct gendisk
*)v
)->kobj
.entry
.next
;
249 return p
==&block_subsys
.kset
.list
? NULL
:
250 list_entry(p
, struct gendisk
, kobj
.entry
);
253 static void part_stop(struct seq_file
*part
, void *v
)
255 up(&block_subsys_sem
);
258 static int show_partition(struct seq_file
*part
, void *v
)
260 struct gendisk
*sgp
= v
;
262 char buf
[BDEVNAME_SIZE
];
264 if (&sgp
->kobj
.entry
== block_subsys
.kset
.list
.next
)
265 seq_puts(part
, "major minor #blocks name\n\n");
267 /* Don't show non-partitionable removeable devices or empty devices */
268 if (!get_capacity(sgp
) ||
269 (sgp
->minors
== 1 && (sgp
->flags
& GENHD_FL_REMOVABLE
)))
271 if (sgp
->flags
& GENHD_FL_SUPPRESS_PARTITION_INFO
)
274 /* show the full disk and all non-0 size partitions of it */
275 seq_printf(part
, "%4d %4d %10llu %s\n",
276 sgp
->major
, sgp
->first_minor
,
277 (unsigned long long)get_capacity(sgp
) >> 1,
278 disk_name(sgp
, 0, buf
));
279 for (n
= 0; n
< sgp
->minors
- 1; n
++) {
282 if (sgp
->part
[n
]->nr_sects
== 0)
284 seq_printf(part
, "%4d %4d %10llu %s\n",
285 sgp
->major
, n
+ 1 + sgp
->first_minor
,
286 (unsigned long long)sgp
->part
[n
]->nr_sects
>> 1 ,
287 disk_name(sgp
, n
+ 1, buf
));
293 struct seq_operations partitions_op
= {
297 .show
= show_partition
302 extern int blk_dev_init(void);
304 static struct kobject
*base_probe(dev_t dev
, int *part
, void *data
)
306 if (request_module("block-major-%d-%d", MAJOR(dev
), MINOR(dev
)) > 0)
307 /* Make old-style 2.4 aliases work */
308 request_module("block-major-%d", MAJOR(dev
));
312 static int __init
genhd_device_init(void)
314 bdev_map
= kobj_map_init(base_probe
, &block_subsys_sem
);
316 subsystem_register(&block_subsys
);
320 subsys_initcall(genhd_device_init
);
325 * kobject & sysfs bindings for block devices
327 static ssize_t
disk_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
330 struct gendisk
*disk
= to_disk(kobj
);
331 struct disk_attribute
*disk_attr
=
332 container_of(attr
,struct disk_attribute
,attr
);
336 ret
= disk_attr
->show(disk
,page
);
340 static ssize_t
disk_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
341 const char *page
, size_t count
)
343 struct gendisk
*disk
= to_disk(kobj
);
344 struct disk_attribute
*disk_attr
=
345 container_of(attr
,struct disk_attribute
,attr
);
348 if (disk_attr
->store
)
349 ret
= disk_attr
->store(disk
, page
, count
);
353 static struct sysfs_ops disk_sysfs_ops
= {
354 .show
= &disk_attr_show
,
355 .store
= &disk_attr_store
,
358 static ssize_t
disk_uevent_store(struct gendisk
* disk
,
359 const char *buf
, size_t count
)
361 kobject_hotplug(&disk
->kobj
, KOBJ_ADD
);
364 static ssize_t
disk_dev_read(struct gendisk
* disk
, char *page
)
366 dev_t base
= MKDEV(disk
->major
, disk
->first_minor
);
367 return print_dev_t(page
, base
);
369 static ssize_t
disk_range_read(struct gendisk
* disk
, char *page
)
371 return sprintf(page
, "%d\n", disk
->minors
);
373 static ssize_t
disk_removable_read(struct gendisk
* disk
, char *page
)
375 return sprintf(page
, "%d\n",
376 (disk
->flags
& GENHD_FL_REMOVABLE
? 1 : 0));
379 static ssize_t
disk_size_read(struct gendisk
* disk
, char *page
)
381 return sprintf(page
, "%llu\n", (unsigned long long)get_capacity(disk
));
384 static ssize_t
disk_stats_read(struct gendisk
* disk
, char *page
)
387 disk_round_stats(disk
);
394 disk_stat_read(disk
, reads
), disk_stat_read(disk
, read_merges
),
395 (unsigned long long)disk_stat_read(disk
, read_sectors
),
396 jiffies_to_msecs(disk_stat_read(disk
, read_ticks
)),
397 disk_stat_read(disk
, writes
),
398 disk_stat_read(disk
, write_merges
),
399 (unsigned long long)disk_stat_read(disk
, write_sectors
),
400 jiffies_to_msecs(disk_stat_read(disk
, write_ticks
)),
402 jiffies_to_msecs(disk_stat_read(disk
, io_ticks
)),
403 jiffies_to_msecs(disk_stat_read(disk
, time_in_queue
)));
405 static struct disk_attribute disk_attr_uevent
= {
406 .attr
= {.name
= "uevent", .mode
= S_IWUSR
},
407 .store
= disk_uevent_store
409 static struct disk_attribute disk_attr_dev
= {
410 .attr
= {.name
= "dev", .mode
= S_IRUGO
},
411 .show
= disk_dev_read
413 static struct disk_attribute disk_attr_range
= {
414 .attr
= {.name
= "range", .mode
= S_IRUGO
},
415 .show
= disk_range_read
417 static struct disk_attribute disk_attr_removable
= {
418 .attr
= {.name
= "removable", .mode
= S_IRUGO
},
419 .show
= disk_removable_read
421 static struct disk_attribute disk_attr_size
= {
422 .attr
= {.name
= "size", .mode
= S_IRUGO
},
423 .show
= disk_size_read
425 static struct disk_attribute disk_attr_stat
= {
426 .attr
= {.name
= "stat", .mode
= S_IRUGO
},
427 .show
= disk_stats_read
430 static struct attribute
* default_attrs
[] = {
431 &disk_attr_uevent
.attr
,
433 &disk_attr_range
.attr
,
434 &disk_attr_removable
.attr
,
435 &disk_attr_size
.attr
,
436 &disk_attr_stat
.attr
,
440 static void disk_release(struct kobject
* kobj
)
442 struct gendisk
*disk
= to_disk(kobj
);
445 free_disk_stats(disk
);
449 static struct kobj_type ktype_block
= {
450 .release
= disk_release
,
451 .sysfs_ops
= &disk_sysfs_ops
,
452 .default_attrs
= default_attrs
,
455 extern struct kobj_type ktype_part
;
457 static int block_hotplug_filter(struct kset
*kset
, struct kobject
*kobj
)
459 struct kobj_type
*ktype
= get_ktype(kobj
);
461 return ((ktype
== &ktype_block
) || (ktype
== &ktype_part
));
464 static int block_hotplug(struct kset
*kset
, struct kobject
*kobj
, char **envp
,
465 int num_envp
, char *buffer
, int buffer_size
)
467 struct kobj_type
*ktype
= get_ktype(kobj
);
468 struct device
*physdev
;
469 struct gendisk
*disk
;
470 struct hd_struct
*part
;
474 if (ktype
== &ktype_block
) {
475 disk
= container_of(kobj
, struct gendisk
, kobj
);
476 add_hotplug_env_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
477 &length
, "MINOR=%u", disk
->first_minor
);
478 } else if (ktype
== &ktype_part
) {
479 disk
= container_of(kobj
->parent
, struct gendisk
, kobj
);
480 part
= container_of(kobj
, struct hd_struct
, kobj
);
481 add_hotplug_env_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
483 disk
->first_minor
+ part
->partno
);
487 add_hotplug_env_var(envp
, num_envp
, &i
, buffer
, buffer_size
, &length
,
488 "MAJOR=%u", disk
->major
);
490 /* add physical device, backing this device */
491 physdev
= disk
->driverfs_dev
;
493 char *path
= kobject_get_path(&physdev
->kobj
, GFP_KERNEL
);
495 add_hotplug_env_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
496 &length
, "PHYSDEVPATH=%s", path
);
500 add_hotplug_env_var(envp
, num_envp
, &i
,
501 buffer
, buffer_size
, &length
,
506 add_hotplug_env_var(envp
, num_envp
, &i
,
507 buffer
, buffer_size
, &length
,
509 physdev
->driver
->name
);
512 /* terminate, set to next free slot, shrink available space */
516 buffer
= &buffer
[length
];
517 buffer_size
-= length
;
522 static struct kset_hotplug_ops block_hotplug_ops
= {
523 .filter
= block_hotplug_filter
,
524 .hotplug
= block_hotplug
,
527 /* declare block_subsys. */
528 static decl_subsys(block
, &ktype_block
, &block_hotplug_ops
);
532 * aggregate disk stat collector. Uses the same stats that the sysfs
533 * entries do, above, but makes them available through one seq_file.
534 * Watching a few disks may be efficient through sysfs, but watching
535 * all of them will be more efficient through this interface.
537 * The output looks suspiciously like /proc/partitions with a bunch of
542 static void *diskstats_start(struct seq_file
*part
, loff_t
*pos
)
547 down(&block_subsys_sem
);
548 list_for_each(p
, &block_subsys
.kset
.list
)
550 return list_entry(p
, struct gendisk
, kobj
.entry
);
554 static void *diskstats_next(struct seq_file
*part
, void *v
, loff_t
*pos
)
556 struct list_head
*p
= ((struct gendisk
*)v
)->kobj
.entry
.next
;
558 return p
==&block_subsys
.kset
.list
? NULL
:
559 list_entry(p
, struct gendisk
, kobj
.entry
);
562 static void diskstats_stop(struct seq_file
*part
, void *v
)
564 up(&block_subsys_sem
);
567 static int diskstats_show(struct seq_file
*s
, void *v
)
569 struct gendisk
*gp
= v
;
570 char buf
[BDEVNAME_SIZE
];
574 if (&sgp->kobj.entry == block_subsys.kset.list.next)
575 seq_puts(s, "major minor name"
576 " rio rmerge rsect ruse wio wmerge "
577 "wsect wuse running use aveq"
582 disk_round_stats(gp
);
584 seq_printf(s
, "%4d %4d %s %u %u %llu %u %u %u %llu %u %u %u %u\n",
585 gp
->major
, n
+ gp
->first_minor
, disk_name(gp
, n
, buf
),
586 disk_stat_read(gp
, reads
), disk_stat_read(gp
, read_merges
),
587 (unsigned long long)disk_stat_read(gp
, read_sectors
),
588 jiffies_to_msecs(disk_stat_read(gp
, read_ticks
)),
589 disk_stat_read(gp
, writes
), disk_stat_read(gp
, write_merges
),
590 (unsigned long long)disk_stat_read(gp
, write_sectors
),
591 jiffies_to_msecs(disk_stat_read(gp
, write_ticks
)),
593 jiffies_to_msecs(disk_stat_read(gp
, io_ticks
)),
594 jiffies_to_msecs(disk_stat_read(gp
, time_in_queue
)));
596 /* now show all non-0 size partitions of it */
597 for (n
= 0; n
< gp
->minors
- 1; n
++) {
598 struct hd_struct
*hd
= gp
->part
[n
];
600 if (hd
&& hd
->nr_sects
)
601 seq_printf(s
, "%4d %4d %s %u %u %u %u\n",
602 gp
->major
, n
+ gp
->first_minor
+ 1,
603 disk_name(gp
, n
+ 1, buf
),
604 hd
->reads
, hd
->read_sectors
,
605 hd
->writes
, hd
->write_sectors
);
611 struct seq_operations diskstats_op
= {
612 .start
= diskstats_start
,
613 .next
= diskstats_next
,
614 .stop
= diskstats_stop
,
615 .show
= diskstats_show
618 struct gendisk
*alloc_disk(int minors
)
620 return alloc_disk_node(minors
, -1);
623 struct gendisk
*alloc_disk_node(int minors
, int node_id
)
625 struct gendisk
*disk
;
627 disk
= kmalloc_node(sizeof(struct gendisk
), GFP_KERNEL
, node_id
);
629 memset(disk
, 0, sizeof(struct gendisk
));
630 if (!init_disk_stats(disk
)) {
635 int size
= (minors
- 1) * sizeof(struct hd_struct
*);
636 disk
->part
= kmalloc_node(size
, GFP_KERNEL
, node_id
);
641 memset(disk
->part
, 0, size
);
643 disk
->minors
= minors
;
644 kobj_set_kset_s(disk
,block_subsys
);
645 kobject_init(&disk
->kobj
);
646 rand_initialize_disk(disk
);
651 EXPORT_SYMBOL(alloc_disk
);
652 EXPORT_SYMBOL(alloc_disk_node
);
654 struct kobject
*get_disk(struct gendisk
*disk
)
656 struct module
*owner
;
657 struct kobject
*kobj
;
661 owner
= disk
->fops
->owner
;
662 if (owner
&& !try_module_get(owner
))
664 kobj
= kobject_get(&disk
->kobj
);
673 EXPORT_SYMBOL(get_disk
);
675 void put_disk(struct gendisk
*disk
)
678 kobject_put(&disk
->kobj
);
681 EXPORT_SYMBOL(put_disk
);
683 void set_device_ro(struct block_device
*bdev
, int flag
)
685 if (bdev
->bd_contains
!= bdev
)
686 bdev
->bd_part
->policy
= flag
;
688 bdev
->bd_disk
->policy
= flag
;
691 EXPORT_SYMBOL(set_device_ro
);
693 void set_disk_ro(struct gendisk
*disk
, int flag
)
697 for (i
= 0; i
< disk
->minors
- 1; i
++)
698 if (disk
->part
[i
]) disk
->part
[i
]->policy
= flag
;
701 EXPORT_SYMBOL(set_disk_ro
);
703 int bdev_read_only(struct block_device
*bdev
)
707 else if (bdev
->bd_contains
!= bdev
)
708 return bdev
->bd_part
->policy
;
710 return bdev
->bd_disk
->policy
;
713 EXPORT_SYMBOL(bdev_read_only
);
715 int invalidate_partition(struct gendisk
*disk
, int index
)
718 struct block_device
*bdev
= bdget_disk(disk
, index
);
721 res
= __invalidate_device(bdev
);
727 EXPORT_SYMBOL(invalidate_partition
);