genhd.c 24 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7
/*
 *  gendisk handling
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/genhd.h>
8
#include <linux/kdev_t.h>
Linus Torvalds's avatar
Linus Torvalds committed
9 10 11 12 13 14 15 16
#include <linux/kernel.h>
#include <linux/blkdev.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/kmod.h>
#include <linux/kobj_map.h>
17
#include <linux/buffer_head.h>
18
#include <linux/mutex.h>
19
#include <linux/idr.h>
Linus Torvalds's avatar
Linus Torvalds committed
20

21 22
#include "blk.h"

23 24 25 26
static DEFINE_MUTEX(block_class_lock);
#ifndef CONFIG_SYSFS_DEPRECATED
struct kobject *block_depr;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
27

28 29 30 31 32 33 34 35 36
/* for extended dynamic devt allocation, currently only one major is used */
#define MAX_EXT_DEVT		(1 << MINORBITS)

/* For extended devt allocation.  ext_devt_mutex prevents look up
 * results from going away underneath its user.
 */
static DEFINE_MUTEX(ext_devt_mutex);
static DEFINE_IDR(ext_devt_idr);

Adrian Bunk's avatar
Adrian Bunk committed
37 38
static struct device_type disk_type;

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
/**
 * disk_get_part - get partition
 * @disk: disk to look partition from
 * @partno: partition number
 *
 * Look for partition @partno from @disk.  If found, increment
 * reference count and return it.
 *
 * CONTEXT:
 * Don't care.
 *
 * RETURNS:
 * Pointer to the found partition on success, NULL if not found.
 */
struct hd_struct *disk_get_part(struct gendisk *disk, int partno)
{
	struct hd_struct *part;

Tejun Heo's avatar
Tejun Heo committed
57
	if (unlikely(partno < 0 || partno >= disk_max_parts(disk)))
58 59
		return NULL;
	rcu_read_lock();
Tejun Heo's avatar
Tejun Heo committed
60
	part = rcu_dereference(disk->__part[partno]);
61
	if (part)
62
		get_device(part_to_dev(part));
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
	rcu_read_unlock();

	return part;
}
EXPORT_SYMBOL_GPL(disk_get_part);

/**
 * disk_part_iter_init - initialize partition iterator
 * @piter: iterator to initialize
 * @disk: disk to iterate over
 * @flags: DISK_PITER_* flags
 *
 * Initialize @piter so that it iterates over partitions of @disk.
 *
 * CONTEXT:
 * Don't care.
 */
void disk_part_iter_init(struct disk_part_iter *piter, struct gendisk *disk,
			  unsigned int flags)
{
	piter->disk = disk;
	piter->part = NULL;

	if (flags & DISK_PITER_REVERSE)
		piter->idx = disk_max_parts(piter->disk) - 1;
Tejun Heo's avatar
Tejun Heo committed
88
	else if (flags & DISK_PITER_INCL_PART0)
89
		piter->idx = 0;
Tejun Heo's avatar
Tejun Heo committed
90 91
	else
		piter->idx = 1;
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118

	piter->flags = flags;
}
EXPORT_SYMBOL_GPL(disk_part_iter_init);

/**
 * disk_part_iter_next - proceed iterator to the next partition and return it
 * @piter: iterator of interest
 *
 * Proceed @piter to the next partition and return it.
 *
 * CONTEXT:
 * Don't care.
 */
struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter)
{
	int inc, end;

	/* put the last partition */
	disk_put_part(piter->part);
	piter->part = NULL;

	rcu_read_lock();

	/* determine iteration parameters */
	if (piter->flags & DISK_PITER_REVERSE) {
		inc = -1;
Tejun Heo's avatar
Tejun Heo committed
119 120 121 122
		if (piter->flags & DISK_PITER_INCL_PART0)
			end = -1;
		else
			end = 0;
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
	} else {
		inc = 1;
		end = disk_max_parts(piter->disk);
	}

	/* iterate to the next partition */
	for (; piter->idx != end; piter->idx += inc) {
		struct hd_struct *part;

		part = rcu_dereference(piter->disk->__part[piter->idx]);
		if (!part)
			continue;
		if (!(piter->flags & DISK_PITER_INCL_EMPTY) && !part->nr_sects)
			continue;

138
		get_device(part_to_dev(part));
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
		piter->part = part;
		piter->idx += inc;
		break;
	}

	rcu_read_unlock();

	return piter->part;
}
EXPORT_SYMBOL_GPL(disk_part_iter_next);

