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>
18 #define MAX_PROBE_HASH 255 /* random */
20 static struct subsystem block_subsys
;
22 static DECLARE_MUTEX(block_subsys_sem
);
25 * Can be deleted altogether. Later.
28 static struct blk_major_name
{
29 struct blk_major_name
*next
;
32 } *major_names
[MAX_PROBE_HASH
];
34 /* index in the above - for now: assume no multimajor ranges */
35 static inline int major_to_index(int major
)
37 return major
% MAX_PROBE_HASH
;
41 /* get block device names in somewhat random order */
42 int get_blkdev_list(char *p
)
44 struct blk_major_name
*n
;
47 len
= sprintf(p
, "\nBlock devices:\n");
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",
55 up(&block_subsys_sem
);
61 int register_blkdev(unsigned int major
, const char *name
)
63 struct blk_major_name
**n
, *p
;
66 down(&block_subsys_sem
);
70 for (index
= ARRAY_SIZE(major_names
)-1; index
> 0; index
--) {
71 if (major_names
[index
] == NULL
)
76 printk("register_blkdev: failed to get major for %s\n",
85 p
= kmalloc(sizeof(struct blk_major_name
), GFP_KERNEL
);
92 strlcpy(p
->name
, name
, sizeof(p
->name
));
94 index
= major_to_index(major
);
96 for (n
= &major_names
[index
]; *n
; n
= &(*n
)->next
) {
97 if ((*n
)->major
== major
)
106 printk("register_blkdev: cannot get major %d for %s\n",
111 up(&block_subsys_sem
);
115 EXPORT_SYMBOL(register_blkdev
);
117 /* todo: make void - error printk here */
118 int unregister_blkdev(unsigned int major
, const char *name
)
120 struct blk_major_name
**n
;
121 struct blk_major_name
*p
= NULL
;
122 int index
= major_to_index(major
);
125 down(&block_subsys_sem
);
126 for (n
= &major_names
[index
]; *n
; n
= &(*n
)->next
)
127 if ((*n
)->major
== major
)
129 if (!*n
|| strcmp((*n
)->name
, name
))
135 up(&block_subsys_sem
);
141 EXPORT_SYMBOL(unregister_blkdev
);
143 static struct kobj_map
*bdev_map
;
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.
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
)
154 kobj_map(bdev_map
, dev
, range
, module
, probe
, lock
, data
);
157 EXPORT_SYMBOL(blk_register_region
);
159 void blk_unregister_region(dev_t dev
, unsigned long range
)
161 kobj_unmap(bdev_map
, dev
, range
);
164 EXPORT_SYMBOL(blk_unregister_region
);
166 static struct kobject
*exact_match(dev_t dev
, int *part
, void *data
)
168 struct gendisk
*p
= data
;
172 static int exact_lock(dev_t dev
, void *data
)
174 struct gendisk
*p
= data
;
182 * add_disk - add partitioning information to kernel list
183 * @disk: per-device partitioning information
185 * This function registers the partitioning information in @disk
188 void add_disk(struct gendisk
*disk
)
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
);
194 blk_register_queue(disk
);
197 EXPORT_SYMBOL(add_disk
);
198 EXPORT_SYMBOL(del_gendisk
); /* in partitions/check.c */
200 void unlink_gendisk(struct gendisk
*disk
)
202 blk_unregister_queue(disk
);
203 blk_unregister_region(MKDEV(disk
->major
, disk
->first_minor
),
207 #define to_disk(obj) container_of(obj,struct gendisk,kobj)
210 * get_gendisk - get partitioning information for a given device
211 * @dev: device to get partitioning information for
213 * This function gets the structure containing partitioning
214 * information for the given device @dev.
216 struct gendisk
*get_gendisk(dev_t dev
, int *part
)
218 struct kobject
*kobj
= kobj_lookup(bdev_map
, dev
, part
);
219 return kobj
? to_disk(kobj
) : NULL
;
222 #ifdef CONFIG_PROC_FS
224 static void *part_start(struct seq_file
*part
, loff_t
*pos
)
229 down(&block_subsys_sem
);
230 list_for_each(p
, &block_subsys
.kset
.list
)
232 return list_entry(p
, struct gendisk
, kobj
.entry
);
236 static void *part_next(struct seq_file
*part
, void *v
, loff_t
*pos
)
238 struct list_head
*p
= ((struct gendisk
*)v
)->kobj
.entry
.next
;
240 return p
==&block_subsys
.kset
.list
? NULL
:
241 list_entry(p
, struct gendisk
, kobj
.entry
);
244 static void part_stop(struct seq_file
*part
, void *v
)
246 up(&block_subsys_sem
);
249 static int show_partition(struct seq_file
*part
, void *v
)
251 struct gendisk
*sgp
= v
;
253 char buf
[BDEVNAME_SIZE
];
255 if (&sgp
->kobj
.entry
== block_subsys
.kset
.list
.next
)
256 seq_puts(part
, "major minor #blocks name\n\n");
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
)))
262 if (sgp
->flags
& GENHD_FL_SUPPRESS_PARTITION_INFO
)
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
++) {
273 if (sgp
->part
[n
]->nr_sects
== 0)
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
));
284 struct seq_operations partitions_op
= {
288 .show
= show_partition
293 extern int blk_dev_init(void);
295 static struct kobject
*base_probe(dev_t dev
, int *part
, void *data
)
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
));
303 static int __init
genhd_device_init(void)
305 bdev_map
= kobj_map_init(base_probe
, &block_subsys_sem
);
307 subsystem_register(&block_subsys
);
311 subsys_initcall(genhd_device_init
);
316 * kobject & sysfs bindings for block devices
318 static ssize_t
disk_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
321 struct gendisk
*disk
= to_disk(kobj
);
322 struct disk_attribute
*disk_attr
=
323 container_of(attr
,struct disk_attribute
,attr
);
327 ret
= disk_attr
->show(disk
,page
);
331 static struct sysfs_ops disk_sysfs_ops
= {
332 .show
= &disk_attr_show
,
335 static ssize_t
disk_dev_read(struct gendisk
* disk
, char *page
)
337 dev_t base
= MKDEV(disk
->major
, disk
->first_minor
);
338 return print_dev_t(page
, base
);
340 static ssize_t
disk_range_read(struct gendisk
* disk
, char *page
)
342 return sprintf(page
, "%d\n", disk
->minors
);
344 static ssize_t
disk_removable_read(struct gendisk
* disk
, char *page
)
346 return sprintf(page
, "%d\n",
347 (disk
->flags
& GENHD_FL_REMOVABLE
? 1 : 0));
350 static ssize_t
disk_size_read(struct gendisk
* disk
, char *page
)
352 return sprintf(page
, "%llu\n", (unsigned long long)get_capacity(disk
));
355 static ssize_t
disk_stats_read(struct gendisk
* disk
, char *page
)
358 disk_round_stats(disk
);
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
)),
373 jiffies_to_msecs(disk_stat_read(disk
, io_ticks
)),
374 jiffies_to_msecs(disk_stat_read(disk
, time_in_queue
)));
376 static struct disk_attribute disk_attr_dev
= {
377 .attr
= {.name
= "dev", .mode
= S_IRUGO
},
378 .show
= disk_dev_read
380 static struct disk_attribute disk_attr_range
= {
381 .attr
= {.name
= "range", .mode
= S_IRUGO
},
382 .show
= disk_range_read
384 static struct disk_attribute disk_attr_removable
= {
385 .attr
= {.name
= "removable", .mode
= S_IRUGO
},
386 .show
= disk_removable_read
388 static struct disk_attribute disk_attr_size
= {
389 .attr
= {.name
= "size", .mode
= S_IRUGO
},
390 .show
= disk_size_read
392 static struct disk_attribute disk_attr_stat
= {
393 .attr
= {.name
= "stat", .mode
= S_IRUGO
},
394 .show
= disk_stats_read
397 static struct attribute
* default_attrs
[] = {
399 &disk_attr_range
.attr
,
400 &disk_attr_removable
.attr
,
401 &disk_attr_size
.attr
,
402 &disk_attr_stat
.attr
,
406 static void disk_release(struct kobject
* kobj
)
408 struct gendisk
*disk
= to_disk(kobj
);
411 free_disk_stats(disk
);
415 static struct kobj_type ktype_block
= {
416 .release
= disk_release
,
417 .sysfs_ops
= &disk_sysfs_ops
,
418 .default_attrs
= default_attrs
,
421 extern struct kobj_type ktype_part
;
423 static int block_hotplug_filter(struct kset
*kset
, struct kobject
*kobj
)
425 struct kobj_type
*ktype
= get_ktype(kobj
);
427 return ((ktype
== &ktype_block
) || (ktype
== &ktype_part
));
430 static int block_hotplug(struct kset
*kset
, struct kobject
*kobj
, char **envp
,
431 int num_envp
, char *buffer
, int buffer_size
)
433 struct kobj_type
*ktype
= get_ktype(kobj
);
434 struct device
*physdev
;
435 struct gendisk
*disk
;
436 struct hd_struct
*part
;
440 if (ktype
== &ktype_block
) {
441 disk
= container_of(kobj
, struct gendisk
, kobj
);
442 add_hotplug_env_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
443 &length
, "MINOR=%u", disk
->first_minor
);
444 } else if (ktype
== &ktype_part
) {
445 disk
= container_of(kobj
->parent
, struct gendisk
, kobj
);
446 part
= container_of(kobj
, struct hd_struct
, kobj
);
447 add_hotplug_env_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
449 disk
->first_minor
+ part
->partno
);
453 add_hotplug_env_var(envp
, num_envp
, &i
, buffer
, buffer_size
, &length
,
454 "MAJOR=%u", disk
->major
);
456 /* add physical device, backing this device */
457 physdev
= disk
->driverfs_dev
;
459 char *path
= kobject_get_path(&physdev
->kobj
, GFP_KERNEL
);
461 add_hotplug_env_var(envp
, num_envp
, &i
, buffer
, buffer_size
,
462 &length
, "PHYSDEVPATH=%s", path
);
466 add_hotplug_env_var(envp
, num_envp
, &i
,
467 buffer
, buffer_size
, &length
,
472 add_hotplug_env_var(envp
, num_envp
, &i
,
473 buffer
, buffer_size
, &length
,
475 physdev
->driver
->name
);
478 /* terminate, set to next free slot, shrink available space */
482 buffer
= &buffer
[length
];
483 buffer_size
-= length
;
488 static struct kset_hotplug_ops block_hotplug_ops
= {
489 .filter
= block_hotplug_filter
,
490 .hotplug
= block_hotplug
,
493 /* declare block_subsys. */
494 static decl_subsys(block
, &ktype_block
, &block_hotplug_ops
);
498 * aggregate disk stat collector. Uses the same stats that the sysfs
499 * entries do, above, but makes them available through one seq_file.
500 * Watching a few disks may be efficient through sysfs, but watching
501 * all of them will be more efficient through this interface.
503 * The output looks suspiciously like /proc/partitions with a bunch of
508 static void *diskstats_start(struct seq_file
*part
, loff_t
*pos
)
513 down(&block_subsys_sem
);
514 list_for_each(p
, &block_subsys
.kset
.list
)
516 return list_entry(p
, struct gendisk
, kobj
.entry
);
520 static void *diskstats_next(struct seq_file
*part
, void *v
, loff_t
*pos
)
522 struct list_head
*p
= ((struct gendisk
*)v
)->kobj
.entry
.next
;
524 return p
==&block_subsys
.kset
.list
? NULL
:
525 list_entry(p
, struct gendisk
, kobj
.entry
);
528 static void diskstats_stop(struct seq_file
*part
, void *v
)
530 up(&block_subsys_sem
);
533 static int diskstats_show(struct seq_file
*s
, void *v
)
535 struct gendisk
*gp
= v
;
536 char buf
[BDEVNAME_SIZE
];
540 if (&sgp->kobj.entry == block_subsys.kset.list.next)
541 seq_puts(s, "major minor name"
542 " rio rmerge rsect ruse wio wmerge "
543 "wsect wuse running use aveq"
548 disk_round_stats(gp
);
550 seq_printf(s
, "%4d %4d %s %u %u %llu %u %u %u %llu %u %u %u %u\n",
551 gp
->major
, n
+ gp
->first_minor
, disk_name(gp
, n
, buf
),
552 disk_stat_read(gp
, reads
), disk_stat_read(gp
, read_merges
),
553 (unsigned long long)disk_stat_read(gp
, read_sectors
),
554 jiffies_to_msecs(disk_stat_read(gp
, read_ticks
)),
555 disk_stat_read(gp
, writes
), disk_stat_read(gp
, write_merges
),
556 (unsigned long long)disk_stat_read(gp
, write_sectors
),
557 jiffies_to_msecs(disk_stat_read(gp
, write_ticks
)),
559 jiffies_to_msecs(disk_stat_read(gp
, io_ticks
)),
560 jiffies_to_msecs(disk_stat_read(gp
, time_in_queue
)));
562 /* now show all non-0 size partitions of it */
563 for (n
= 0; n
< gp
->minors
- 1; n
++) {
564 struct hd_struct
*hd
= gp
->part
[n
];
566 if (hd
&& hd
->nr_sects
)
567 seq_printf(s
, "%4d %4d %s %u %u %u %u\n",
568 gp
->major
, n
+ gp
->first_minor
+ 1,
569 disk_name(gp
, n
+ 1, buf
),
570 hd
->reads
, hd
->read_sectors
,
571 hd
->writes
, hd
->write_sectors
);
577 struct seq_operations diskstats_op
= {
578 .start
= diskstats_start
,
579 .next
= diskstats_next
,
580 .stop
= diskstats_stop
,
581 .show
= diskstats_show
585 struct gendisk
*alloc_disk(int minors
)
587 struct gendisk
*disk
= kmalloc(sizeof(struct gendisk
), GFP_KERNEL
);
589 memset(disk
, 0, sizeof(struct gendisk
));
590 if (!init_disk_stats(disk
)) {
595 int size
= (minors
- 1) * sizeof(struct hd_struct
*);
596 disk
->part
= kmalloc(size
, GFP_KERNEL
);
601 memset(disk
->part
, 0, size
);
603 disk
->minors
= minors
;
604 kobj_set_kset_s(disk
,block_subsys
);
605 kobject_init(&disk
->kobj
);
606 rand_initialize_disk(disk
);
611 EXPORT_SYMBOL(alloc_disk
);
613 struct kobject
*get_disk(struct gendisk
*disk
)
615 struct module
*owner
;
616 struct kobject
*kobj
;
620 owner
= disk
->fops
->owner
;
621 if (owner
&& !try_module_get(owner
))
623 kobj
= kobject_get(&disk
->kobj
);
632 EXPORT_SYMBOL(get_disk
);
634 void put_disk(struct gendisk
*disk
)
637 kobject_put(&disk
->kobj
);
640 EXPORT_SYMBOL(put_disk
);
642 void set_device_ro(struct block_device
*bdev
, int flag
)
644 if (bdev
->bd_contains
!= bdev
)
645 bdev
->bd_part
->policy
= flag
;
647 bdev
->bd_disk
->policy
= flag
;
650 EXPORT_SYMBOL(set_device_ro
);
652 void set_disk_ro(struct gendisk
*disk
, int flag
)
656 for (i
= 0; i
< disk
->minors
- 1; i
++)
657 if (disk
->part
[i
]) disk
->part
[i
]->policy
= flag
;
660 EXPORT_SYMBOL(set_disk_ro
);
662 int bdev_read_only(struct block_device
*bdev
)
666 else if (bdev
->bd_contains
!= bdev
)
667 return bdev
->bd_part
->policy
;
669 return bdev
->bd_disk
->policy
;
672 EXPORT_SYMBOL(bdev_read_only
);
674 int invalidate_partition(struct gendisk
*disk
, int index
)
677 struct block_device
*bdev
= bdget_disk(disk
, index
);
679 res
= __invalidate_device(bdev
, 1);
685 EXPORT_SYMBOL(invalidate_partition
);