blob: de2ebb2fab436119cf16b862c720c15be6d991c4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * gendisk handling
3 */
4
Linus Torvalds1da177e2005-04-16 15:20:36 -07005#include <linux/module.h>
6#include <linux/fs.h>
7#include <linux/genhd.h>
Andrew Mortonb446b602007-02-20 13:57:48 -08008#include <linux/kdev_t.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#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>
Christoph Hellwig2ef41632005-05-05 16:15:59 -070017#include <linux/buffer_head.h>
Jes Sorensen58383af2006-02-06 14:12:43 -080018#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
Kay Sieversedfaa7c2007-05-21 22:08:01 +020020static DEFINE_MUTEX(block_class_lock);
21#ifndef CONFIG_SYSFS_DEPRECATED
22struct kobject *block_depr;
23#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25/*
26 * Can be deleted altogether. Later.
27 *
28 */
29static struct blk_major_name {
30 struct blk_major_name *next;
31 int major;
32 char name[16];
Joe Korty68eef3b2006-03-31 02:30:32 -080033} *major_names[BLKDEV_MAJOR_HASH_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35/* index in the above - for now: assume no multimajor ranges */
36static inline int major_to_index(int major)
37{
Joe Korty68eef3b2006-03-31 02:30:32 -080038 return major % BLKDEV_MAJOR_HASH_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039}
40
Joe Korty68eef3b2006-03-31 02:30:32 -080041#ifdef CONFIG_PROC_FS
Joe Korty68eef3b2006-03-31 02:30:32 -080042void blkdev_show(struct seq_file *f, off_t offset)
Neil Horman7170be52006-01-14 13:20:38 -080043{
Joe Korty68eef3b2006-03-31 02:30:32 -080044 struct blk_major_name *dp;
Neil Horman7170be52006-01-14 13:20:38 -080045
Joe Korty68eef3b2006-03-31 02:30:32 -080046 if (offset < BLKDEV_MAJOR_HASH_SIZE) {
Kay Sieversedfaa7c2007-05-21 22:08:01 +020047 mutex_lock(&block_class_lock);
Joe Korty68eef3b2006-03-31 02:30:32 -080048 for (dp = major_names[offset]; dp; dp = dp->next)
49 seq_printf(f, "%3d %s\n", dp->major, dp->name);
Kay Sieversedfaa7c2007-05-21 22:08:01 +020050 mutex_unlock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070052}
Joe Korty68eef3b2006-03-31 02:30:32 -080053#endif /* CONFIG_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55int register_blkdev(unsigned int major, const char *name)
56{
57 struct blk_major_name **n, *p;
58 int index, ret = 0;
59
Kay Sieversedfaa7c2007-05-21 22:08:01 +020060 mutex_lock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62 /* temporary */
63 if (major == 0) {
64 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
65 if (major_names[index] == NULL)
66 break;
67 }
68
69 if (index == 0) {
70 printk("register_blkdev: failed to get major for %s\n",
71 name);
72 ret = -EBUSY;
73 goto out;
74 }
75 major = index;
76 ret = major;
77 }
78
79 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
80 if (p == NULL) {
81 ret = -ENOMEM;
82 goto out;
83 }
84
85 p->major = major;
86 strlcpy(p->name, name, sizeof(p->name));
87 p->next = NULL;
88 index = major_to_index(major);
89
90 for (n = &major_names[index]; *n; n = &(*n)->next) {
91 if ((*n)->major == major)
92 break;
93 }
94 if (!*n)
95 *n = p;
96 else
97 ret = -EBUSY;
98
99 if (ret < 0) {
100 printk("register_blkdev: cannot get major %d for %s\n",
101 major, name);
102 kfree(p);
103 }
104out:
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200105 mutex_unlock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 return ret;
107}
108
109EXPORT_SYMBOL(register_blkdev);
110
Akinobu Mitaf4480242007-07-17 04:03:47 -0700111void unregister_blkdev(unsigned int major, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{
113 struct blk_major_name **n;
114 struct blk_major_name *p = NULL;
115 int index = major_to_index(major);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200117 mutex_lock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 for (n = &major_names[index]; *n; n = &(*n)->next)
119 if ((*n)->major == major)
120 break;
Akinobu Mita294462a2007-07-17 04:03:45 -0700121 if (!*n || strcmp((*n)->name, name)) {
122 WARN_ON(1);
Akinobu Mita294462a2007-07-17 04:03:45 -0700123 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 p = *n;
125 *n = p->next;
126 }
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200127 mutex_unlock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 kfree(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129}
130
131EXPORT_SYMBOL(unregister_blkdev);
132
133static struct kobj_map *bdev_map;
134
135/*
136 * Register device numbers dev..(dev+range-1)
137 * range must be nonzero
138 * The hash chain is sorted on range, so that subranges can override.
139 */
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200140void blk_register_region(dev_t devt, unsigned long range, struct module *module,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 struct kobject *(*probe)(dev_t, int *, void *),
142 int (*lock)(dev_t, void *), void *data)
143{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200144 kobj_map(bdev_map, devt, range, module, probe, lock, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145}
146
147EXPORT_SYMBOL(blk_register_region);
148
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200149void blk_unregister_region(dev_t devt, unsigned long range)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200151 kobj_unmap(bdev_map, devt, range);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
153
154EXPORT_SYMBOL(blk_unregister_region);
155
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200156static struct kobject *exact_match(dev_t devt, int *part, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
158 struct gendisk *p = data;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200159
160 return &p->dev.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161}
162
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200163static int exact_lock(dev_t devt, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
165 struct gendisk *p = data;
166
167 if (!get_disk(p))
168 return -1;
169 return 0;
170}
171
172/**
173 * add_disk - add partitioning information to kernel list
174 * @disk: per-device partitioning information
175 *
176 * This function registers the partitioning information in @disk
177 * with the kernel.
178 */
179void add_disk(struct gendisk *disk)
180{
181 disk->flags |= GENHD_FL_UP;
182 blk_register_region(MKDEV(disk->major, disk->first_minor),
183 disk->minors, NULL, exact_match, exact_lock, disk);
184 register_disk(disk);
185 blk_register_queue(disk);
186}
187
188EXPORT_SYMBOL(add_disk);
189EXPORT_SYMBOL(del_gendisk); /* in partitions/check.c */
190
191void unlink_gendisk(struct gendisk *disk)
192{
193 blk_unregister_queue(disk);
194 blk_unregister_region(MKDEV(disk->major, disk->first_minor),
195 disk->minors);
196}
197
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198/**
199 * get_gendisk - get partitioning information for a given device
200 * @dev: device to get partitioning information for
201 *
202 * This function gets the structure containing partitioning
203 * information for the given device @dev.
204 */
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200205struct gendisk *get_gendisk(dev_t devt, int *part)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200207 struct kobject *kobj = kobj_lookup(bdev_map, devt, part);
208 struct device *dev = kobj_to_dev(kobj);
209
210 return kobj ? dev_to_disk(dev) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211}
212
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700213/*
214 * print a full list of all partitions - intended for places where the root
215 * filesystem can't be mounted and thus to give the victim some idea of what
216 * went wrong
217 */
218void __init printk_all_partitions(void)
219{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200220 struct device *dev;
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700221 struct gendisk *sgp;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200222 char buf[BDEVNAME_SIZE];
223 int n;
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700224
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200225 mutex_lock(&block_class_lock);
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700226 /* For each block device... */
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200227 list_for_each_entry(dev, &block_class.devices, node) {
228 if (dev->type != &disk_type)
229 continue;
230 sgp = dev_to_disk(dev);
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700231 /*
232 * Don't show empty devices or things that have been surpressed
233 */
234 if (get_capacity(sgp) == 0 ||
235 (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
236 continue;
237
238 /*
239 * Note, unlike /proc/partitions, I am showing the numbers in
240 * hex - the same format as the root= option takes.
241 */
242 printk("%02x%02x %10llu %s",
243 sgp->major, sgp->first_minor,
244 (unsigned long long)get_capacity(sgp) >> 1,
245 disk_name(sgp, 0, buf));
246 if (sgp->driverfs_dev != NULL &&
247 sgp->driverfs_dev->driver != NULL)
248 printk(" driver: %s\n",
249 sgp->driverfs_dev->driver->name);
250 else
251 printk(" (driver?)\n");
252
253 /* now show the partitions */
254 for (n = 0; n < sgp->minors - 1; ++n) {
255 if (sgp->part[n] == NULL)
256 continue;
257 if (sgp->part[n]->nr_sects == 0)
258 continue;
259 printk(" %02x%02x %10llu %s\n",
260 sgp->major, n + 1 + sgp->first_minor,
261 (unsigned long long)sgp->part[n]->nr_sects >> 1,
262 disk_name(sgp, n + 1, buf));
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200263 }
264 }
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700265
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200266 mutex_unlock(&block_class_lock);
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700267}
268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269#ifdef CONFIG_PROC_FS
270/* iterator */
271static void *part_start(struct seq_file *part, loff_t *pos)
272{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200273 loff_t k = *pos;
274 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200276 mutex_lock(&block_class_lock);
277 list_for_each_entry(dev, &block_class.devices, node) {
278 if (dev->type != &disk_type)
279 continue;
280 if (!k--)
281 return dev_to_disk(dev);
282 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 return NULL;
284}
285
286static void *part_next(struct seq_file *part, void *v, loff_t *pos)
287{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200288 struct gendisk *gp = v;
289 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 ++*pos;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200291 list_for_each_entry(dev, &gp->dev.node, node) {
292 if (&dev->node == &block_class.devices)
293 return NULL;
294 if (dev->type == &disk_type)
295 return dev_to_disk(dev);
296 }
297 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298}
299
300static void part_stop(struct seq_file *part, void *v)
301{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200302 mutex_unlock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303}
304
305static int show_partition(struct seq_file *part, void *v)
306{
307 struct gendisk *sgp = v;
308 int n;
309 char buf[BDEVNAME_SIZE];
310
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200311 if (&sgp->dev.node == block_class.devices.next)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 seq_puts(part, "major minor #blocks name\n\n");
313
314 /* Don't show non-partitionable removeable devices or empty devices */
315 if (!get_capacity(sgp) ||
316 (sgp->minors == 1 && (sgp->flags & GENHD_FL_REMOVABLE)))
317 return 0;
318 if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
319 return 0;
320
321 /* show the full disk and all non-0 size partitions of it */
322 seq_printf(part, "%4d %4d %10llu %s\n",
323 sgp->major, sgp->first_minor,
324 (unsigned long long)get_capacity(sgp) >> 1,
325 disk_name(sgp, 0, buf));
326 for (n = 0; n < sgp->minors - 1; n++) {
327 if (!sgp->part[n])
328 continue;
329 if (sgp->part[n]->nr_sects == 0)
330 continue;
331 seq_printf(part, "%4d %4d %10llu %s\n",
332 sgp->major, n + 1 + sgp->first_minor,
333 (unsigned long long)sgp->part[n]->nr_sects >> 1 ,
334 disk_name(sgp, n + 1, buf));
335 }
336
337 return 0;
338}
339
Jan Engelhardt12f32bb2008-01-29 20:57:51 +0100340const struct seq_operations partitions_op = {
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200341 .start = part_start,
342 .next = part_next,
343 .stop = part_stop,
344 .show = show_partition
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345};
346#endif
347
348
349extern int blk_dev_init(void);
350
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200351static struct kobject *base_probe(dev_t devt, int *part, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200353 if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 /* Make old-style 2.4 aliases work */
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200355 request_module("block-major-%d", MAJOR(devt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return NULL;
357}
358
359static int __init genhd_device_init(void)
360{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200361 class_register(&block_class);
362 bdev_map = kobj_map_init(base_probe, &block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 blk_dev_init();
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200364
365#ifndef CONFIG_SYSFS_DEPRECATED
366 /* create top-level block dir */
367 block_depr = kobject_create_and_add("block", NULL);
368#endif
Greg Kroah-Hartman830d3cf2007-11-06 10:36:58 -0800369 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370}
371
372subsys_initcall(genhd_device_init);
373
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200374static ssize_t disk_range_show(struct device *dev,
375 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200377 struct gendisk *disk = dev_to_disk(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200379 return sprintf(buf, "%d\n", disk->minors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380}
381
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200382static ssize_t disk_removable_show(struct device *dev,
383 struct device_attribute *attr, char *buf)
Kay Sieversa7fd6702005-10-01 14:49:43 +0200384{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200385 struct gendisk *disk = dev_to_disk(dev);
Kay Sieversa7fd6702005-10-01 14:49:43 +0200386
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200387 return sprintf(buf, "%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200389}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200391static ssize_t disk_size_show(struct device *dev,
392 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200394 struct gendisk *disk = dev_to_disk(dev);
395
396 return sprintf(buf, "%llu\n", (unsigned long long)get_capacity(disk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397}
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200398
399static ssize_t disk_capability_show(struct device *dev,
400 struct device_attribute *attr, char *buf)
Kristen Carlson Accardi86ce18d2007-05-23 13:57:38 -0700401{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200402 struct gendisk *disk = dev_to_disk(dev);
403
404 return sprintf(buf, "%x\n", disk->flags);
Kristen Carlson Accardi86ce18d2007-05-23 13:57:38 -0700405}
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200406
407static ssize_t disk_stat_show(struct device *dev,
408 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200410 struct gendisk *disk = dev_to_disk(dev);
411
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 preempt_disable();
413 disk_round_stats(disk);
414 preempt_enable();
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200415 return sprintf(buf,
Ben Woodard837c7872006-03-22 08:09:31 +0100416 "%8lu %8lu %8llu %8u "
417 "%8lu %8lu %8llu %8u "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 "%8u %8u %8u"
419 "\n",
Jens Axboe47a00412005-11-09 13:38:47 +0100420 disk_stat_read(disk, ios[READ]),
421 disk_stat_read(disk, merges[READ]),
422 (unsigned long long)disk_stat_read(disk, sectors[READ]),
423 jiffies_to_msecs(disk_stat_read(disk, ticks[READ])),
424 disk_stat_read(disk, ios[WRITE]),
425 disk_stat_read(disk, merges[WRITE]),
426 (unsigned long long)disk_stat_read(disk, sectors[WRITE]),
427 jiffies_to_msecs(disk_stat_read(disk, ticks[WRITE])),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 disk->in_flight,
429 jiffies_to_msecs(disk_stat_read(disk, io_ticks)),
430 jiffies_to_msecs(disk_stat_read(disk, time_in_queue)));
431}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Akinobu Mitac17bb492006-12-08 02:39:46 -0800433#ifdef CONFIG_FAIL_MAKE_REQUEST
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200434static ssize_t disk_fail_show(struct device *dev,
435 struct device_attribute *attr, char *buf)
436{
437 struct gendisk *disk = dev_to_disk(dev);
Akinobu Mitac17bb492006-12-08 02:39:46 -0800438
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200439 return sprintf(buf, "%d\n", disk->flags & GENHD_FL_FAIL ? 1 : 0);
440}
441
442static ssize_t disk_fail_store(struct device *dev,
443 struct device_attribute *attr,
Akinobu Mitac17bb492006-12-08 02:39:46 -0800444 const char *buf, size_t count)
445{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200446 struct gendisk *disk = dev_to_disk(dev);
Akinobu Mitac17bb492006-12-08 02:39:46 -0800447 int i;
448
449 if (count > 0 && sscanf(buf, "%d", &i) > 0) {
450 if (i == 0)
451 disk->flags &= ~GENHD_FL_FAIL;
452 else
453 disk->flags |= GENHD_FL_FAIL;
454 }
455
456 return count;
457}
Akinobu Mitac17bb492006-12-08 02:39:46 -0800458
459#endif
460
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200461static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
462static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
463static DEVICE_ATTR(size, S_IRUGO, disk_size_show, NULL);
464static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
465static DEVICE_ATTR(stat, S_IRUGO, disk_stat_show, NULL);
Akinobu Mitac17bb492006-12-08 02:39:46 -0800466#ifdef CONFIG_FAIL_MAKE_REQUEST
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200467static struct device_attribute dev_attr_fail =
468 __ATTR(make-it-fail, S_IRUGO|S_IWUSR, disk_fail_show, disk_fail_store);
Akinobu Mitac17bb492006-12-08 02:39:46 -0800469#endif
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200470
471static struct attribute *disk_attrs[] = {
472 &dev_attr_range.attr,
473 &dev_attr_removable.attr,
474 &dev_attr_size.attr,
475 &dev_attr_capability.attr,
476 &dev_attr_stat.attr,
477#ifdef CONFIG_FAIL_MAKE_REQUEST
478 &dev_attr_fail.attr,
479#endif
480 NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481};
482
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200483static struct attribute_group disk_attr_group = {
484 .attrs = disk_attrs,
485};
486
487static struct attribute_group *disk_attr_groups[] = {
488 &disk_attr_group,
489 NULL
490};
491
492static void disk_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200494 struct gendisk *disk = dev_to_disk(dev);
495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 kfree(disk->random);
497 kfree(disk->part);
498 free_disk_stats(disk);
499 kfree(disk);
500}
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200501struct class block_class = {
502 .name = "block",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503};
504
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200505struct device_type disk_type = {
506 .name = "disk",
507 .groups = disk_attr_groups,
508 .release = disk_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509};
510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511/*
512 * aggregate disk stat collector. Uses the same stats that the sysfs
513 * entries do, above, but makes them available through one seq_file.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 *
515 * The output looks suspiciously like /proc/partitions with a bunch of
516 * extra fields.
517 */
518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519static void *diskstats_start(struct seq_file *part, loff_t *pos)
520{
521 loff_t k = *pos;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200522 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200524 mutex_lock(&block_class_lock);
525 list_for_each_entry(dev, &block_class.devices, node) {
526 if (dev->type != &disk_type)
527 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 if (!k--)
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200529 return dev_to_disk(dev);
530 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 return NULL;
532}
533
534static void *diskstats_next(struct seq_file *part, void *v, loff_t *pos)
535{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200536 struct gendisk *gp = v;
537 struct device *dev;
538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 ++*pos;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200540 list_for_each_entry(dev, &gp->dev.node, node) {
541 if (&dev->node == &block_class.devices)
542 return NULL;
543 if (dev->type == &disk_type)
544 return dev_to_disk(dev);
545 }
546 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547}
548
549static void diskstats_stop(struct seq_file *part, void *v)
550{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200551 mutex_unlock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552}
553
554static int diskstats_show(struct seq_file *s, void *v)
555{
556 struct gendisk *gp = v;
557 char buf[BDEVNAME_SIZE];
558 int n = 0;
559
560 /*
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200561 if (&gp->dev.kobj.entry == block_class.devices.next)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 seq_puts(s, "major minor name"
563 " rio rmerge rsect ruse wio wmerge "
564 "wsect wuse running use aveq"
565 "\n\n");
566 */
567
568 preempt_disable();
569 disk_round_stats(gp);
570 preempt_enable();
Ben Woodard837c7872006-03-22 08:09:31 +0100571 seq_printf(s, "%4d %4d %s %lu %lu %llu %u %lu %lu %llu %u %u %u %u\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 gp->major, n + gp->first_minor, disk_name(gp, n, buf),
Jens Axboea3623572005-11-01 09:26:16 +0100573 disk_stat_read(gp, ios[0]), disk_stat_read(gp, merges[0]),
574 (unsigned long long)disk_stat_read(gp, sectors[0]),
575 jiffies_to_msecs(disk_stat_read(gp, ticks[0])),
576 disk_stat_read(gp, ios[1]), disk_stat_read(gp, merges[1]),
577 (unsigned long long)disk_stat_read(gp, sectors[1]),
578 jiffies_to_msecs(disk_stat_read(gp, ticks[1])),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 gp->in_flight,
580 jiffies_to_msecs(disk_stat_read(gp, io_ticks)),
581 jiffies_to_msecs(disk_stat_read(gp, time_in_queue)));
582
583 /* now show all non-0 size partitions of it */
584 for (n = 0; n < gp->minors - 1; n++) {
585 struct hd_struct *hd = gp->part[n];
586
587 if (hd && hd->nr_sects)
588 seq_printf(s, "%4d %4d %s %u %u %u %u\n",
589 gp->major, n + gp->first_minor + 1,
590 disk_name(gp, n + 1, buf),
Jens Axboea3623572005-11-01 09:26:16 +0100591 hd->ios[0], hd->sectors[0],
592 hd->ios[1], hd->sectors[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 }
594
595 return 0;
596}
597
Jan Engelhardt12f32bb2008-01-29 20:57:51 +0100598const struct seq_operations diskstats_op = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 .start = diskstats_start,
600 .next = diskstats_next,
601 .stop = diskstats_stop,
602 .show = diskstats_show
603};
604
Kristen Carlson Accardi8ce7ad72007-05-23 13:57:38 -0700605static void media_change_notify_thread(struct work_struct *work)
606{
607 struct gendisk *gd = container_of(work, struct gendisk, async_notify);
608 char event[] = "MEDIA_CHANGE=1";
609 char *envp[] = { event, NULL };
610
611 /*
612 * set enviroment vars to indicate which event this is for
613 * so that user space will know to go check the media status.
614 */
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200615 kobject_uevent_env(&gd->dev.kobj, KOBJ_CHANGE, envp);
Kristen Carlson Accardi8ce7ad72007-05-23 13:57:38 -0700616 put_device(gd->driverfs_dev);
617}
618
619void genhd_media_change_notify(struct gendisk *disk)
620{
621 get_device(disk->driverfs_dev);
622 schedule_work(&disk->async_notify);
623}
624EXPORT_SYMBOL_GPL(genhd_media_change_notify);
625
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200626dev_t blk_lookup_devt(const char *name)
627{
628 struct device *dev;
629 dev_t devt = MKDEV(0, 0);
630
631 mutex_lock(&block_class_lock);
632 list_for_each_entry(dev, &block_class.devices, node) {
633 if (strcmp(dev->bus_id, name) == 0) {
634 devt = dev->devt;
635 break;
636 }
637 }
638 mutex_unlock(&block_class_lock);
639
640 return devt;
641}
642
643EXPORT_SYMBOL(blk_lookup_devt);
644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645struct gendisk *alloc_disk(int minors)
646{
Christoph Lameter19460892005-06-23 00:08:19 -0700647 return alloc_disk_node(minors, -1);
648}
649
650struct gendisk *alloc_disk_node(int minors, int node_id)
651{
652 struct gendisk *disk;
653
Christoph Lameter94f60302007-07-17 04:03:29 -0700654 disk = kmalloc_node(sizeof(struct gendisk),
655 GFP_KERNEL | __GFP_ZERO, node_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 if (disk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if (!init_disk_stats(disk)) {
658 kfree(disk);
659 return NULL;
660 }
661 if (minors > 1) {
662 int size = (minors - 1) * sizeof(struct hd_struct *);
Christoph Lameter94f60302007-07-17 04:03:29 -0700663 disk->part = kmalloc_node(size,
664 GFP_KERNEL | __GFP_ZERO, node_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 if (!disk->part) {
Jerome Marchandc7674032007-11-23 09:17:53 +0100666 free_disk_stats(disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 kfree(disk);
668 return NULL;
669 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 }
671 disk->minors = minors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 rand_initialize_disk(disk);
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200673 disk->dev.class = &block_class;
674 disk->dev.type = &disk_type;
675 device_initialize(&disk->dev);
Kristen Carlson Accardi8ce7ad72007-05-23 13:57:38 -0700676 INIT_WORK(&disk->async_notify,
677 media_change_notify_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 }
679 return disk;
680}
681
682EXPORT_SYMBOL(alloc_disk);
Christoph Lameter19460892005-06-23 00:08:19 -0700683EXPORT_SYMBOL(alloc_disk_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
685struct kobject *get_disk(struct gendisk *disk)
686{
687 struct module *owner;
688 struct kobject *kobj;
689
690 if (!disk->fops)
691 return NULL;
692 owner = disk->fops->owner;
693 if (owner && !try_module_get(owner))
694 return NULL;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200695 kobj = kobject_get(&disk->dev.kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 if (kobj == NULL) {
697 module_put(owner);
698 return NULL;
699 }
700 return kobj;
701
702}
703
704EXPORT_SYMBOL(get_disk);
705
706void put_disk(struct gendisk *disk)
707{
708 if (disk)
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200709 kobject_put(&disk->dev.kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
711
712EXPORT_SYMBOL(put_disk);
713
714void set_device_ro(struct block_device *bdev, int flag)
715{
716 if (bdev->bd_contains != bdev)
717 bdev->bd_part->policy = flag;
718 else
719 bdev->bd_disk->policy = flag;
720}
721
722EXPORT_SYMBOL(set_device_ro);
723
724void set_disk_ro(struct gendisk *disk, int flag)
725{
726 int i;
727 disk->policy = flag;
728 for (i = 0; i < disk->minors - 1; i++)
729 if (disk->part[i]) disk->part[i]->policy = flag;
730}
731
732EXPORT_SYMBOL(set_disk_ro);
733
734int bdev_read_only(struct block_device *bdev)
735{
736 if (!bdev)
737 return 0;
738 else if (bdev->bd_contains != bdev)
739 return bdev->bd_part->policy;
740 else
741 return bdev->bd_disk->policy;
742}
743
744EXPORT_SYMBOL(bdev_read_only);
745
746int invalidate_partition(struct gendisk *disk, int index)
747{
748 int res = 0;
749 struct block_device *bdev = bdget_disk(disk, index);
750 if (bdev) {
Christoph Hellwig2ef41632005-05-05 16:15:59 -0700751 fsync_bdev(bdev);
752 res = __invalidate_device(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 bdput(bdev);
754 }
755 return res;
756}
757
758EXPORT_SYMBOL(invalidate_partition);