/**
 * disk_part_iter_exit - finish up partition iteration
 * @piter: iter of interest
 *
 * Called when iteration is over.  Cleans up @piter.
 *
 * CONTEXT:
 * Don't care.
 */
void disk_part_iter_exit(struct disk_part_iter *piter)
{
	disk_put_part(piter->part);
	piter->part = NULL;
}
EXPORT_SYMBOL_GPL(disk_part_iter_exit);

/**
 * disk_map_sector_rcu - map sector to partition
 * @disk: gendisk of interest
 * @sector: sector to map
 *
 * Find out which partition @sector maps to on @disk.  This is
 * primarily used for stats accounting.
 *
 * CONTEXT:
 * RCU read locked.  The returned partition pointer is valid only
 * while preemption is disabled.
 *
 * RETURNS:
179
 * Found partition on success, part0 is returned if no partition matches
180 181 182 183 184
 */
struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector)
{
	int i;

Tejun Heo's avatar
Tejun Heo committed
185
	for (i = 1; i < disk_max_parts(disk); i++) {
186 187 188 189 190 191
		struct hd_struct *part = rcu_dereference(disk->__part[i]);

		if (part && part->start_sect <= sector &&
		    sector < part->start_sect + part->nr_sects)
			return part;
	}
192
	return &disk->part0;
193 194 195
}
EXPORT_SYMBOL_GPL(disk_map_sector_rcu);

Linus Torvalds's avatar
Linus Torvalds committed
196 197 198 199 200 201 202 203
/*
 * Can be deleted altogether. Later.
 *
 */
static struct blk_major_name {
	struct blk_major_name *next;
	int major;
	char name[16];
204
} *major_names[BLKDEV_MAJOR_HASH_SIZE];
Linus Torvalds's avatar
Linus Torvalds committed
205 206 207 208

/* index in the above - for now: assume no multimajor ranges */
static inline int major_to_index(int major)
{
209
	return major % BLKDEV_MAJOR_HASH_SIZE;
210 211
}

212
#ifdef CONFIG_PROC_FS
213
void blkdev_show(struct seq_file *seqf, off_t offset)
214
{
215
	struct blk_major_name *dp;
216

217
	if (offset < BLKDEV_MAJOR_HASH_SIZE) {
218
		mutex_lock(&block_class_lock);
219
		for (dp = major_names[offset]; dp; dp = dp->next)
220
			seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
221
		mutex_unlock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
222 223
	}
}
224
#endif /* CONFIG_PROC_FS */
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228 229 230

int register_blkdev(unsigned int major, const char *name)
{
	struct blk_major_name **n, *p;
	int index, ret = 0;

231
	mutex_lock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275

	/* temporary */
	if (major == 0) {
		for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
			if (major_names[index] == NULL)
				break;
		}

		if (index == 0) {
			printk("register_blkdev: failed to get major for %s\n",
			       name);
			ret = -EBUSY;
			goto out;
		}
		major = index;
		ret = major;
	}

	p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
	if (p == NULL) {
		ret = -ENOMEM;
		goto out;
	}

	p->major = major;
	strlcpy(p->name, name, sizeof(p->name));
	p->next = NULL;
	index = major_to_index(major);

	for (n = &major_names[index]; *n; n = &(*n)->next) {
		if ((*n)->major == major)
			break;
	}
	if (!*n)
		*n = p;
	else
		ret = -EBUSY;

	if (ret < 0) {
		printk("register_blkdev: cannot get major %d for %s\n",
		       major, name);
		kfree(p);
	}
out:
276
	mutex_unlock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
277 278 279 280 281
	return ret;
}

EXPORT_SYMBOL(register_blkdev);

