blob: 5fa2b44a72ffd22994d2e648b3d247f3f4877c95 [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>
Alexey Dobriyanf5009752008-10-04 23:53:21 +040013#include <linux/proc_fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/seq_file.h>
15#include <linux/slab.h>
16#include <linux/kmod.h>
17#include <linux/kobj_map.h>
Christoph Hellwig2ef41632005-05-05 16:15:59 -070018#include <linux/buffer_head.h>
Jes Sorensen58383af2006-02-06 14:12:43 -080019#include <linux/mutex.h>
Tejun Heobcce3de2008-08-25 19:47:22 +090020#include <linux/idr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Adrian Bunkff889722008-03-04 11:23:45 +010022#include "blk.h"
23
Kay Sieversedfaa7c2007-05-21 22:08:01 +020024static DEFINE_MUTEX(block_class_lock);
Kay Sieversedfaa7c2007-05-21 22:08:01 +020025struct kobject *block_depr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Tejun Heobcce3de2008-08-25 19:47:22 +090027/* for extended dynamic devt allocation, currently only one major is used */
28#define MAX_EXT_DEVT (1 << MINORBITS)
29
30/* For extended devt allocation. ext_devt_mutex prevents look up
31 * results from going away underneath its user.
32 */
33static DEFINE_MUTEX(ext_devt_mutex);
34static DEFINE_IDR(ext_devt_idr);
35
Adrian Bunk1826ead2008-03-04 11:23:46 +010036static struct device_type disk_type;
37
Tejun Heoe71bf0d2008-09-03 09:03:02 +020038/**
39 * disk_get_part - get partition
40 * @disk: disk to look partition from
41 * @partno: partition number
42 *
43 * Look for partition @partno from @disk. If found, increment
44 * reference count and return it.
45 *
46 * CONTEXT:
47 * Don't care.
48 *
49 * RETURNS:
50 * Pointer to the found partition on success, NULL if not found.
51 */
52struct hd_struct *disk_get_part(struct gendisk *disk, int partno)
53{
Tejun Heo540eed52008-08-25 19:56:15 +090054 struct hd_struct *part = NULL;
55 struct disk_part_tbl *ptbl;
Tejun Heoe71bf0d2008-09-03 09:03:02 +020056
Tejun Heo540eed52008-08-25 19:56:15 +090057 if (unlikely(partno < 0))
Tejun Heoe71bf0d2008-09-03 09:03:02 +020058 return NULL;
Tejun Heo540eed52008-08-25 19:56:15 +090059
Tejun Heoe71bf0d2008-09-03 09:03:02 +020060 rcu_read_lock();
Tejun Heo540eed52008-08-25 19:56:15 +090061
62 ptbl = rcu_dereference(disk->part_tbl);
63 if (likely(partno < ptbl->len)) {
64 part = rcu_dereference(ptbl->part[partno]);
65 if (part)
66 get_device(part_to_dev(part));
67 }
68
Tejun Heoe71bf0d2008-09-03 09:03:02 +020069 rcu_read_unlock();
70
71 return part;
72}
73EXPORT_SYMBOL_GPL(disk_get_part);
74
75/**
76 * disk_part_iter_init - initialize partition iterator
77 * @piter: iterator to initialize
78 * @disk: disk to iterate over
79 * @flags: DISK_PITER_* flags
80 *
81 * Initialize @piter so that it iterates over partitions of @disk.
82 *
83 * CONTEXT:
84 * Don't care.
85 */
86void disk_part_iter_init(struct disk_part_iter *piter, struct gendisk *disk,
87 unsigned int flags)
88{
Tejun Heo540eed52008-08-25 19:56:15 +090089 struct disk_part_tbl *ptbl;
90
91 rcu_read_lock();
92 ptbl = rcu_dereference(disk->part_tbl);
93
Tejun Heoe71bf0d2008-09-03 09:03:02 +020094 piter->disk = disk;
95 piter->part = NULL;
96
97 if (flags & DISK_PITER_REVERSE)
Tejun Heo540eed52008-08-25 19:56:15 +090098 piter->idx = ptbl->len - 1;
Tejun Heo71982a42009-04-17 08:34:48 +020099 else if (flags & (DISK_PITER_INCL_PART0 | DISK_PITER_INCL_EMPTY_PART0))
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200100 piter->idx = 0;
Tejun Heob5d0b9d2008-09-03 09:06:42 +0200101 else
102 piter->idx = 1;
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200103
104 piter->flags = flags;
Tejun Heo540eed52008-08-25 19:56:15 +0900105
106 rcu_read_unlock();
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200107}
108EXPORT_SYMBOL_GPL(disk_part_iter_init);
109
110/**
111 * disk_part_iter_next - proceed iterator to the next partition and return it
112 * @piter: iterator of interest
113 *
114 * Proceed @piter to the next partition and return it.
115 *
116 * CONTEXT:
117 * Don't care.
118 */
119struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter)
120{
Tejun Heo540eed52008-08-25 19:56:15 +0900121 struct disk_part_tbl *ptbl;
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200122 int inc, end;
123
124 /* put the last partition */
125 disk_put_part(piter->part);
126 piter->part = NULL;
127
Tejun Heo540eed52008-08-25 19:56:15 +0900128 /* get part_tbl */
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200129 rcu_read_lock();
Tejun Heo540eed52008-08-25 19:56:15 +0900130 ptbl = rcu_dereference(piter->disk->part_tbl);
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200131
132 /* determine iteration parameters */
133 if (piter->flags & DISK_PITER_REVERSE) {
134 inc = -1;
Tejun Heo71982a42009-04-17 08:34:48 +0200135 if (piter->flags & (DISK_PITER_INCL_PART0 |
136 DISK_PITER_INCL_EMPTY_PART0))
Tejun Heob5d0b9d2008-09-03 09:06:42 +0200137 end = -1;
138 else
139 end = 0;
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200140 } else {
141 inc = 1;
Tejun Heo540eed52008-08-25 19:56:15 +0900142 end = ptbl->len;
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200143 }
144
145 /* iterate to the next partition */
146 for (; piter->idx != end; piter->idx += inc) {
147 struct hd_struct *part;
148
Tejun Heo540eed52008-08-25 19:56:15 +0900149 part = rcu_dereference(ptbl->part[piter->idx]);
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200150 if (!part)
151 continue;
Tejun Heo71982a42009-04-17 08:34:48 +0200152 if (!part->nr_sects &&
153 !(piter->flags & DISK_PITER_INCL_EMPTY) &&
154 !(piter->flags & DISK_PITER_INCL_EMPTY_PART0 &&
155 piter->idx == 0))
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200156 continue;
157
Tejun Heoed9e1982008-08-25 19:56:05 +0900158 get_device(part_to_dev(part));
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200159 piter->part = part;
160 piter->idx += inc;
161 break;
162 }
163
164 rcu_read_unlock();
165
166 return piter->part;
167}
168EXPORT_SYMBOL_GPL(disk_part_iter_next);
169
170/**
171 * disk_part_iter_exit - finish up partition iteration
172 * @piter: iter of interest
173 *
174 * Called when iteration is over. Cleans up @piter.
175 *
176 * CONTEXT:
177 * Don't care.
178 */
179void disk_part_iter_exit(struct disk_part_iter *piter)
180{
181 disk_put_part(piter->part);
182 piter->part = NULL;
183}
184EXPORT_SYMBOL_GPL(disk_part_iter_exit);
185
Jens Axboea6f23652008-10-24 12:52:42 +0200186static inline int sector_in_part(struct hd_struct *part, sector_t sector)
187{
188 return part->start_sect <= sector &&
189 sector < part->start_sect + part->nr_sects;
190}
191
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200192/**
193 * disk_map_sector_rcu - map sector to partition
194 * @disk: gendisk of interest
195 * @sector: sector to map
196 *
197 * Find out which partition @sector maps to on @disk. This is
198 * primarily used for stats accounting.
199 *
200 * CONTEXT:
201 * RCU read locked. The returned partition pointer is valid only
202 * while preemption is disabled.
203 *
204 * RETURNS:
Tejun Heo074a7ac2008-08-25 19:56:14 +0900205 * Found partition on success, part0 is returned if no partition matches
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200206 */
207struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector)
208{
Tejun Heo540eed52008-08-25 19:56:15 +0900209 struct disk_part_tbl *ptbl;
Jens Axboea6f23652008-10-24 12:52:42 +0200210 struct hd_struct *part;
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200211 int i;
212
Tejun Heo540eed52008-08-25 19:56:15 +0900213 ptbl = rcu_dereference(disk->part_tbl);
214
Jens Axboea6f23652008-10-24 12:52:42 +0200215 part = rcu_dereference(ptbl->last_lookup);
216 if (part && sector_in_part(part, sector))
217 return part;
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200218
Jens Axboea6f23652008-10-24 12:52:42 +0200219 for (i = 1; i < ptbl->len; i++) {
220 part = rcu_dereference(ptbl->part[i]);
221
222 if (part && sector_in_part(part, sector)) {
223 rcu_assign_pointer(ptbl->last_lookup, part);
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200224 return part;
Jens Axboea6f23652008-10-24 12:52:42 +0200225 }
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200226 }
Tejun Heo074a7ac2008-08-25 19:56:14 +0900227 return &disk->part0;
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200228}
229EXPORT_SYMBOL_GPL(disk_map_sector_rcu);
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231/*
232 * Can be deleted altogether. Later.
233 *
234 */
235static struct blk_major_name {
236 struct blk_major_name *next;
237 int major;
238 char name[16];
Joe Korty68eef3b2006-03-31 02:30:32 -0800239} *major_names[BLKDEV_MAJOR_HASH_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241/* index in the above - for now: assume no multimajor ranges */
242static inline int major_to_index(int major)
243{
Joe Korty68eef3b2006-03-31 02:30:32 -0800244 return major % BLKDEV_MAJOR_HASH_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245}
246
Joe Korty68eef3b2006-03-31 02:30:32 -0800247#ifdef CONFIG_PROC_FS
Tejun Heocf771cb2008-09-03 09:01:09 +0200248void blkdev_show(struct seq_file *seqf, off_t offset)
Neil Horman7170be52006-01-14 13:20:38 -0800249{
Joe Korty68eef3b2006-03-31 02:30:32 -0800250 struct blk_major_name *dp;
Neil Horman7170be52006-01-14 13:20:38 -0800251
Joe Korty68eef3b2006-03-31 02:30:32 -0800252 if (offset < BLKDEV_MAJOR_HASH_SIZE) {
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200253 mutex_lock(&block_class_lock);
Joe Korty68eef3b2006-03-31 02:30:32 -0800254 for (dp = major_names[offset]; dp; dp = dp->next)
Tejun Heocf771cb2008-09-03 09:01:09 +0200255 seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200256 mutex_unlock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258}
Joe Korty68eef3b2006-03-31 02:30:32 -0800259#endif /* CONFIG_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Márton Németh9e8c0bc2009-02-20 08:12:51 +0100261/**
262 * register_blkdev - register a new block device
263 *
264 * @major: the requested major device number [1..255]. If @major=0, try to
265 * allocate any unused major number.
266 * @name: the name of the new block device as a zero terminated string
267 *
268 * The @name must be unique within the system.
269 *
270 * The return value depends on the @major input parameter.
271 * - if a major device number was requested in range [1..255] then the
272 * function returns zero on success, or a negative error code
273 * - if any unused major number was requested with @major=0 parameter
274 * then the return value is the allocated major number in range
275 * [1..255] or a negative error code otherwise
276 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277int register_blkdev(unsigned int major, const char *name)
278{
279 struct blk_major_name **n, *p;
280 int index, ret = 0;
281
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200282 mutex_lock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
284 /* temporary */
285 if (major == 0) {
286 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
287 if (major_names[index] == NULL)
288 break;
289 }
290
291 if (index == 0) {
292 printk("register_blkdev: failed to get major for %s\n",
293 name);
294 ret = -EBUSY;
295 goto out;
296 }
297 major = index;
298 ret = major;
299 }
300
301 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
302 if (p == NULL) {
303 ret = -ENOMEM;
304 goto out;
305 }
306
307 p->major = major;
308 strlcpy(p->name, name, sizeof(p->name));
309 p->next = NULL;
310 index = major_to_index(major);
311
312 for (n = &major_names[index]; *n; n = &(*n)->next) {
313 if ((*n)->major == major)
314 break;
315 }
316 if (!*n)
317 *n = p;
318 else
319 ret = -EBUSY;
320
321 if (ret < 0) {
322 printk("register_blkdev: cannot get major %d for %s\n",
323 major, name);
324 kfree(p);
325 }
326out:
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200327 mutex_unlock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 return ret;
329}
330
331EXPORT_SYMBOL(register_blkdev);
332
Akinobu Mitaf4480242007-07-17 04:03:47 -0700333void unregister_blkdev(unsigned int major, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334{
335 struct blk_major_name **n;
336 struct blk_major_name *p = NULL;
337 int index = major_to_index(major);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200339 mutex_lock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 for (n = &major_names[index]; *n; n = &(*n)->next)
341 if ((*n)->major == major)
342 break;
Akinobu Mita294462a2007-07-17 04:03:45 -0700343 if (!*n || strcmp((*n)->name, name)) {
344 WARN_ON(1);
Akinobu Mita294462a2007-07-17 04:03:45 -0700345 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 p = *n;
347 *n = p->next;
348 }
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200349 mutex_unlock(&block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 kfree(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
353EXPORT_SYMBOL(unregister_blkdev);
354
355static struct kobj_map *bdev_map;
356
Tejun Heobcce3de2008-08-25 19:47:22 +0900357/**
Tejun Heo870d6652008-08-25 19:47:25 +0900358 * blk_mangle_minor - scatter minor numbers apart
359 * @minor: minor number to mangle
360 *
361 * Scatter consecutively allocated @minor number apart if MANGLE_DEVT
362 * is enabled. Mangling twice gives the original value.
363 *
364 * RETURNS:
365 * Mangled value.
366 *
367 * CONTEXT:
368 * Don't care.
369 */
370static int blk_mangle_minor(int minor)
371{
372#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
373 int i;
374
375 for (i = 0; i < MINORBITS / 2; i++) {
376 int low = minor & (1 << i);
377 int high = minor & (1 << (MINORBITS - 1 - i));
378 int distance = MINORBITS - 1 - 2 * i;
379
380 minor ^= low | high; /* clear both bits */
381 low <<= distance; /* swap the positions */
382 high >>= distance;
383 minor |= low | high; /* and set */
384 }
385#endif
386 return minor;
387}
388
389/**
Tejun Heobcce3de2008-08-25 19:47:22 +0900390 * blk_alloc_devt - allocate a dev_t for a partition
391 * @part: partition to allocate dev_t for
Tejun Heobcce3de2008-08-25 19:47:22 +0900392 * @devt: out parameter for resulting dev_t
393 *
394 * Allocate a dev_t for block device.
395 *
396 * RETURNS:
397 * 0 on success, allocated dev_t is returned in *@devt. -errno on
398 * failure.
399 *
400 * CONTEXT:
401 * Might sleep.
402 */
403int blk_alloc_devt(struct hd_struct *part, dev_t *devt)
404{
405 struct gendisk *disk = part_to_disk(part);
406 int idx, rc;
407
408 /* in consecutive minor range? */
409 if (part->partno < disk->minors) {
410 *devt = MKDEV(disk->major, disk->first_minor + part->partno);
411 return 0;
412 }
413
414 /* allocate ext devt */
415 do {
416 if (!idr_pre_get(&ext_devt_idr, GFP_KERNEL))
417 return -ENOMEM;
418 rc = idr_get_new(&ext_devt_idr, part, &idx);
419 } while (rc == -EAGAIN);
420
421 if (rc)
422 return rc;
423
424 if (idx > MAX_EXT_DEVT) {
425 idr_remove(&ext_devt_idr, idx);
426 return -EBUSY;
427 }
428
Tejun Heo870d6652008-08-25 19:47:25 +0900429 *devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
Tejun Heobcce3de2008-08-25 19:47:22 +0900430 return 0;
431}
432
433/**
434 * blk_free_devt - free a dev_t
435 * @devt: dev_t to free
436 *
437 * Free @devt which was allocated using blk_alloc_devt().
438 *
439 * CONTEXT:
440 * Might sleep.
441 */
442void blk_free_devt(dev_t devt)
443{
444 might_sleep();
445
446 if (devt == MKDEV(0, 0))
447 return;
448
449 if (MAJOR(devt) == BLOCK_EXT_MAJOR) {
450 mutex_lock(&ext_devt_mutex);
Tejun Heo870d6652008-08-25 19:47:25 +0900451 idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
Tejun Heobcce3de2008-08-25 19:47:22 +0900452 mutex_unlock(&ext_devt_mutex);
453 }
454}
455
Tejun Heo1f014292008-08-25 19:47:23 +0900456static char *bdevt_str(dev_t devt, char *buf)
457{
458 if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) {
459 char tbuf[BDEVT_SIZE];
460 snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt));
461 snprintf(buf, BDEVT_SIZE, "%-9s", tbuf);
462 } else
463 snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt));
464
465 return buf;
466}
467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468/*
469 * Register device numbers dev..(dev+range-1)
470 * range must be nonzero
471 * The hash chain is sorted on range, so that subranges can override.
472 */
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200473void blk_register_region(dev_t devt, unsigned long range, struct module *module,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 struct kobject *(*probe)(dev_t, int *, void *),
475 int (*lock)(dev_t, void *), void *data)
476{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200477 kobj_map(bdev_map, devt, range, module, probe, lock, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478}
479
480EXPORT_SYMBOL(blk_register_region);
481
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200482void blk_unregister_region(dev_t devt, unsigned long range)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200484 kobj_unmap(bdev_map, devt, range);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
487EXPORT_SYMBOL(blk_unregister_region);
488
Tejun Heocf771cb2008-09-03 09:01:09 +0200489static struct kobject *exact_match(dev_t devt, int *partno, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
491 struct gendisk *p = data;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200492
Tejun Heoed9e1982008-08-25 19:56:05 +0900493 return &disk_to_dev(p)->kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494}
495
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200496static int exact_lock(dev_t devt, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497{
498 struct gendisk *p = data;
499
500 if (!get_disk(p))
501 return -1;
502 return 0;
503}
504
505/**
506 * add_disk - add partitioning information to kernel list
507 * @disk: per-device partitioning information
508 *
509 * This function registers the partitioning information in @disk
510 * with the kernel.
Tejun Heo3e1a7ff2008-08-25 19:56:17 +0900511 *
512 * FIXME: error handling
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 */
514void add_disk(struct gendisk *disk)
515{
Peter Zijlstracf0ca9f2008-04-30 00:54:32 -0700516 struct backing_dev_info *bdi;
Tejun Heo3e1a7ff2008-08-25 19:56:17 +0900517 dev_t devt;
Greg Kroah-Hartman6ffeea72008-05-22 17:21:08 -0400518 int retval;
Peter Zijlstracf0ca9f2008-04-30 00:54:32 -0700519
Tejun Heo3e1a7ff2008-08-25 19:56:17 +0900520 /* minors == 0 indicates to use ext devt from part0 and should
521 * be accompanied with EXT_DEVT flag. Make sure all
522 * parameters make sense.
523 */
524 WARN_ON(disk->minors && !(disk->major || disk->first_minor));
525 WARN_ON(!disk->minors && !(disk->flags & GENHD_FL_EXT_DEVT));
526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 disk->flags |= GENHD_FL_UP;
Tejun Heo3e1a7ff2008-08-25 19:56:17 +0900528
529 retval = blk_alloc_devt(&disk->part0, &devt);
530 if (retval) {
531 WARN_ON(1);
532 return;
533 }
534 disk_to_dev(disk)->devt = devt;
535
536 /* ->major and ->first_minor aren't supposed to be
537 * dereferenced from here on, but set them just in case.
538 */
539 disk->major = MAJOR(devt);
540 disk->first_minor = MINOR(devt);
541
Signed-off-by: Jan Kara01ea5062010-09-16 20:36:36 +0200542 /* Register BDI before referencing it from bdev */
543 bdi = &disk->queue->backing_dev_info;
544 bdi_register_dev(bdi, disk_devt(disk));
545
Tejun Heof331c022008-09-03 09:01:48 +0200546 blk_register_region(disk_devt(disk), disk->minors, NULL,
547 exact_match, exact_lock, disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 register_disk(disk);
549 blk_register_queue(disk);
Peter Zijlstracf0ca9f2008-04-30 00:54:32 -0700550
Tejun Heoed9e1982008-08-25 19:56:05 +0900551 retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
552 "bdi");
Greg Kroah-Hartman6ffeea72008-05-22 17:21:08 -0400553 WARN_ON(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554}
555
556EXPORT_SYMBOL(add_disk);
557EXPORT_SYMBOL(del_gendisk); /* in partitions/check.c */
558
559void unlink_gendisk(struct gendisk *disk)
560{
Tejun Heoed9e1982008-08-25 19:56:05 +0900561 sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
Peter Zijlstracf0ca9f2008-04-30 00:54:32 -0700562 bdi_unregister(&disk->queue->backing_dev_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 blk_unregister_queue(disk);
Tejun Heof331c022008-09-03 09:01:48 +0200564 blk_unregister_region(disk_devt(disk), disk->minors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565}
566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567/**
568 * get_gendisk - get partitioning information for a given device
Randy Dunlap710027a2008-08-19 20:13:11 +0200569 * @devt: device to get partitioning information for
Randy Dunlap496aa8a2008-10-16 07:46:23 +0200570 * @partno: returned partition index
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 *
572 * This function gets the structure containing partitioning
Randy Dunlap710027a2008-08-19 20:13:11 +0200573 * information for the given device @devt.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 */
Tejun Heocf771cb2008-09-03 09:01:09 +0200575struct gendisk *get_gendisk(dev_t devt, int *partno)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
Tejun Heobcce3de2008-08-25 19:47:22 +0900577 struct gendisk *disk = NULL;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200578
Tejun Heobcce3de2008-08-25 19:47:22 +0900579 if (MAJOR(devt) != BLOCK_EXT_MAJOR) {
580 struct kobject *kobj;
581
582 kobj = kobj_lookup(bdev_map, devt, partno);
583 if (kobj)
584 disk = dev_to_disk(kobj_to_dev(kobj));
585 } else {
586 struct hd_struct *part;
587
588 mutex_lock(&ext_devt_mutex);
Tejun Heo870d6652008-08-25 19:47:25 +0900589 part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
Tejun Heobcce3de2008-08-25 19:47:22 +0900590 if (part && get_disk(part_to_disk(part))) {
591 *partno = part->partno;
592 disk = part_to_disk(part);
593 }
594 mutex_unlock(&ext_devt_mutex);
595 }
596
597 return disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598}
Divyesh Shahb6ac23af2010-04-15 08:54:59 +0200599EXPORT_SYMBOL(get_gendisk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Tejun Heof331c022008-09-03 09:01:48 +0200601/**
602 * bdget_disk - do bdget() by gendisk and partition number
603 * @disk: gendisk of interest
604 * @partno: partition number
605 *
606 * Find partition @partno from @disk, do bdget() on it.
607 *
608 * CONTEXT:
609 * Don't care.
610 *
611 * RETURNS:
612 * Resulting block_device on success, NULL on failure.
613 */
Harvey Harrisonaeb3d3a2008-08-28 09:27:42 +0200614struct block_device *bdget_disk(struct gendisk *disk, int partno)
Tejun Heof331c022008-09-03 09:01:48 +0200615{
Tejun Heo548b10e2008-08-29 09:01:47 +0200616 struct hd_struct *part;
617 struct block_device *bdev = NULL;
Tejun Heof331c022008-09-03 09:01:48 +0200618
Tejun Heo548b10e2008-08-29 09:01:47 +0200619 part = disk_get_part(disk, partno);
Tejun Heo2bbedcb2008-08-29 11:41:51 +0200620 if (part)
Tejun Heo548b10e2008-08-29 09:01:47 +0200621 bdev = bdget(part_devt(part));
622 disk_put_part(part);
Tejun Heof331c022008-09-03 09:01:48 +0200623
Tejun Heo548b10e2008-08-29 09:01:47 +0200624 return bdev;
Tejun Heof331c022008-09-03 09:01:48 +0200625}
626EXPORT_SYMBOL(bdget_disk);
627
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700628/*
629 * print a full list of all partitions - intended for places where the root
630 * filesystem can't be mounted and thus to give the victim some idea of what
631 * went wrong
632 */
633void __init printk_all_partitions(void)
634{
Tejun Heodef4e382008-09-03 08:57:12 +0200635 struct class_dev_iter iter;
636 struct device *dev;
637
638 class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
639 while ((dev = class_dev_iter_next(&iter))) {
640 struct gendisk *disk = dev_to_disk(dev);
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200641 struct disk_part_iter piter;
642 struct hd_struct *part;
Tejun Heo1f014292008-08-25 19:47:23 +0900643 char name_buf[BDEVNAME_SIZE];
644 char devt_buf[BDEVT_SIZE];
Will Drewryb5af9212010-08-31 15:47:07 -0500645 u8 uuid[PARTITION_META_INFO_UUIDLTH * 2 + 1];
Tejun Heodef4e382008-09-03 08:57:12 +0200646
647 /*
648 * Don't show empty devices or things that have been
649 * surpressed
650 */
651 if (get_capacity(disk) == 0 ||
652 (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
653 continue;
654
655 /*
656 * Note, unlike /proc/partitions, I am showing the
657 * numbers in hex - the same format as the root=
658 * option takes.
659 */
Tejun Heo074a7ac2008-08-25 19:56:14 +0900660 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
661 while ((part = disk_part_iter_next(&piter))) {
662 bool is_part0 = part == &disk->part0;
Tejun Heodef4e382008-09-03 08:57:12 +0200663
Will Drewryb5af9212010-08-31 15:47:07 -0500664 uuid[0] = 0;
665 if (part->info)
666 part_unpack_uuid(part->info->uuid, uuid);
667
668 printk("%s%s %10llu %s %s", is_part0 ? "" : " ",
Tejun Heo1f014292008-08-25 19:47:23 +0900669 bdevt_str(part_devt(part), devt_buf),
Tejun Heof331c022008-09-03 09:01:48 +0200670 (unsigned long long)part->nr_sects >> 1,
Will Drewryb5af9212010-08-31 15:47:07 -0500671 disk_name(disk, part->partno, name_buf), uuid);
Tejun Heo074a7ac2008-08-25 19:56:14 +0900672 if (is_part0) {
673 if (disk->driverfs_dev != NULL &&
674 disk->driverfs_dev->driver != NULL)
675 printk(" driver: %s\n",
676 disk->driverfs_dev->driver->name);
677 else
678 printk(" (driver?)\n");
679 } else
680 printk("\n");
681 }
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200682 disk_part_iter_exit(&piter);
Tejun Heodef4e382008-09-03 08:57:12 +0200683 }
684 class_dev_iter_exit(&iter);
Dave Gilbertdd2a3452007-05-09 02:33:24 -0700685}
686
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687#ifdef CONFIG_PROC_FS
688/* iterator */
Tejun Heodef4e382008-09-03 08:57:12 +0200689static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
Greg Kroah-Hartman68c4d4a2008-05-22 17:21:08 -0400690{
Tejun Heodef4e382008-09-03 08:57:12 +0200691 loff_t skip = *pos;
692 struct class_dev_iter *iter;
693 struct device *dev;
Greg Kroah-Hartman68c4d4a2008-05-22 17:21:08 -0400694
Harvey Harrisonaeb3d3a2008-08-28 09:27:42 +0200695 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
Tejun Heodef4e382008-09-03 08:57:12 +0200696 if (!iter)
697 return ERR_PTR(-ENOMEM);
698
699 seqf->private = iter;
700 class_dev_iter_init(iter, &block_class, NULL, &disk_type);
701 do {
702 dev = class_dev_iter_next(iter);
703 if (!dev)
704 return NULL;
705 } while (skip--);
706
707 return dev_to_disk(dev);
Greg Kroah-Hartman68c4d4a2008-05-22 17:21:08 -0400708}
709
Tejun Heodef4e382008-09-03 08:57:12 +0200710static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200712 struct device *dev;
Greg Kroah-Hartman66c64af2008-05-22 17:21:08 -0400713
Tejun Heodef4e382008-09-03 08:57:12 +0200714 (*pos)++;
715 dev = class_dev_iter_next(seqf->private);
Tejun Heo2ac3cee2008-09-03 08:53:37 +0200716 if (dev)
Greg Kroah-Hartman68c4d4a2008-05-22 17:21:08 -0400717 return dev_to_disk(dev);
Tejun Heo2ac3cee2008-09-03 08:53:37 +0200718
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 return NULL;
720}
721
Tejun Heodef4e382008-09-03 08:57:12 +0200722static void disk_seqf_stop(struct seq_file *seqf, void *v)
Greg Kroah-Hartman27f30252008-05-22 17:21:08 -0400723{
Tejun Heodef4e382008-09-03 08:57:12 +0200724 struct class_dev_iter *iter = seqf->private;
Greg Kroah-Hartman27f30252008-05-22 17:21:08 -0400725
Tejun Heodef4e382008-09-03 08:57:12 +0200726 /* stop is called even after start failed :-( */
727 if (iter) {
728 class_dev_iter_exit(iter);
729 kfree(iter);
Kay Sievers5c0ef6d2008-08-16 14:30:30 +0200730 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731}
732
Tejun Heodef4e382008-09-03 08:57:12 +0200733static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
Tejun Heodef4e382008-09-03 08:57:12 +0200735 static void *p;
736
737 p = disk_seqf_start(seqf, pos);
Tejun Heo243294d2008-09-04 09:17:31 +0200738 if (!IS_ERR(p) && p && !*pos)
Tejun Heodef4e382008-09-03 08:57:12 +0200739 seq_puts(seqf, "major minor #blocks name\n\n");
740 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741}
742
Tejun Heocf771cb2008-09-03 09:01:09 +0200743static int show_partition(struct seq_file *seqf, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744{
745 struct gendisk *sgp = v;
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200746 struct disk_part_iter piter;
747 struct hd_struct *part;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 char buf[BDEVNAME_SIZE];
749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 /* Don't show non-partitionable removeable devices or empty devices */
Tejun Heob5d0b9d2008-09-03 09:06:42 +0200751 if (!get_capacity(sgp) || (!disk_partitionable(sgp) &&
Tejun Heof331c022008-09-03 09:01:48 +0200752 (sgp->flags & GENHD_FL_REMOVABLE)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return 0;
754 if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
755 return 0;
756
757 /* show the full disk and all non-0 size partitions of it */
Tejun Heo074a7ac2008-08-25 19:56:14 +0900758 disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0);
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200759 while ((part = disk_part_iter_next(&piter)))
Tejun Heo1f014292008-08-25 19:47:23 +0900760 seq_printf(seqf, "%4d %7d %10llu %s\n",
Tejun Heof331c022008-09-03 09:01:48 +0200761 MAJOR(part_devt(part)), MINOR(part_devt(part)),
762 (unsigned long long)part->nr_sects >> 1,
763 disk_name(sgp, part->partno, buf));
Tejun Heoe71bf0d2008-09-03 09:03:02 +0200764 disk_part_iter_exit(&piter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766 return 0;
767}
768
Alexey Dobriyanf5009752008-10-04 23:53:21 +0400769static const struct seq_operations partitions_op = {
Tejun Heodef4e382008-09-03 08:57:12 +0200770 .start = show_partition_start,
771 .next = disk_seqf_next,
772 .stop = disk_seqf_stop,
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200773 .show = show_partition
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774};
Alexey Dobriyanf5009752008-10-04 23:53:21 +0400775
776static int partitions_open(struct inode *inode, struct file *file)
777{
778 return seq_open(file, &partitions_op);
779}
780
781static const struct file_operations proc_partitions_operations = {
782 .open = partitions_open,
783 .read = seq_read,
784 .llseek = seq_lseek,
785 .release = seq_release,
786};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787#endif
788
789
Tejun Heocf771cb2008-09-03 09:01:09 +0200790static struct kobject *base_probe(dev_t devt, int *partno, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200792 if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 /* Make old-style 2.4 aliases work */
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200794 request_module("block-major-%d", MAJOR(devt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 return NULL;
796}
797
798static int __init genhd_device_init(void)
799{
Dan Williamse105b8b2008-04-21 10:51:07 -0700800 int error;
801
802 block_class.dev_kobj = sysfs_dev_block_kobj;
803 error = class_register(&block_class);
Roland McGrathee27a552008-03-11 17:13:15 -0700804 if (unlikely(error))
805 return error;
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200806 bdev_map = kobj_map_init(base_probe, &block_class_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 blk_dev_init();
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200808
Zhang, Yanmin561ec682008-11-14 08:26:30 +0100809 register_blkdev(BLOCK_EXT_MAJOR, "blkext");
810
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200811 /* create top-level block dir */
Andi Kleene52eec12010-09-08 16:54:17 +0200812 if (!sysfs_deprecated)
813 block_depr = kobject_create_and_add("block", NULL);
Greg Kroah-Hartman830d3cf2007-11-06 10:36:58 -0800814 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815}
816
817subsys_initcall(genhd_device_init);
818
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200819static ssize_t disk_range_show(struct device *dev,
820 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200822 struct gendisk *disk = dev_to_disk(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200824 return sprintf(buf, "%d\n", disk->minors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825}
826
Tejun Heo1f014292008-08-25 19:47:23 +0900827static ssize_t disk_ext_range_show(struct device *dev,
828 struct device_attribute *attr, char *buf)
829{
830 struct gendisk *disk = dev_to_disk(dev);
831
Tejun Heob5d0b9d2008-09-03 09:06:42 +0200832 return sprintf(buf, "%d\n", disk_max_parts(disk));
Tejun Heo1f014292008-08-25 19:47:23 +0900833}
834
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200835static ssize_t disk_removable_show(struct device *dev,
836 struct device_attribute *attr, char *buf)
Kay Sieversa7fd6702005-10-01 14:49:43 +0200837{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200838 struct gendisk *disk = dev_to_disk(dev);
Kay Sieversa7fd6702005-10-01 14:49:43 +0200839
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200840 return sprintf(buf, "%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200842}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Kay Sievers1c9ce522008-06-13 09:41:00 +0200844static ssize_t disk_ro_show(struct device *dev,
845 struct device_attribute *attr, char *buf)
846{
847 struct gendisk *disk = dev_to_disk(dev);
848
Tejun Heob7db9952008-08-25 19:56:10 +0900849 return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
Kay Sievers1c9ce522008-06-13 09:41:00 +0200850}
851
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200852static ssize_t disk_capability_show(struct device *dev,
853 struct device_attribute *attr, char *buf)
Kristen Carlson Accardi86ce18d2007-05-23 13:57:38 -0700854{
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200855 struct gendisk *disk = dev_to_disk(dev);
856
857 return sprintf(buf, "%x\n", disk->flags);
Kristen Carlson Accardi86ce18d2007-05-23 13:57:38 -0700858}
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200859
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400860static ssize_t disk_alignment_offset_show(struct device *dev,
861 struct device_attribute *attr,
862 char *buf)
863{
864 struct gendisk *disk = dev_to_disk(dev);
865
866 return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
867}
868
Martin K. Petersen86b37282009-11-10 11:50:21 +0100869static ssize_t disk_discard_alignment_show(struct device *dev,
870 struct device_attribute *attr,
871 char *buf)
872{
873 struct gendisk *disk = dev_to_disk(dev);
874
Martin K. Petersendd3d1452010-01-11 03:21:48 -0500875 return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
Martin K. Petersen86b37282009-11-10 11:50:21 +0100876}
877
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200878static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
Tejun Heo1f014292008-08-25 19:47:23 +0900879static DEVICE_ATTR(ext_range, S_IRUGO, disk_ext_range_show, NULL);
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200880static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
Kay Sievers1c9ce522008-06-13 09:41:00 +0200881static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
Tejun Heoe5610522008-08-25 19:56:09 +0900882static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400883static DEVICE_ATTR(alignment_offset, S_IRUGO, disk_alignment_offset_show, NULL);
Martin K. Petersen86b37282009-11-10 11:50:21 +0100884static DEVICE_ATTR(discard_alignment, S_IRUGO, disk_discard_alignment_show,
885 NULL);
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200886static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
Tejun Heo074a7ac2008-08-25 19:56:14 +0900887static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
Nikanth Karthikesan316d3152009-10-06 20:16:55 +0200888static DEVICE_ATTR(inflight, S_IRUGO, part_inflight_show, NULL);
Akinobu Mitac17bb492006-12-08 02:39:46 -0800889#ifdef CONFIG_FAIL_MAKE_REQUEST
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200890static struct device_attribute dev_attr_fail =
Tejun Heoeddb2e22008-08-25 19:56:13 +0900891 __ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store);
Akinobu Mitac17bb492006-12-08 02:39:46 -0800892#endif
Jens Axboe581d4e22008-09-14 05:56:33 -0700893#ifdef CONFIG_FAIL_IO_TIMEOUT
894static struct device_attribute dev_attr_fail_timeout =
895 __ATTR(io-timeout-fail, S_IRUGO|S_IWUSR, part_timeout_show,
896 part_timeout_store);
897#endif
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200898
899static struct attribute *disk_attrs[] = {
900 &dev_attr_range.attr,
Tejun Heo1f014292008-08-25 19:47:23 +0900901 &dev_attr_ext_range.attr,
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200902 &dev_attr_removable.attr,
Kay Sievers1c9ce522008-06-13 09:41:00 +0200903 &dev_attr_ro.attr,
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200904 &dev_attr_size.attr,
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400905 &dev_attr_alignment_offset.attr,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100906 &dev_attr_discard_alignment.attr,
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200907 &dev_attr_capability.attr,
908 &dev_attr_stat.attr,
Nikanth Karthikesan316d3152009-10-06 20:16:55 +0200909 &dev_attr_inflight.attr,
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200910#ifdef CONFIG_FAIL_MAKE_REQUEST
911 &dev_attr_fail.attr,
912#endif
Jens Axboe581d4e22008-09-14 05:56:33 -0700913#ifdef CONFIG_FAIL_IO_TIMEOUT
914 &dev_attr_fail_timeout.attr,
915#endif
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200916 NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917};
918
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200919static struct attribute_group disk_attr_group = {
920 .attrs = disk_attrs,
921};
922
David Brownella4dbd672009-06-24 10:06:31 -0700923static const struct attribute_group *disk_attr_groups[] = {
Kay Sieversedfaa7c2007-05-21 22:08:01 +0200924 &disk_attr_group,
925 NULL
926};
927
Tejun Heo540eed52008-08-25 19:56:15 +0900928static void disk_free_ptbl_rcu_cb(struct rcu_head *head)
929{
930 struct disk_part_tbl *ptbl =
931 container_of(head, struct disk_part_tbl, rcu_head);
932
933 kfree(ptbl);
934}
935
936/**
937 * disk_replace_part_tbl - replace disk->part_tbl in RCU-safe way
938 * @disk: disk to replace part_tbl for
939 * @new_ptbl: new part_tbl to install
940 *
941 * Replace disk->part_tbl with @new_ptbl in RCU-safe way. The
942 * original ptbl is freed using RCU callback.
943 *
944 * LOCKING:
945 * Matching bd_mutx locked.
946 */
947static void disk_replace_part_tbl(struct gendisk *disk,
948 struct disk_part_tbl *new_ptbl)
949{
950 struct disk_part_tbl *old_ptbl = disk->part_tbl;
951
952 rcu_assign_pointer(disk->part_tbl, new_ptbl);
Jens Axboea6f23652008-10-24 12:52:42 +0200953
954 if (old_ptbl) {
955 rcu_assign_pointer(old_ptbl->last_lookup, NULL);
Tejun Heo540eed52008-08-25 19:56:15 +0900956 call_rcu(&old_ptbl->rcu_head, disk_free_ptbl_rcu_cb);
Jens Axboea6f23652008-10-24 12:52:42 +0200957 }
Tejun Heo540eed52008-08-25 19:56:15 +0900958}
959
960/**
961 * disk_expand_part_tbl - expand disk->part_tbl
962 * @disk: disk to expand part_tbl for
963 * @partno: expand such that this partno can fit in
964 *
965 * Expand disk->part_tbl such that @partno can fit in. disk->part_tbl
966 * uses RCU to allow unlocked dereferencing for stats and other stuff.
967 *
968 * LOCKING:
969 * Matching bd_mutex locked, might sleep.
970 *
971 * RETURNS:
972 * 0 on success, -errno on failure.
973 */
974int disk_expand_part_tbl(struct gendisk *disk, int partno)
975{
976 struct disk_part_tbl *old_ptbl = disk->part_tbl;
977 struct disk_part_tbl *new_ptbl;
978 int len = old_ptbl ? old_ptbl->len : 0;
979 int target = partno + 1;
980 size_t size;
981 int i;
982
983 /* disk_max_parts() is zero during initialization, ignore if so */
984 if (disk_max_parts(disk) && target > disk_max_parts(disk))
985 return -EINVAL;
986
987 if (target <= len)
988 return 0;
989
990 size = sizeof(*new_ptbl) + target * sizeof(new_ptbl->part[0]);
991 new_ptbl = kzalloc_node(size, GFP_KERNEL, disk->node_id);
992 if (!new_ptbl)
993 return -ENOMEM;
994
Tejun Heo540eed52008-08-25 19:56:15 +0900995 new_ptbl->len = target;
996
997 for (i = 0; i < len; i++)
998 rcu_assign_pointer(new_ptbl->part[i], old_ptbl->part[i]);
999
1000 disk_replace_part_tbl(disk, new_ptbl);
1001 return 0;
1002}
1003
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001004static void disk_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005{
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001006 struct gendisk *disk = dev_to_disk(dev);
1007
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 kfree(disk->random);
Tejun Heo540eed52008-08-25 19:56:15 +09001009 disk_replace_part_tbl(disk, NULL);
Tejun Heo074a7ac2008-08-25 19:56:14 +09001010 free_part_stats(&disk->part0);
Will Drewry6d1d8052010-08-31 15:47:05 -05001011 free_part_info(&disk->part0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 kfree(disk);
1013}
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001014struct class block_class = {
1015 .name = "block",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016};
1017
Kay Sieverse454cea2009-09-18 23:01:12 +02001018static char *block_devnode(struct device *dev, mode_t *mode)
Kay Sieversb03f38b2009-04-30 15:23:42 +02001019{
1020 struct gendisk *disk = dev_to_disk(dev);
1021
Kay Sieverse454cea2009-09-18 23:01:12 +02001022 if (disk->devnode)
1023 return disk->devnode(disk, mode);
Kay Sieversb03f38b2009-04-30 15:23:42 +02001024 return NULL;
1025}
1026
Adrian Bunk1826ead2008-03-04 11:23:46 +01001027static struct device_type disk_type = {
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001028 .name = "disk",
1029 .groups = disk_attr_groups,
1030 .release = disk_release,
Kay Sieverse454cea2009-09-18 23:01:12 +02001031 .devnode = block_devnode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032};
1033
Randy Dunlapa6e2ba82008-05-23 09:44:11 -07001034#ifdef CONFIG_PROC_FS
Tejun Heocf771cb2008-09-03 09:01:09 +02001035/*
1036 * aggregate disk stat collector. Uses the same stats that the sysfs
1037 * entries do, above, but makes them available through one seq_file.
1038 *
1039 * The output looks suspiciously like /proc/partitions with a bunch of
1040 * extra fields.
1041 */
1042static int diskstats_show(struct seq_file *seqf, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043{
1044 struct gendisk *gp = v;
Tejun Heoe71bf0d2008-09-03 09:03:02 +02001045 struct disk_part_iter piter;
1046 struct hd_struct *hd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 char buf[BDEVNAME_SIZE];
Tejun Heoc9959052008-08-25 19:47:21 +09001048 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049
1050 /*
Tejun Heoed9e1982008-08-25 19:56:05 +09001051 if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
Tejun Heocf771cb2008-09-03 09:01:09 +02001052 seq_puts(seqf, "major minor name"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 " rio rmerge rsect ruse wio wmerge "
1054 "wsect wuse running use aveq"
1055 "\n\n");
1056 */
1057
Tejun Heo71982a42009-04-17 08:34:48 +02001058 disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0);
Tejun Heoe71bf0d2008-09-03 09:03:02 +02001059 while ((hd = disk_part_iter_next(&piter))) {
Tejun Heo074a7ac2008-08-25 19:56:14 +09001060 cpu = part_stat_lock();
Tejun Heoc9959052008-08-25 19:47:21 +09001061 part_round_stats(cpu, hd);
Tejun Heo074a7ac2008-08-25 19:56:14 +09001062 part_stat_unlock();
Tejun Heo1f014292008-08-25 19:47:23 +09001063 seq_printf(seqf, "%4d %7d %s %lu %lu %llu "
Jerome Marchand28f39d52008-02-08 11:04:56 +01001064 "%u %lu %lu %llu %u %u %u %u\n",
Tejun Heof331c022008-09-03 09:01:48 +02001065 MAJOR(part_devt(hd)), MINOR(part_devt(hd)),
1066 disk_name(gp, hd->partno, buf),
Jerome Marchand28f39d52008-02-08 11:04:56 +01001067 part_stat_read(hd, ios[0]),
1068 part_stat_read(hd, merges[0]),
1069 (unsigned long long)part_stat_read(hd, sectors[0]),
1070 jiffies_to_msecs(part_stat_read(hd, ticks[0])),
1071 part_stat_read(hd, ios[1]),
1072 part_stat_read(hd, merges[1]),
1073 (unsigned long long)part_stat_read(hd, sectors[1]),
1074 jiffies_to_msecs(part_stat_read(hd, ticks[1])),
Nikanth Karthikesan316d3152009-10-06 20:16:55 +02001075 part_in_flight(hd),
Jerome Marchand28f39d52008-02-08 11:04:56 +01001076 jiffies_to_msecs(part_stat_read(hd, io_ticks)),
1077 jiffies_to_msecs(part_stat_read(hd, time_in_queue))
1078 );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 }
Tejun Heoe71bf0d2008-09-03 09:03:02 +02001080 disk_part_iter_exit(&piter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
1082 return 0;
1083}
1084
Alexey Dobriyan31d85ab2008-10-06 12:55:38 +04001085static const struct seq_operations diskstats_op = {
Tejun Heodef4e382008-09-03 08:57:12 +02001086 .start = disk_seqf_start,
1087 .next = disk_seqf_next,
1088 .stop = disk_seqf_stop,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 .show = diskstats_show
1090};
Alexey Dobriyanf5009752008-10-04 23:53:21 +04001091
Alexey Dobriyan31d85ab2008-10-06 12:55:38 +04001092static int diskstats_open(struct inode *inode, struct file *file)
1093{
1094 return seq_open(file, &diskstats_op);
1095}
1096
1097static const struct file_operations proc_diskstats_operations = {
1098 .open = diskstats_open,
1099 .read = seq_read,
1100 .llseek = seq_lseek,
1101 .release = seq_release,
1102};
1103
Alexey Dobriyanf5009752008-10-04 23:53:21 +04001104static int __init proc_genhd_init(void)
1105{
Alexey Dobriyan31d85ab2008-10-06 12:55:38 +04001106 proc_create("diskstats", 0, NULL, &proc_diskstats_operations);
Alexey Dobriyanf5009752008-10-04 23:53:21 +04001107 proc_create("partitions", 0, NULL, &proc_partitions_operations);
1108 return 0;
1109}
1110module_init(proc_genhd_init);
Randy Dunlapa6e2ba82008-05-23 09:44:11 -07001111#endif /* CONFIG_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
Kristen Carlson Accardi8ce7ad72007-05-23 13:57:38 -07001113static void media_change_notify_thread(struct work_struct *work)
1114{
1115 struct gendisk *gd = container_of(work, struct gendisk, async_notify);
1116 char event[] = "MEDIA_CHANGE=1";
1117 char *envp[] = { event, NULL };
1118
1119 /*
1120 * set enviroment vars to indicate which event this is for
1121 * so that user space will know to go check the media status.
1122 */
Tejun Heoed9e1982008-08-25 19:56:05 +09001123 kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
Kristen Carlson Accardi8ce7ad72007-05-23 13:57:38 -07001124 put_device(gd->driverfs_dev);
1125}
1126
Adrian Bunk1826ead2008-03-04 11:23:46 +01001127#if 0
Kristen Carlson Accardi8ce7ad72007-05-23 13:57:38 -07001128void genhd_media_change_notify(struct gendisk *disk)
1129{
1130 get_device(disk->driverfs_dev);
1131 schedule_work(&disk->async_notify);
1132}
1133EXPORT_SYMBOL_GPL(genhd_media_change_notify);
Adrian Bunk1826ead2008-03-04 11:23:46 +01001134#endif /* 0 */
Kristen Carlson Accardi8ce7ad72007-05-23 13:57:38 -07001135
Tejun Heocf771cb2008-09-03 09:01:09 +02001136dev_t blk_lookup_devt(const char *name, int partno)
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001137{
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001138 dev_t devt = MKDEV(0, 0);
Tejun Heodef4e382008-09-03 08:57:12 +02001139 struct class_dev_iter iter;
1140 struct device *dev;
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001141
Tejun Heodef4e382008-09-03 08:57:12 +02001142 class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
1143 while ((dev = class_dev_iter_next(&iter))) {
1144 struct gendisk *disk = dev_to_disk(dev);
Tejun Heo548b10e2008-08-29 09:01:47 +02001145 struct hd_struct *part;
Tejun Heodef4e382008-09-03 08:57:12 +02001146
Kay Sievers3ada8b72009-01-06 10:44:43 -08001147 if (strcmp(dev_name(dev), name))
Tejun Heof331c022008-09-03 09:01:48 +02001148 continue;
Tejun Heof331c022008-09-03 09:01:48 +02001149
Neil Brown41b8c852009-02-18 10:33:59 +01001150 if (partno < disk->minors) {
1151 /* We need to return the right devno, even
1152 * if the partition doesn't exist yet.
1153 */
1154 devt = MKDEV(MAJOR(dev->devt),
1155 MINOR(dev->devt) + partno);
1156 break;
1157 }
Tejun Heo548b10e2008-08-29 09:01:47 +02001158 part = disk_get_part(disk, partno);
Tejun Heo2bbedcb2008-08-29 11:41:51 +02001159 if (part) {
Tejun Heof331c022008-09-03 09:01:48 +02001160 devt = part_devt(part);
Tejun Heoe71bf0d2008-09-03 09:03:02 +02001161 disk_put_part(part);
Tejun Heo548b10e2008-08-29 09:01:47 +02001162 break;
Tejun Heodef4e382008-09-03 08:57:12 +02001163 }
Tejun Heo548b10e2008-08-29 09:01:47 +02001164 disk_put_part(part);
Kay Sievers5c0ef6d2008-08-16 14:30:30 +02001165 }
Tejun Heodef4e382008-09-03 08:57:12 +02001166 class_dev_iter_exit(&iter);
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001167 return devt;
1168}
Kay Sieversedfaa7c2007-05-21 22:08:01 +02001169EXPORT_SYMBOL(blk_lookup_devt);
1170
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171struct gendisk *alloc_disk(int minors)
1172{
Christoph Lameter19460892005-06-23 00:08:19 -07001173 return alloc_disk_node(minors, -1);
1174}
Tejun Heo689d6fa2008-08-25 19:56:16 +09001175EXPORT_SYMBOL(alloc_disk);
Christoph Lameter19460892005-06-23 00:08:19 -07001176
1177struct gendisk *alloc_disk_node(int minors, int node_id)
1178{
1179 struct gendisk *disk;
1180
Christoph Lameter94f60302007-07-17 04:03:29 -07001181 disk = kmalloc_node(sizeof(struct gendisk),
1182 GFP_KERNEL | __GFP_ZERO, node_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 if (disk) {
Tejun Heo074a7ac2008-08-25 19:56:14 +09001184 if (!init_part_stats(&disk->part0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 kfree(disk);
1186 return NULL;
1187 }
Cheng Renquanbf91db12008-11-20 08:37:37 +01001188 disk->node_id = node_id;
Tejun Heo540eed52008-08-25 19:56:15 +09001189 if (disk_expand_part_tbl(disk, 0)) {
1190 free_part_stats(&disk->part0);
Tejun Heob5d0b9d2008-09-03 09:06:42 +02001191 kfree(disk);
1192 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 }
Tejun Heo540eed52008-08-25 19:56:15 +09001194 disk->part_tbl->part[0] = &disk->part0;
Tejun Heob5d0b9d2008-09-03 09:06:42 +02001195
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 disk->minors = minors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 rand_initialize_disk(disk);
Tejun Heoed9e1982008-08-25 19:56:05 +09001198 disk_to_dev(disk)->class = &block_class;
1199 disk_to_dev(disk)->type = &disk_type;
1200 device_initialize(disk_to_dev(disk));
Kristen Carlson Accardi8ce7ad72007-05-23 13:57:38 -07001201 INIT_WORK(&disk->async_notify,
1202 media_change_notify_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 }
1204 return disk;
1205}
Christoph Lameter19460892005-06-23 00:08:19 -07001206EXPORT_SYMBOL(alloc_disk_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208struct kobject *get_disk(struct gendisk *disk)
1209{
1210 struct module *owner;
1211 struct kobject *kobj;
1212
1213 if (!disk->fops)
1214 return NULL;
1215 owner = disk->fops->owner;
1216 if (owner && !try_module_get(owner))
1217 return NULL;
Tejun Heoed9e1982008-08-25 19:56:05 +09001218 kobj = kobject_get(&disk_to_dev(disk)->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 if (kobj == NULL) {
1220 module_put(owner);
1221 return NULL;
1222 }
1223 return kobj;
1224
1225}
1226
1227EXPORT_SYMBOL(get_disk);
1228
1229void put_disk(struct gendisk *disk)
1230{
1231 if (disk)
Tejun Heoed9e1982008-08-25 19:56:05 +09001232 kobject_put(&disk_to_dev(disk)->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233}
1234
1235EXPORT_SYMBOL(put_disk);
1236
Hannes Reineckee3264a42009-07-28 09:13:13 +02001237static void set_disk_ro_uevent(struct gendisk *gd, int ro)
1238{
1239 char event[] = "DISK_RO=1";
1240 char *envp[] = { event, NULL };
1241
1242 if (!ro)
1243 event[8] = '0';
1244 kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
1245}
1246
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247void set_device_ro(struct block_device *bdev, int flag)
1248{
Tejun Heob7db9952008-08-25 19:56:10 +09001249 bdev->bd_part->policy = flag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250}
1251
1252EXPORT_SYMBOL(set_device_ro);
1253
1254void set_disk_ro(struct gendisk *disk, int flag)
1255{
Tejun Heoe71bf0d2008-09-03 09:03:02 +02001256 struct disk_part_iter piter;
1257 struct hd_struct *part;
1258
Hannes Reineckee3264a42009-07-28 09:13:13 +02001259 if (disk->part0.policy != flag) {
1260 set_disk_ro_uevent(disk, flag);
1261 disk->part0.policy = flag;
1262 }
1263
1264 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
Tejun Heoe71bf0d2008-09-03 09:03:02 +02001265 while ((part = disk_part_iter_next(&piter)))
1266 part->policy = flag;
1267 disk_part_iter_exit(&piter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268}
1269
1270EXPORT_SYMBOL(set_disk_ro);
1271
1272int bdev_read_only(struct block_device *bdev)
1273{
1274 if (!bdev)
1275 return 0;
Tejun Heob7db9952008-08-25 19:56:10 +09001276 return bdev->bd_part->policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277}
1278
1279EXPORT_SYMBOL(bdev_read_only);
1280
Tejun Heocf771cb2008-09-03 09:01:09 +02001281int invalidate_partition(struct gendisk *disk, int partno)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282{
1283 int res = 0;
Tejun Heocf771cb2008-09-03 09:01:09 +02001284 struct block_device *bdev = bdget_disk(disk, partno);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 if (bdev) {
Christoph Hellwig2ef41632005-05-05 16:15:59 -07001286 fsync_bdev(bdev);
1287 res = __invalidate_device(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 bdput(bdev);
1289 }
1290 return res;
1291}
1292
1293EXPORT_SYMBOL(invalidate_partition);