282
void unregister_blkdev(unsigned int major, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
283 284 285 286 287
{
	struct blk_major_name **n;
	struct blk_major_name *p = NULL;
	int index = major_to_index(major);

288
	mutex_lock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
289 290 291
	for (n = &major_names[index]; *n; n = &(*n)->next)
		if ((*n)->major == major)
			break;
292 293 294
	if (!*n || strcmp((*n)->name, name)) {
		WARN_ON(1);
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
295 296 297
		p = *n;
		*n = p->next;
	}
298
	mutex_unlock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
299 300 301 302 303 304 305
	kfree(p);
}

EXPORT_SYMBOL(unregister_blkdev);

static struct kobj_map *bdev_map;

306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
/**
 * blk_mangle_minor - scatter minor numbers apart
 * @minor: minor number to mangle
 *
 * Scatter consecutively allocated @minor number apart if MANGLE_DEVT
 * is enabled.  Mangling twice gives the original value.
 *
 * RETURNS:
 * Mangled value.
 *
 * CONTEXT:
 * Don't care.
 */
static int blk_mangle_minor(int minor)
{
#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
	int i;

	for (i = 0; i < MINORBITS / 2; i++) {
		int low = minor & (1 << i);
		int high = minor & (1 << (MINORBITS - 1 - i));
		int distance = MINORBITS - 1 - 2 * i;

		minor ^= low | high;	/* clear both bits */
		low <<= distance;	/* swap the positions */
		high >>= distance;
		minor |= low | high;	/* and set */
	}
#endif
	return minor;
}

338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
/**
 * blk_alloc_devt - allocate a dev_t for a partition
 * @part: partition to allocate dev_t for
 * @gfp_mask: memory allocation flag
 * @devt: out parameter for resulting dev_t
 *
 * Allocate a dev_t for block device.
 *
 * RETURNS:
 * 0 on success, allocated dev_t is returned in *@devt.  -errno on
 * failure.
 *
 * CONTEXT:
 * Might sleep.
 */
int blk_alloc_devt(struct hd_struct *part, dev_t *devt)
{
	struct gendisk *disk = part_to_disk(part);
	int idx, rc;

	/* in consecutive minor range? */
	if (part->partno < disk->minors) {
		*devt = MKDEV(disk->major, disk->first_minor + part->partno);
		return 0;
	}

	/* allocate ext devt */
	do {
		if (!idr_pre_get(&ext_devt_idr, GFP_KERNEL))
			return -ENOMEM;
		rc = idr_get_new(&ext_devt_idr, part, &idx);
	} while (rc == -EAGAIN);

	if (rc)
		return rc;

	if (idx > MAX_EXT_DEVT) {
		idr_remove(&ext_devt_idr, idx);
		return -EBUSY;
	}

379
	*devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
	return 0;
}

/**
 * blk_free_devt - free a dev_t
 * @devt: dev_t to free
 *
 * Free @devt which was allocated using blk_alloc_devt().
 *
 * CONTEXT:
 * Might sleep.
 */
void blk_free_devt(dev_t devt)
{
	might_sleep();

	if (devt == MKDEV(0, 0))
		return;

	if (MAJOR(devt) == BLOCK_EXT_MAJOR) {
		mutex_lock(&ext_devt_mutex);
401
		idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
402 403 404 405
		mutex_unlock(&ext_devt_mutex);
	}
}

406 407 408 409 410 411 412 413 414 415 416 417
static char *bdevt_str(dev_t devt, char *buf)
{
	if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) {
		char tbuf[BDEVT_SIZE];
		snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt));
		snprintf(buf, BDEVT_SIZE, "%-9s", tbuf);
	} else
		snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt));

	return buf;
}

Linus Torvalds's avatar
Linus Torvalds committed
418 419 420 421 422
/*
 * Register device numbers dev..(dev+range-1)
 * range must be nonzero
 * The hash chain is sorted on range, so that subranges can override.
 */
423
void blk_register_region(dev_t devt, unsigned long range, struct module *module,
Linus Torvalds's avatar
Linus Torvalds committed
424 425 426
			 struct kobject *(*probe)(dev_t, int *, void *),
			 int (*lock)(dev_t, void *), void *data)
{
427
	kobj_map(bdev_map, devt, range, module, probe, lock, data);
Linus Torvalds's avatar
Linus Torvalds committed
428 429 430 431
}

EXPORT_SYMBOL(blk_register_region);

432
void blk_unregister_region(dev_t devt, unsigned long range)
Linus Torvalds's avatar
Linus Torvalds committed
433
{
434
	kobj_unmap(bdev_map, devt, range);
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437 438
}

EXPORT_SYMBOL(blk_unregister_region);

439
static struct kobject *exact_match(dev_t devt, int *partno, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
440 441
{
	struct gendisk *p = data;
442

443
	return &disk_to_dev(p)->kobj;
Linus Torvalds's avatar
Linus Torvalds committed
444 445
}

446
static int exact_lock(dev_t devt, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
{
	struct gendisk *p = data;

	if (!get_disk(p))
		return -1;
	return 0;
}

/**
 * add_disk - add partitioning information to kernel list
 * @disk: per-device partitioning information
 *
 * This function registers the partitioning information in @disk
 * with the kernel.
 */
void add_disk(struct gendisk *disk)
{
464
	struct backing_dev_info *bdi;
465
	int retval;
466

Linus Torvalds's avatar
Linus Torvalds committed
467
	disk->flags |= GENHD_FL_UP;
468
	disk_to_dev(disk)->devt = MKDEV(disk->major, disk->first_minor);
469 470
	blk_register_region(disk_devt(disk), disk->minors, NULL,
			    exact_match, exact_lock, disk);
Linus Torvalds's avatar
Linus Torvalds committed
471 472
	register_disk(disk);
	blk_register_queue(disk);
473 474

	bdi = &disk->queue->backing_dev_info;
475
	bdi_register_dev(bdi, disk_devt(disk));
476 477
	retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
				   "bdi");
478
	WARN_ON(retval);
Linus Torvalds's avatar
Linus Torvalds committed
479 480 481 482 483 484 485
}

EXPORT_SYMBOL(add_disk);
EXPORT_SYMBOL(del_gendisk);	/* in partitions/check.c */

void unlink_gendisk(struct gendisk *disk)
{
486
	sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
487
	bdi_unregister(&disk->queue->backing_dev_info);
Linus Torvalds's avatar
Linus Torvalds committed
488
	blk_unregister_queue(disk);
489
	blk_unregister_region(disk_devt(disk), disk->minors);
Linus Torvalds's avatar
Linus Torvalds committed
490 491 492 493
}

/**
 * get_gendisk - get partitioning information for a given device
494 495
 * @devt: device to get partitioning information for
 * @part: returned partition index
Linus Torvalds's avatar
Linus Torvalds committed
496 497
 *
 * This function gets the structure containing partitioning
498
 * information for the given device @devt.
Linus Torvalds's avatar
Linus Torvalds committed
499
 */
500
struct gendisk *get_gendisk(dev_t devt, int *partno)
Linus Torvalds's avatar
Linus Torvalds committed
501
{
502 503 504 505 506 507 508 509 510 511 512 513
	struct gendisk *disk = NULL;

	if (MAJOR(devt) != BLOCK_EXT_MAJOR) {
		struct kobject *kobj;

		kobj = kobj_lookup(bdev_map, devt, partno);
		if (kobj)
			disk = dev_to_disk(kobj_to_dev(kobj));
	} else {
		struct hd_struct *part;

		mutex_lock(&ext_devt_mutex);
514
		part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
515 516 517 518 519 520
		if (part && get_disk(part_to_disk(part))) {
			*partno = part->partno;
			disk = part_to_disk(part);
		}
		mutex_unlock(&ext_devt_mutex);
	}
521

522
	return disk;
Linus Torvalds's avatar
Linus Torvalds committed
523 524
}

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
/**
 * bdget_disk - do bdget() by gendisk and partition number
 * @disk: gendisk of interest
 * @partno: partition number
 *
 * Find partition @partno from @disk, do bdget() on it.
 *
 * CONTEXT:
 * Don't care.
 *
 * RETURNS:
 * Resulting block_device on success, NULL on failure.
 */
extern struct block_device *bdget_disk(struct gendisk *disk, int partno)
{
540 541
	struct hd_struct *part;
	struct block_device *bdev = NULL;
542

543 544 545 546
	part = disk_get_part(disk, partno);
	if (part && (part->nr_sects || partno == 0))
		bdev = bdget(part_devt(part));
	disk_put_part(part);
547

548
	return bdev;
549 550 551
}
EXPORT_SYMBOL(bdget_disk);

552 553 554 555 556 557 558
/*
 * print a full list of all partitions - intended for places where the root
 * filesystem can't be mounted and thus to give the victim some idea of what
 * went wrong
 */
void __init printk_all_partitions(void)
{
559 560 561 562 563 564
	struct class_dev_iter iter;
	struct device *dev;

	class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
	while ((dev = class_dev_iter_next(&iter))) {
		struct gendisk *disk = dev_to_disk(dev);
565 566
		struct disk_part_iter piter;
		struct hd_struct *part;
567 568
		char name_buf[BDEVNAME_SIZE];
		char devt_buf[BDEVT_SIZE];
569 570 571 572 573 574 575 576 577 578 579 580 581 582

		/*
		 * Don't show empty devices or things that have been
		 * surpressed
		 */
		if (get_capacity(disk) == 0 ||
		    (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
			continue;

		/*
		 * Note, unlike /proc/partitions, I am showing the
		 * numbers in hex - the same format as the root=
		 * option takes.
		 */
583 584 585
		disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
		while ((part = disk_part_iter_next(&piter))) {
			bool is_part0 = part == &disk->part0;
586

587
			printk("%s%s %10llu %s", is_part0 ? "" : "  ",
588
			       bdevt_str(part_devt(part), devt_buf),
589
			       (unsigned long long)part->nr_sects >> 1,
590
			       disk_name(disk, part->partno, name_buf));
591 592 593 594 595 596 597 598 599 600
			if (is_part0) {
				if (disk->driverfs_dev != NULL &&
				    disk->driverfs_dev->driver != NULL)
					printk(" driver: %s\n",
					      disk->driverfs_dev->driver->name);
				else
					printk(" (driver?)\n");
			} else
				printk("\n");
		}
601
		disk_part_iter_exit(&piter);
602 603
	}
	class_dev_iter_exit(&iter);
604 605
}

Linus Torvalds's avatar
Linus Torvalds committed
606 607
#ifdef CONFIG_PROC_FS
/* iterator */
608
static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
609
{
610 611 612
	loff_t skip = *pos;
	struct class_dev_iter *iter;
	struct device *dev;
613

614 615 616 617 618 619 620 621 622 623 624 625 626
	iter = kmalloc(GFP_KERNEL, sizeof(*iter));
	if (!iter)
		return ERR_PTR(-ENOMEM);

	seqf->private = iter;
	class_dev_iter_init(iter, &block_class, NULL, &disk_type);
	do {
		dev = class_dev_iter_next(iter);
		if (!dev)
			return NULL;
	} while (skip--);

	return dev_to_disk(dev);
627 628
}

629
static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
Linus Torvalds's avatar
Linus Torvalds committed
630
{
631
	struct device *dev;
Linus Torvalds's avatar
Linus Torvalds committed
632

633 634
	(*pos)++;
	dev = class_dev_iter_next(seqf->private);
635
	if (dev)
636
		return dev_to_disk(dev);
637

Linus Torvalds's avatar
Linus Torvalds committed
638 639 640
	return NULL;
}

641
static void disk_seqf_stop(struct seq_file *seqf, void *v)
642
{
643
	struct class_dev_iter *iter = seqf->private;
644

645 646 647 648
	/* stop is called even after start failed :-( */
	if (iter) {
		class_dev_iter_exit(iter);
		kfree(iter);
649
	}
Linus Torvalds's avatar
Linus Torvalds committed
650 651
}

652
static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
Linus Torvalds's avatar
Linus Torvalds committed
653
{
654 655 656 657 658 659
	static void *p;

	p = disk_seqf_start(seqf, pos);
	if (!IS_ERR(p) && p)
		seq_puts(seqf, "major minor  #blocks  name\n\n");
	return p;
Linus Torvalds's avatar
Linus Torvalds committed
660 661
}

662
static int show_partition(struct seq_file *seqf, void *v)
Linus Torvalds's avatar
Linus Torvalds committed
663 664
{
	struct gendisk *sgp = v;
665 666
	struct disk_part_iter piter;
	struct hd_struct *part;
Linus Torvalds's avatar
Linus Torvalds committed
667 668 669
	char buf[BDEVNAME_SIZE];

	/* Don't show non-partitionable removeable devices or empty devices */
Tejun Heo's avatar
Tejun Heo committed
670
	if (!get_capacity(sgp) || (!disk_partitionable(sgp) &&
671
				   (sgp->flags & GENHD_FL_REMOVABLE)))
Linus Torvalds's avatar
Linus Torvalds committed
672 673 674 675 676
		return 0;
	if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
		return 0;

	/* show the full disk and all non-0 size partitions of it */
677
	disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0);
678
	while ((part = disk_part_iter_next(&piter)))
679
		seq_printf(seqf, "%4d  %7d %10llu %s\n",
680 681 682
			   MAJOR(part_devt(part)), MINOR(part_devt(part)),
			   (unsigned long long)part->nr_sects >> 1,
			   disk_name(sgp, part->partno, buf));
683
	disk_part_iter_exit(&piter);
Linus Torvalds's avatar
Linus Torvalds committed
684 685 686 687

	return 0;
}

688
const struct seq_operations partitions_op = {
689 690 691
	.start	= show_partition_start,
	.next	= disk_seqf_next,
	.stop	= disk_seqf_stop,
692
	.show	= show_partition
Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696
};
#endif


697
static struct kobject *base_probe(dev_t devt, int *partno, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
698
{
699
	if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
Linus Torvalds's avatar
Linus Torvalds committed
700
		/* Make old-style 2.4 aliases work */
701
		request_module("block-major-%d", MAJOR(devt));
Linus Torvalds's avatar
Linus Torvalds committed
702 703 704 705 706
	return NULL;
}

static int __init genhd_device_init(void)
{
707 708 709 710
	int error;

	block_class.dev_kobj = sysfs_dev_block_kobj;
	error = class_register(&block_class);
Roland McGrath's avatar
Roland McGrath committed
711 712
	if (unlikely(error))
		return error;
713
	bdev_map = kobj_map_init(base_probe, &block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
714
	blk_dev_init();
715 716 717 718 719

#ifndef CONFIG_SYSFS_DEPRECATED
	/* create top-level block dir */
	block_depr = kobject_create_and_add("block", NULL);
#endif
720
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
721 722 723 724
}

subsys_initcall(genhd_device_init);

725 726
static ssize_t disk_range_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
727
{
728
	struct gendisk *disk = dev_to_disk(dev);
Linus Torvalds's avatar
Linus Torvalds committed
729

730
	return sprintf(buf, "%d\n", disk->minors);
Linus Torvalds's avatar
Linus Torvalds committed
731 732
}

733 734 735 736 737
static ssize_t disk_ext_range_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct gendisk *disk = dev_to_disk(dev);

Tejun Heo's avatar
Tejun Heo committed
738
	return sprintf(buf, "%d\n", disk_max_parts(disk));
739 740
}

741 742
static ssize_t disk_removable_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
743
{
744
	struct gendisk *disk = dev_to_disk(dev);
745

746 747
	return sprintf(buf, "%d\n",
		       (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
748 749
}

Kay Sievers's avatar
Kay Sievers committed
750 751 752 753 754
static ssize_t disk_ro_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct gendisk *disk = dev_to_disk(dev);

755
	return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
Kay Sievers's avatar
Kay Sievers committed
756 757
}

758 759
static ssize_t disk_capability_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
760
{
761 762 763
	struct gendisk *disk = dev_to_disk(dev);

	return sprintf(buf, "%x\n", disk->flags);
764
}
765 766

static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
767
static DEVICE_ATTR(ext_range, S_IRUGO, disk_ext_range_show, NULL);
768
static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
Kay Sievers's avatar
Kay Sievers committed
769
static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
770
static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
771
static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
772
static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
773
#ifdef CONFIG_FAIL_MAKE_REQUEST
774
static struct device_attribute dev_attr_fail =
775
	__ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store);
776
#endif
777 778 779

static struct attribute *disk_attrs[] = {
	&dev_attr_range.attr,
780
	&dev_attr_ext_range.attr,
781
	&dev_attr_removable.attr,
Kay Sievers's avatar
Kay Sievers committed
782
	&dev_attr_ro.attr,
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
	&dev_attr_size.attr,
	&dev_attr_capability.attr,
	&dev_attr_stat.attr,
#ifdef CONFIG_FAIL_MAKE_REQUEST
	&dev_attr_fail.attr,
#endif
	NULL
};

static struct attribute_group disk_attr_group = {
	.attrs = disk_attrs,
};

static struct attribute_group *disk_attr_groups[] = {
	&disk_attr_group,
	NULL
Linus Torvalds's avatar
Linus Torvalds committed
799 800
};

801
static void disk_release(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
802
{
803 804
	struct gendisk *disk = dev_to_disk(dev);

Linus Torvalds's avatar
Linus Torvalds committed
805
	kfree(disk->random);
806
	kfree(disk->__part);
807
	free_part_stats(&disk->part0);
Linus Torvalds's avatar
Linus Torvalds committed
808 809
	kfree(disk);
}
810 811
struct class block_class = {
	.name		= "block",
Linus Torvalds's avatar
Linus Torvalds committed
812 813
};

Adrian Bunk's avatar
Adrian Bunk committed
814
static struct device_type disk_type = {
815 816 817
	.name		= "disk",
	.groups		= disk_attr_groups,
	.release	= disk_release,
Linus Torvalds's avatar
Linus Torvalds committed
818 819
};

820
#ifdef CONFIG_PROC_FS
821 822 823 824 825 826 827 828
/*
 * aggregate disk stat collector.  Uses the same stats that the sysfs
 * entries do, above, but makes them available through one seq_file.
 *
 * The output looks suspiciously like /proc/partitions with a bunch of
 * extra fields.
 */
static int diskstats_show(struct seq_file *seqf, void *v)
Linus Torvalds's avatar
Linus Torvalds committed
829 830
{
	struct gendisk *gp = v;
831 832
	struct disk_part_iter piter;
	struct hd_struct *hd;
Linus Torvalds's avatar
Linus Torvalds committed
833
	char buf[BDEVNAME_SIZE];
Tejun Heo's avatar
Tejun Heo committed
834
	int cpu;
Linus Torvalds's avatar
Linus Torvalds committed
835 836

	/*
837
	if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
838
		seq_puts(seqf,	"major minor name"
Linus Torvalds's avatar
Linus Torvalds committed
839 840 841 842 843
				"     rio rmerge rsect ruse wio wmerge "
				"wsect wuse running use aveq"
				"\n\n");
	*/
 
844
	disk_part_iter_init(&piter, gp, DISK_PITER_INCL_PART0);
845
	while ((hd = disk_part_iter_next(&piter))) {
846
		cpu = part_stat_lock();
Tejun Heo's avatar
Tejun Heo committed
847
		part_round_stats(cpu, hd);
848
		part_stat_unlock();
849
		seq_printf(seqf, "%4d %7d %s %lu %lu %llu "
850
			   "%u %lu %lu %llu %u %u %u %u\n",
851 852
			   MAJOR(part_devt(hd)), MINOR(part_devt(hd)),
			   disk_name(gp, hd->partno, buf),
853 854 855 856 857 858 859 860 861 862 863 864
			   part_stat_read(hd, ios[0]),
			   part_stat_read(hd, merges[0]),
			   (unsigned long long)part_stat_read(hd, sectors[0]),
			   jiffies_to_msecs(part_stat_read(hd, ticks[0])),
			   part_stat_read(hd, ios[1]),
			   part_stat_read(hd, merges[1]),
			   (unsigned long long)part_stat_read(hd, sectors[1]),
			   jiffies_to_msecs(part_stat_read(hd, ticks[1])),
			   hd->in_flight,
			   jiffies_to_msecs(part_stat_read(hd, io_ticks)),
			   jiffies_to_msecs(part_stat_read(hd, time_in_queue))
			);
Linus Torvalds's avatar
Linus Torvalds committed
865
	}
866
	disk_part_iter_exit(&piter);
Linus Torvalds's avatar
Linus Torvalds committed
867 868 869 870
 
	return 0;
}

871
const struct seq_operations diskstats_op = {
872 873 874
	.start	= disk_seqf_start,
	.next	= disk_seqf_next,
	.stop	= disk_seqf_stop,
Linus Torvalds's avatar
Linus Torvalds committed
875 876
	.show	= diskstats_show
};
877
#endif /* CONFIG_PROC_FS */
Linus Torvalds's avatar
Linus Torvalds committed
878

879 880 881 882 883 884 885 886 887 888
static void media_change_notify_thread(struct work_struct *work)
{
	struct gendisk *gd = container_of(work, struct gendisk, async_notify);
	char event[] = "MEDIA_CHANGE=1";
	char *envp[] = { event, NULL };

	/*
	 * set enviroment vars to indicate which event this is for
	 * so that user space will know to go check the media status.
	 */
889
	kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
890 891 892
	put_device(gd->driverfs_dev);
}

Adrian Bunk's avatar
Adrian Bunk committed
893
#if 0
894 895 896 897 898 899
void genhd_media_change_notify(struct gendisk *disk)
{
	get_device(disk->driverfs_dev);
	schedule_work(&disk->async_notify);
}
EXPORT_SYMBOL_GPL(genhd_media_change_notify);
Adrian Bunk's avatar
Adrian Bunk committed
900
#endif  /*  0  */
901

902
dev_t blk_lookup_devt(const char *name, int partno)
903
{
904 905 906
	dev_t devt = MKDEV(0, 0);
	struct class_dev_iter iter;
	struct device *dev;
907

908 909
	class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
	while ((dev = class_dev_iter_next(&iter))) {
910
		struct gendisk *disk = dev_to_disk(dev);
911
		struct hd_struct *part;
912

913 914 915
		if (strcmp(dev->bus_id, name))
			continue;

916 917
		part = disk_get_part(disk, partno);
		if (part && (part->nr_sects || partno == 0)) {
918
			devt = part_devt(part);
919
			disk_put_part(part);
920
			break;
921
		}
922
		disk_put_part(part);
923
	}
924
	class_dev_iter_exit(&iter);
925 926 927 928
	return devt;
}
EXPORT_SYMBOL(blk_lookup_devt);

Linus Torvalds's avatar
Linus Torvalds committed
929 930
struct gendisk *alloc_disk(int minors)
{
931 932 933 934
	return alloc_disk_node(minors, -1);
}

struct gendisk *alloc_disk_node(int minors, int node_id)
935 936 937 938 939 940 941 942 943 944
{
	return alloc_disk_ext_node(minors, 0, node_id);
}

struct gendisk *alloc_disk_ext(int minors, int ext_minors)
{
	return alloc_disk_ext_node(minors, ext_minors, -1);
}

struct gendisk *alloc_disk_ext_node(int minors, int ext_minors, int node_id)
945 946 947
{
	struct gendisk *disk;

948 949
	disk = kmalloc_node(sizeof(struct gendisk),
				GFP_KERNEL | __GFP_ZERO, node_id);
Linus Torvalds's avatar
Linus Torvalds committed
950
	if (disk) {
951
		int tot_minors = minors + ext_minors;
Tejun Heo's avatar
Tejun Heo committed
952
		int size = tot_minors * sizeof(struct hd_struct *);
953

954
		if (!init_part_stats(&disk->part0)) {
Linus Torvalds's avatar
Linus Torvalds committed
955 956 957
			kfree(disk);
			return NULL;
		}
Tejun Heo's avatar
Tejun Heo committed
958 959 960 961

		disk->__part = kmalloc_node(size, GFP_KERNEL | __GFP_ZERO,
					    node_id);
		if (!disk->__part) {
962
				free_part_stats(&disk->part0);
Tejun Heo's avatar
Tejun Heo committed
963 964
			kfree(disk);
			return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
965
		}
Tejun Heo's avatar
Tejun Heo committed
966 967
		disk->__part[0] = &disk->part0;

Linus Torvalds's avatar
Linus Torvalds committed
968
		disk->minors = minors;
969
		disk->ext_minors = ext_minors;
Linus Torvalds's avatar
Linus Torvalds committed
970
		rand_initialize_disk(disk);
971 972 973
		disk_to_dev(disk)->class = &block_class;
		disk_to_dev(disk)->type = &disk_type;
		device_initialize(disk_to_dev(disk));
974 975
		INIT_WORK(&disk->async_notify,
			media_change_notify_thread);
Linus Torvalds's avatar
Linus Torvalds committed
976 977 978 979 980
	}
	return disk;
}

EXPORT_SYMBOL(alloc_disk);
981
EXPORT_SYMBOL(alloc_disk_node);
982 983
EXPORT_SYMBOL(alloc_disk_ext);
EXPORT_SYMBOL(alloc_disk_ext_node);
Linus Torvalds's avatar
Linus Torvalds committed
984 985 986 987 988 989 990 991 992 993 994

struct kobject *get_disk(struct gendisk *disk)
{
	struct module *owner;
	struct kobject *kobj;

	if (!disk->fops)
		return NULL;
	owner = disk->fops->owner;
	if (owner && !try_module_get(owner))
		return NULL;
995
	kobj = kobject_get(&disk_to_dev(disk)->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
	if (kobj == NULL) {
		module_put(owner);
		return NULL;
	}
	return kobj;

}

EXPORT_SYMBOL(get_disk);

void put_disk(struct gendisk *disk)
{
	if (disk)
1009
		kobject_put(&disk_to_dev(disk)->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
1010 1011 1012 1013 1014 1015
}

EXPORT_SYMBOL(put_disk);

void set_device_ro(struct block_device *bdev, int flag)
{
1016
	bdev->bd_part->policy = flag;
Linus Torvalds's avatar
Linus Torvalds committed
1017 1018 1019 1020 1021 1022
}

EXPORT_SYMBOL(set_device_ro);

void set_disk_ro(struct gendisk *disk, int flag)
{
1023 1024 1025
	struct disk_part_iter piter;
	struct hd_struct *part;

1026 1027
	disk_part_iter_init(&piter, disk,
			    DISK_PITER_INCL_EMPTY | DISK_PITER_INCL_PART0);
1028 1029 1030
	while ((part = disk_part_iter_next(&piter)))
		part->policy = flag;
	disk_part_iter_exit(&piter);
Linus Torvalds's avatar
Linus Torvalds committed
1031 1032 1033 1034 1035 1036 1037 1038
}

EXPORT_SYMBOL(set_disk_ro);

int bdev_read_only(struct block_device *bdev)
{
	if (!bdev)
		return 0;
1039
	return bdev->bd_part->policy;
Linus Torvalds's avatar
Linus Torvalds committed
1040 1041 1042 1043
}

EXPORT_SYMBOL(bdev_read_only);

1044
int invalidate_partition(struct gendisk *disk, int partno)
Linus Torvalds's avatar
Linus Torvalds committed
1045 1046
{
	int res = 0;
1047
	struct block_device *bdev = bdget_disk(disk, partno);
Linus Torvalds's avatar
Linus Torvalds committed
1048
	if (bdev) {
1049 1050
		fsync_bdev(bdev);
		res = __invalidate_device(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
1051 1052 1053 1054 1055 1056
		bdput(bdev);
	}
	return res;
}

EXPORT_SYMBOL(invalidate_partition);