genhd.c 43 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
#include <linux/kernel.h>
#include <linux/blkdev.h>
#include <linux/init.h>
#include <linux/spinlock.h>
13
#include <linux/proc_fs.h>
Linus Torvalds's avatar
Linus Torvalds committed
14 15 16 17
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/kmod.h>
#include <linux/kobj_map.h>
18
#include <linux/mutex.h>
19
#include <linux/idr.h>
20
#include <linux/log2.h>
Linus Torvalds's avatar
Linus Torvalds committed
21

22 23
#include "blk.h"

24 25
static DEFINE_MUTEX(block_class_lock);
struct kobject *block_depr;
Linus Torvalds's avatar
Linus Torvalds committed
26

27 28 29 30 31 32 33 34 35
/* 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
36 37
static struct device_type disk_type;

38
static void disk_alloc_events(struct gendisk *disk);
39 40 41 42
static void disk_add_events(struct gendisk *disk);
static void disk_del_events(struct gendisk *disk);
static void disk_release_events(struct gendisk *disk);

43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
/**
 * 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)
{
59 60
	struct hd_struct *part = NULL;
	struct disk_part_tbl *ptbl;
61

62
	if (unlikely(partno < 0))
63
		return NULL;
64

65
	rcu_read_lock();
66 67 68 69 70 71 72 73

	ptbl = rcu_dereference(disk->part_tbl);
	if (likely(partno < ptbl->len)) {
		part = rcu_dereference(ptbl->part[partno]);
		if (part)
			get_device(part_to_dev(part));
	}

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
	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)
{
94 95 96 97 98
	struct disk_part_tbl *ptbl;

	rcu_read_lock();
	ptbl = rcu_dereference(disk->part_tbl);

99 100 101 102
	piter->disk = disk;
	piter->part = NULL;

	if (flags & DISK_PITER_REVERSE)
103
		piter->idx = ptbl->len - 1;
104
	else if (flags & (DISK_PITER_INCL_PART0 | DISK_PITER_INCL_EMPTY_PART0))
105
		piter->idx = 0;
Tejun Heo's avatar
Tejun Heo committed
106 107
	else
		piter->idx = 1;
108 109

	piter->flags = flags;
110 111

	rcu_read_unlock();
112 113 114 115 116 117 118 119 120 121 122 123 124 125
}
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)
{
126
	struct disk_part_tbl *ptbl;
127 128 129 130 131 132
	int inc, end;

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

133
	/* get part_tbl */
134
	rcu_read_lock();
135
	ptbl = rcu_dereference(piter->disk->part_tbl);
136 137 138 139

	/* determine iteration parameters */
	if (piter->flags & DISK_PITER_REVERSE) {
		inc = -1;
140 141
		if (piter->flags & (DISK_PITER_INCL_PART0 |
				    DISK_PITER_INCL_EMPTY_PART0))
Tejun Heo's avatar
Tejun Heo committed
142 143 144
			end = -1;
		else
			end = 0;
145 146
	} else {
		inc = 1;
147
		end = ptbl->len;
148 149 150 151 152 153
	}

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

154
		part = rcu_dereference(ptbl->part[piter->idx]);
155 156
		if (!part)
			continue;
157 158 159 160
		if (!part->nr_sects &&
		    !(piter->flags & DISK_PITER_INCL_EMPTY) &&
		    !(piter->flags & DISK_PITER_INCL_EMPTY_PART0 &&
		      piter->idx == 0))
161 162
			continue;

163
		get_device(part_to_dev(part));
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
		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);

191 192 193 194 195 196
static inline int sector_in_part(struct hd_struct *part, sector_t sector)
{
	return part->start_sect <= sector &&
		sector < part->start_sect + part->nr_sects;
}

197 198 199 200 201 202 203 204 205 206 207 208 209
/**
 * 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:
210
 * Found partition on success, part0 is returned if no partition matches
211 212 213
 */
struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector)
{
214
	struct disk_part_tbl *ptbl;
215
	struct hd_struct *part;
216 217
	int i;

218 219
	ptbl = rcu_dereference(disk->part_tbl);

220 221 222 223
	part = rcu_dereference(ptbl->last_lookup);
	if (part && sector_in_part(part, sector))
		return part;

224
	for (i = 1; i < ptbl->len; i++) {
225
		part = rcu_dereference(ptbl->part[i]);
226

227 228
		if (part && sector_in_part(part, sector)) {
			rcu_assign_pointer(ptbl->last_lookup, part);
229
			return part;
230
		}
231
	}
232
	return &disk->part0;
233 234 235
}
EXPORT_SYMBOL_GPL(disk_map_sector_rcu);

Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239 240 241 242 243
/*
 * Can be deleted altogether. Later.
 *
 */
static struct blk_major_name {
	struct blk_major_name *next;
	int major;
	char name[16];
244
} *major_names[BLKDEV_MAJOR_HASH_SIZE];
Linus Torvalds's avatar
Linus Torvalds committed
245 246

/* index in the above - for now: assume no multimajor ranges */
247
static inline int major_to_index(unsigned major)
Linus Torvalds's avatar
Linus Torvalds committed
248
{
249
	return major % BLKDEV_MAJOR_HASH_SIZE;
250 251
}

252
#ifdef CONFIG_PROC_FS
253
void blkdev_show(struct seq_file *seqf, off_t offset)
254
{
255
	struct blk_major_name *dp;
256

257
	if (offset < BLKDEV_MAJOR_HASH_SIZE) {
258
		mutex_lock(&block_class_lock);
259
		for (dp = major_names[offset]; dp; dp = dp->next)
260
			seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
261
		mutex_unlock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
262 263
	}
}
264
#endif /* CONFIG_PROC_FS */
Linus Torvalds's avatar
Linus Torvalds committed
265

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
/**
 * register_blkdev - register a new block device
 *
 * @major: the requested major device number [1..255]. If @major=0, try to
 *         allocate any unused major number.
 * @name: the name of the new block device as a zero terminated string
 *
 * The @name must be unique within the system.
 *
 * The return value depends on the @major input parameter.
 *  - if a major device number was requested in range [1..255] then the
 *    function returns zero on success, or a negative error code
 *  - if any unused major number was requested with @major=0 parameter
 *    then the return value is the allocated major number in range
 *    [1..255] or a negative error code otherwise
 */
Linus Torvalds's avatar
Linus Torvalds committed
282 283 284 285 286
int register_blkdev(unsigned int major, const char *name)
{
	struct blk_major_name **n, *p;
	int index, ret = 0;

287
	mutex_lock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 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

	/* 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:
332
	mutex_unlock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
333 334 335 336 337
	return ret;
}

EXPORT_SYMBOL(register_blkdev);

338
void unregister_blkdev(unsigned int major, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
339 340 341 342 343
{
	struct blk_major_name **n;
	struct blk_major_name *p = NULL;
	int index = major_to_index(major);

344
	mutex_lock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
345 346 347
	for (n = &major_names[index]; *n; n = &(*n)->next)
		if ((*n)->major == major)
			break;
348 349 350
	if (!*n || strcmp((*n)->name, name)) {
		WARN_ON(1);
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353
		p = *n;
		*n = p->next;
	}
354
	mutex_unlock(&block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
355 356 357 358 359 360 361
	kfree(p);
}

EXPORT_SYMBOL(unregister_blkdev);

static struct kobj_map *bdev_map;

362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
/**
 * 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;
}

394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
/**
 * blk_alloc_devt - allocate a dev_t for a partition
 * @part: partition to allocate dev_t for
 * @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;
	}

434
	*devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
	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);
456
		idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
457 458 459 460
		mutex_unlock(&ext_devt_mutex);
	}
}

461 462 463 464 465 466 467 468 469 470 471 472
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
473 474 475 476 477
/*
 * Register device numbers dev..(dev+range-1)
 * range must be nonzero
 * The hash chain is sorted on range, so that subranges can override.
 */
478
void blk_register_region(dev_t devt, unsigned long range, struct module *module,
Linus Torvalds's avatar
Linus Torvalds committed
479 480 481
			 struct kobject *(*probe)(dev_t, int *, void *),
			 int (*lock)(dev_t, void *), void *data)
{
482
	kobj_map(bdev_map, devt, range, module, probe, lock, data);
Linus Torvalds's avatar
Linus Torvalds committed
483 484 485 486
}

EXPORT_SYMBOL(blk_register_region);

487
void blk_unregister_region(dev_t devt, unsigned long range)
Linus Torvalds's avatar
Linus Torvalds committed
488
{
489
	kobj_unmap(bdev_map, devt, range);
Linus Torvalds's avatar
Linus Torvalds committed
490 491 492 493
}

EXPORT_SYMBOL(blk_unregister_region);

494
static struct kobject *exact_match(dev_t devt, int *partno, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
495 496
{
	struct gendisk *p = data;
497

498
	return &disk_to_dev(p)->kobj;
Linus Torvalds's avatar
Linus Torvalds committed
499 500
}

501
static int exact_lock(dev_t devt, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
502 503 504 505 506 507 508 509
{
	struct gendisk *p = data;

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

Al Viro's avatar
Al Viro committed
510
static void register_disk(struct gendisk *disk)
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
{
	struct device *ddev = disk_to_dev(disk);
	struct block_device *bdev;
	struct disk_part_iter piter;
	struct hd_struct *part;
	int err;

	ddev->parent = disk->driverfs_dev;

	dev_set_name(ddev, disk->disk_name);

	/* delay uevents, until we scanned partition table */
	dev_set_uevent_suppress(ddev, 1);

	if (device_add(ddev))
		return;
	if (!sysfs_deprecated) {
		err = sysfs_create_link(block_depr, &ddev->kobj,
					kobject_name(&ddev->kobj));
		if (err) {
			device_del(ddev);
			return;
		}
	}
	disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
	disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);

	/* No minors to use for partitions */
Tejun Heo's avatar
Tejun Heo committed
539
	if (!disk_part_scan_enabled(disk))
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
		goto exit;

	/* No such device (e.g., media were just removed) */
	if (!get_capacity(disk))
		goto exit;

	bdev = bdget_disk(disk, 0);
	if (!bdev)
		goto exit;

	bdev->bd_invalidated = 1;
	err = blkdev_get(bdev, FMODE_READ, NULL);
	if (err < 0)
		goto exit;
	blkdev_put(bdev, FMODE_READ);

exit:
	/* announce disk after possible partitions are created */
	dev_set_uevent_suppress(ddev, 0);
	kobject_uevent(&ddev->kobj, KOBJ_ADD);

	/* announce possible partitions */
	disk_part_iter_init(&piter, disk, 0);
	while ((part = disk_part_iter_next(&piter)))
		kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD);
	disk_part_iter_exit(&piter);
}

Linus Torvalds's avatar
Linus Torvalds committed
568 569 570 571 572 573
/**
 * add_disk - add partitioning information to kernel list
 * @disk: per-device partitioning information
 *
 * This function registers the partitioning information in @disk
 * with the kernel.
574 575
 *
 * FIXME: error handling
Linus Torvalds's avatar
Linus Torvalds committed
576 577 578
 */
void add_disk(struct gendisk *disk)
{
579
	struct backing_dev_info *bdi;
580
	dev_t devt;
581
	int retval;
582

583 584 585 586 587 588 589
	/* minors == 0 indicates to use ext devt from part0 and should
	 * be accompanied with EXT_DEVT flag.  Make sure all
	 * parameters make sense.
	 */
	WARN_ON(disk->minors && !(disk->major || disk->first_minor));
	WARN_ON(!disk->minors && !(disk->flags & GENHD_FL_EXT_DEVT));

Linus Torvalds's avatar
Linus Torvalds committed
590
	disk->flags |= GENHD_FL_UP;
591 592 593 594 595 596 597 598 599 600 601 602 603 604

	retval = blk_alloc_devt(&disk->part0, &devt);
	if (retval) {
		WARN_ON(1);
		return;
	}
	disk_to_dev(disk)->devt = devt;

	/* ->major and ->first_minor aren't supposed to be
	 * dereferenced from here on, but set them just in case.
	 */
	disk->major = MAJOR(devt);
	disk->first_minor = MINOR(devt);

605 606
	disk_alloc_events(disk);

607
	/* Register BDI before referencing it from bdev */
608 609 610
	bdi = &disk->queue->backing_dev_info;
	bdi_register_dev(bdi, disk_devt(disk));

611 612
	blk_register_region(disk_devt(disk), disk->minors, NULL,
			    exact_match, exact_lock, disk);
Linus Torvalds's avatar
Linus Torvalds committed
613 614
	register_disk(disk);
	blk_register_queue(disk);
615

616 617 618 619
	/*
	 * Take an extra ref on queue which will be put on disk_release()
	 * so that it sticks around as long as @disk is there.
	 */
620
	WARN_ON_ONCE(!blk_get_queue(disk->queue));
621

622 623
	retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
				   "bdi");
624
	WARN_ON(retval);
Linus Torvalds's avatar
Linus Torvalds committed
625

626
	disk_add_events(disk);
Linus Torvalds's avatar
Linus Torvalds committed
627 628 629
}
EXPORT_SYMBOL(add_disk);

630
void del_gendisk(struct gendisk *disk)
Linus Torvalds's avatar
Linus Torvalds committed
631
{
632 633 634
	struct disk_part_iter piter;
	struct hd_struct *part;

635 636
	disk_del_events(disk);

637 638 639 640 641 642 643 644 645 646 647 648 649 650
	/* invalidate stuff */
	disk_part_iter_init(&piter, disk,
			     DISK_PITER_INCL_EMPTY | DISK_PITER_REVERSE);
	while ((part = disk_part_iter_next(&piter))) {
		invalidate_partition(disk, part->partno);
		delete_partition(disk, part->partno);
	}
	disk_part_iter_exit(&piter);

	invalidate_partition(disk, 0);
	blk_free_devt(disk_to_dev(disk)->devt);
	set_capacity(disk, 0);
	disk->flags &= ~GENHD_FL_UP;

651
	sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
652
	bdi_unregister(&disk->queue->backing_dev_info);
Linus Torvalds's avatar
Linus Torvalds committed
653
	blk_unregister_queue(disk);
654
	blk_unregister_region(disk_devt(disk), disk->minors);
655 656 657 658 659 660 661 662 663 664

	part_stat_set_all(&disk->part0, 0);
	disk->part0.stamp = 0;

	kobject_put(disk->part0.holder_dir);
	kobject_put(disk->slave_dir);
	disk->driverfs_dev = NULL;
	if (!sysfs_deprecated)
		sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
	device_del(disk_to_dev(disk));
Linus Torvalds's avatar
Linus Torvalds committed
665
}
666
EXPORT_SYMBOL(del_gendisk);
Linus Torvalds's avatar
Linus Torvalds committed
667 668 669

/**
 * get_gendisk - get partitioning information for a given device
670
 * @devt: device to get partitioning information for
671
 * @partno: returned partition index
Linus Torvalds's avatar
Linus Torvalds committed
672 673
 *
 * This function gets the structure containing partitioning
674
 * information for the given device @devt.
Linus Torvalds's avatar
Linus Torvalds committed
675
 */
676
struct gendisk *get_gendisk(dev_t devt, int *partno)
Linus Torvalds's avatar
Linus Torvalds committed
677
{
678 679 680 681 682 683 684 685 686 687 688 689
	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);
690
		part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
691 692 693 694 695 696
		if (part && get_disk(part_to_disk(part))) {
			*partno = part->partno;
			disk = part_to_disk(part);
		}
		mutex_unlock(&ext_devt_mutex);
	}
697

698
	return disk;
Linus Torvalds's avatar
Linus Torvalds committed
699
}
700
EXPORT_SYMBOL(get_gendisk);
Linus Torvalds's avatar
Linus Torvalds committed
701

702 703 704 705 706 707 708 709 710 711 712 713 714
/**
 * 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.
 */
715
struct block_device *bdget_disk(struct gendisk *disk, int partno)
716
{
717 718
	struct hd_struct *part;
	struct block_device *bdev = NULL;
719

720
	part = disk_get_part(disk, partno);
721
	if (part)
722 723
		bdev = bdget(part_devt(part));
	disk_put_part(part);
724

725
	return bdev;
726 727 728
}
EXPORT_SYMBOL(bdget_disk);

729 730 731 732 733 734 735
/*
 * 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)
{
736 737 738 739 740 741
	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);
742 743
		struct disk_part_iter piter;
		struct hd_struct *part;
744 745
		char name_buf[BDEVNAME_SIZE];
		char devt_buf[BDEVT_SIZE];
746
		char uuid_buf[PARTITION_META_INFO_UUIDLTH * 2 + 5];
747 748 749

		/*
		 * Don't show empty devices or things that have been
Lucas De Marchi's avatar
Lucas De Marchi committed
750
		 * suppressed
751 752 753 754 755 756 757 758 759 760
		 */
		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.
		 */
761 762 763
		disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
		while ((part = disk_part_iter_next(&piter))) {
			bool is_part0 = part == &disk->part0;
764

765
			uuid_buf[0] = '\0';
766
			if (part->info)
767 768
				snprintf(uuid_buf, sizeof(uuid_buf), "%pU",
					 part->info->uuid);
769 770

			printk("%s%s %10llu %s %s", is_part0 ? "" : "  ",
771
			       bdevt_str(part_devt(part), devt_buf),
772
			       (unsigned long long)part->nr_sects >> 1,
773 774
			       disk_name(disk, part->partno, name_buf),
			       uuid_buf);
775 776 777 778 779 780 781 782 783 784
			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");
		}
785
		disk_part_iter_exit(&piter);
786 787
	}
	class_dev_iter_exit(&iter);
788 789
}

Linus Torvalds's avatar
Linus Torvalds committed
790 791
#ifdef CONFIG_PROC_FS
/* iterator */
792
static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
793
{
794 795 796
	loff_t skip = *pos;
	struct class_dev_iter *iter;
	struct device *dev;
797

798
	iter = kmalloc(sizeof(*iter), GFP_KERNEL);
799 800 801 802 803 804 805 806 807 808 809 810
	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);
811 812
}

813
static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
Linus Torvalds's avatar
Linus Torvalds committed
814
{
815
	struct device *dev;
Linus Torvalds's avatar
Linus Torvalds committed
816

817 818
	(*pos)++;
	dev = class_dev_iter_next(seqf->private);
819
	if (dev)
820
		return dev_to_disk(dev);
821

Linus Torvalds's avatar
Linus Torvalds committed
822 823 824
	return NULL;
}

825
static void disk_seqf_stop(struct seq_file *seqf, void *v)
826
{
827
	struct class_dev_iter *iter = seqf->private;
828

829 830 831 832
	/* stop is called even after start failed :-( */
	if (iter) {
		class_dev_iter_exit(iter);
		kfree(iter);
833
	}
Linus Torvalds's avatar
Linus Torvalds committed
834 835
}

836
static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
Linus Torvalds's avatar
Linus Torvalds committed
837
{
838 839 840
	static void *p;

	p = disk_seqf_start(seqf, pos);
841
	if (!IS_ERR_OR_NULL(p) && !*pos)
842 843
		seq_puts(seqf, "major minor  #blocks  name\n\n");
	return p;
Linus Torvalds's avatar
Linus Torvalds committed
844 845
}

846
static int show_partition(struct seq_file *seqf, void *v)
Linus Torvalds's avatar
Linus Torvalds committed
847 848
{
	struct gendisk *sgp = v;
849 850
	struct disk_part_iter piter;
	struct hd_struct *part;
Linus Torvalds's avatar
Linus Torvalds committed
851 852 853
	char buf[BDEVNAME_SIZE];

	/* Don't show non-partitionable removeable devices or empty devices */
Tejun Heo's avatar
Tejun Heo committed
854
	if (!get_capacity(sgp) || (!disk_max_parts(sgp) &&
855
				   (sgp->flags & GENHD_FL_REMOVABLE)))
Linus Torvalds's avatar
Linus Torvalds committed
856 857 858 859 860
		return 0;
	if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
		return 0;

	/* show the full disk and all non-0 size partitions of it */
861
	disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0);
862
	while ((part = disk_part_iter_next(&piter)))
863
		seq_printf(seqf, "%4d  %7d %10llu %s\n",
864 865 866
			   MAJOR(part_devt(part)), MINOR(part_devt(part)),
			   (unsigned long long)part->nr_sects >> 1,
			   disk_name(sgp, part->partno, buf));
867
	disk_part_iter_exit(&piter);
Linus Torvalds's avatar
Linus Torvalds committed
868 869 870 871

	return 0;
}

872
static const struct seq_operations partitions_op = {
873 874 875
	.start	= show_partition_start,
	.next	= disk_seqf_next,
	.stop	= disk_seqf_stop,
876
	.show	= show_partition
Linus Torvalds's avatar
Linus Torvalds committed
877
};
878 879 880 881 882 883 884 885 886 887 888 889

static int partitions_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &partitions_op);
}

static const struct file_operations proc_partitions_operations = {
	.open		= partitions_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
};
Linus Torvalds's avatar
Linus Torvalds committed
890 891 892
#endif


893
static struct kobject *base_probe(dev_t devt, int *partno, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
894
{
895
	if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
Linus Torvalds's avatar
Linus Torvalds committed
896
		/* Make old-style 2.4 aliases work */
897
		request_module("block-major-%d", MAJOR(devt));
Linus Torvalds's avatar
Linus Torvalds committed
898 899 900 901 902
	return NULL;
}

static int __init genhd_device_init(void)
{
903 904 905 906
	int error;

	block_class.dev_kobj = sysfs_dev_block_kobj;
	error = class_register(&block_class);
907 908
	if (unlikely(error))
		return error;
909
	bdev_map = kobj_map_init(base_probe, &block_class_lock);
Linus Torvalds's avatar
Linus Torvalds committed
910
	blk_dev_init();
911

912 913
	register_blkdev(BLOCK_EXT_MAJOR, "blkext");

914
	/* create top-level block dir */
915 916
	if (!sysfs_deprecated)
		block_depr = kobject_create_and_add("block", NULL);
917
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
918 919 920 921
}

subsys_initcall(genhd_device_init);

922 923
static ssize_t disk_range_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
924
{
925
	struct gendisk *disk = dev_to_disk(dev);
Linus Torvalds's avatar
Linus Torvalds committed
926

927
	return sprintf(buf, "%d\n", disk->minors);
Linus Torvalds's avatar
Linus Torvalds committed
928 929
}

930 931 932 933 934
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
935
	return sprintf(buf, "%d\n", disk_max_parts(disk));
936 937
}

938 939
static ssize_t disk_removable_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
940
{
941
	struct gendisk *disk = dev_to_disk(dev);
942

943 944
	return sprintf(buf, "%d\n",
		       (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
945 946
}

Kay Sievers's avatar
Kay Sievers committed
947 948 949 950 951
static ssize_t disk_ro_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct gendisk *disk = dev_to_disk(dev);

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

955 956
static ssize_t disk_capability_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
957
{
958 959 960
	struct gendisk *disk = dev_to_disk(dev);

	return sprintf(buf, "%x\n", disk->flags);
961
}
962

963 964 965 966 967 968 969 970 971
static ssize_t disk_alignment_offset_show(struct device *dev,
					  struct device_attribute *attr,
					  char *buf)
{
	struct gendisk *disk = dev_to_disk(dev);

	return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
}

972 973 974 975 976 977
static ssize_t disk_discard_alignment_show(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct gendisk *disk = dev_to_disk(dev);

978
	return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
979 980
}

981
static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
982
static DEVICE_ATTR(ext_range, S_IRUGO, disk_ext_range_show, NULL);
983
static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
Kay Sievers's avatar
Kay Sievers committed
984
static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
985
static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
986
static DEVICE_ATTR(alignment_offset, S_IRUGO, disk_alignment_offset_show, NULL);
987 988
static DEVICE_ATTR(discard_alignment, S_IRUGO, disk_discard_alignment_show,
		   NULL);
989
static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
990
static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
991
static DEVICE_ATTR(inflight, S_IRUGO, part_inflight_show, NULL);
992
#ifdef CONFIG_FAIL_MAKE_REQUEST
993
static struct device_attribute dev_attr_fail =
994
	__ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store);
995
#endif
996 997 998 999 1000
#ifdef CONFIG_FAIL_IO_TIMEOUT
static struct device_attribute dev_attr_fail_timeout =
	__ATTR(io-timeout-fail,  S_IRUGO|S_IWUSR, part_timeout_show,
		part_timeout_store);
#endif
1001 1002 1003

static struct attribute *disk_attrs[] = {
	&dev_attr_range.attr,
1004
	&dev_attr_ext_range.attr,
1005
	&dev_attr_removable.attr,
Kay Sievers's avatar
Kay Sievers committed
1006
	&dev_attr_ro.attr,
1007
	&dev_attr_size.attr,
1008
	&dev_attr_alignment_offset.attr,
1009
	&dev_attr_discard_alignment.attr,
1010 1011
	&dev_attr_capability.attr,
	&dev_attr_stat.attr,
1012
	&dev_attr_inflight.attr,
1013 1014
#ifdef CONFIG_FAIL_MAKE_REQUEST
	&dev_attr_fail.attr,
1015 1016 1017
#endif
#ifdef CONFIG_FAIL_IO_TIMEOUT
	&dev_attr_fail_timeout.attr,
1018 1019 1020 1021 1022 1023 1024 1025
#endif
	NULL
};

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

1026
static const struct attribute_group *disk_attr_groups[] = {
1027 1028
	&disk_attr_group,
	NULL
Linus Torvalds's avatar
Linus Torvalds committed
1029 1030
};

1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
/**
 * disk_replace_part_tbl - replace disk->part_tbl in RCU-safe way
 * @disk: disk to replace part_tbl for
 * @new_ptbl: new part_tbl to install
 *
 * Replace disk->part_tbl with @new_ptbl in RCU-safe way.  The
 * original ptbl is freed using RCU callback.
 *
 * LOCKING:
 * Matching bd_mutx locked.
 */
static void disk_replace_part_tbl(struct gendisk *disk,
				  struct disk_part_tbl *new_ptbl)
{
	struct disk_part_tbl *old_ptbl = disk->part_tbl;

	rcu_assign_pointer(disk->part_tbl, new_ptbl);
1048 1049 1050

	if (old_ptbl) {
		rcu_assign_pointer(old_ptbl->last_lookup, NULL);
1051
		kfree_rcu(old_ptbl, rcu_head);
1052
	}
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
}

/**
 * disk_expand_part_tbl - expand disk->part_tbl
 * @disk: disk to expand part_tbl for
 * @partno: expand such that this partno can fit in
 *
 * Expand disk->part_tbl such that @partno can fit in.  disk->part_tbl
 * uses RCU to allow unlocked dereferencing for stats and other stuff.
 *
 * LOCKING:
 * Matching bd_mutex locked, might sleep.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
int disk_expand_part_tbl(struct gendisk *disk, int partno)
{
	struct disk_part_tbl *old_ptbl = disk->part_tbl;
	struct disk_part_tbl *new_ptbl;
	int len = old_ptbl ? old_ptbl->len : 0;
	int target = partno + 1;
	size_t size;
	int i;

	/* disk_max_parts() is zero during initialization, ignore if so */
	if (disk_max_parts(disk) && target > disk_max_parts(disk))
		return -EINVAL;

	if (target <= len)
		return 0;

	size = sizeof(*new_ptbl) + target * sizeof(new_ptbl->part[0]);
	new_ptbl = kzalloc_node(size, GFP_KERNEL, disk->node_id);
	if (!new_ptbl)
		return -ENOMEM;

	new_ptbl->len = target;

	for (i = 0; i < len; i++)
		rcu_assign_pointer(new_ptbl->part[i], old_ptbl->part[i]);

	disk_replace_part_tbl(disk, new_ptbl);
	return 0;
}

1099
static void disk_release(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1100
{
1101 1102
	struct gendisk *disk = dev_to_disk(dev);

1103
	disk_release_events(disk);
Linus Torvalds's avatar
Linus Torvalds committed
1104
	kfree(disk->random);
1105
	disk_replace_part_tbl(disk, NULL);
1106
	free_part_stats(&disk->part0);
1107
	free_part_info(&disk->part0);
1108 1109
	if (disk->queue)
		blk_put_queue(disk->queue);
Linus Torvalds's avatar
Linus Torvalds committed
1110 1111
	kfree(disk);
}
1112 1113
struct class block_class = {
	.name		= "block",
Linus Torvalds's avatar
Linus Torvalds committed
1114 1115
};

1116
static char *block_devnode(struct device *dev, umode_t *mode)
1117 1118 1119
{
	struct gendisk *disk = dev_to_disk(dev);

1120 1121
	if (disk->devnode)
		return disk->devnode(disk, mode);
1122 1123 1124
	return NULL;
}

Adrian Bunk's avatar
Adrian Bunk committed
1125
static struct device_type disk_type = {
1126 1127 1128
	.name		= "disk",
	.groups		= disk_attr_groups,
	.release	= disk_release,
1129
	.devnode	= block_devnode,
Linus Torvalds's avatar
Linus Torvalds committed
1130 1131
};

1132
#ifdef CONFIG_PROC_FS
1133 1134 1135 1136 1137 1138 1139 1140
/*
 * 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
1141 1142
{
	struct gendisk *gp = v;
1143 1144
	struct disk_part_iter piter;
	struct hd_struct *hd;
Linus Torvalds's avatar
Linus Torvalds committed
1145
	char buf[BDEVNAME_SIZE];
Tejun Heo's avatar
Tejun Heo committed
1146
	int cpu;
Linus Torvalds's avatar
Linus Torvalds committed
1147 1148

	/*
1149
	if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
1150
		seq_puts(seqf,	"major minor name"
Linus Torvalds's avatar
Linus Torvalds committed
1151 1152 1153 1154
				"     rio rmerge rsect ruse wio wmerge "
				"wsect wuse running use aveq"
				"\n\n");
	*/
1155

1156
	disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0);
1157
	while ((hd = disk_part_iter_next(&piter))) {
1158
		cpu = part_stat_lock();
Tejun Heo's avatar
Tejun Heo committed
1159
		part_round_stats(cpu, hd);
1160
		part_stat_unlock();
1161 1162
		seq_printf(seqf, "%4d %7d %s %lu %lu %lu "
			   "%u %lu %lu %lu %u %u %u %u\n",
1163 1164
			   MAJOR(part_devt(hd)), MINOR(part_devt(hd)),
			   disk_name(gp, hd->partno, buf),
1165 1166
			   part_stat_read(hd, ios[READ]),
			   part_stat_read(hd, merges[READ]),
1167
			   part_stat_read(hd, sectors[READ]),
1168 1169 1170
			   jiffies_to_msecs(part_stat_read(hd, ticks[READ])),
			   part_stat_read(hd, ios[WRITE]),
			   part_stat_read(hd, merges[WRITE]),
1171
			   part_stat_read(hd, sectors[WRITE]),
1172
			   jiffies_to_msecs(part_stat_read(hd, ticks[WRITE])),
1173
			   part_in_flight(hd),
1174 1175 1176
			   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
1177
	}
1178
	disk_part_iter_exit(&piter);
1179

Linus Torvalds's avatar
Linus Torvalds committed
1180 1181 1182
	return 0;
}

1183
static const struct seq_operations diskstats_op = {
1184 1185 1186
	.start	= disk_seqf_start,
	.next	= disk_seqf_next,
	.stop	= disk_seqf_stop,
Linus Torvalds's avatar
Linus Torvalds committed
1187 1188
	.show	= diskstats_show
};
1189

1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
static int diskstats_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &diskstats_op);
}

static const struct file_operations proc_diskstats_operations = {
	.open		= diskstats_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
};

1202 1203
static int __init proc_genhd_init(void)
{
1204
	proc_create("diskstats", 0, NULL, &proc_diskstats_operations);
1205 1206 1207 1208
	proc_create("partitions", 0, NULL, &proc_partitions_operations);
	return 0;
}
module_init(proc_genhd_init);
1209
#endif /* CONFIG_PROC_FS */
Linus Torvalds's avatar
Linus Torvalds committed
1210

1211
dev_t blk_lookup_devt(const char *name, int partno)
1212
{
1213 1214 1215
	dev_t devt = MKDEV(0, 0);
	struct class_dev_iter iter;
	struct device *dev;
1216

1217 1218
	class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
	while ((dev = class_dev_iter_next(&iter))) {
1219
		struct gendisk *disk = dev_to_disk(dev);
1220
		struct hd_struct *part;
1221

1222
		if (strcmp(dev_name(dev), name))
1223 1224
			continue;

1225 1226 1227 1228 1229 1230 1231 1232
		if (partno < disk->minors) {
			/* We need to return the right devno, even
			 * if the partition doesn't exist yet.
			 */
			devt = MKDEV(MAJOR(dev->devt),
				     MINOR(dev->devt) + partno);
			break;
		}
1233
		part = disk_get_part(disk, partno);
1234
		if (part) {
1235
			devt = part_devt(part);
1236
			disk_put_part(part);
1237
			break;
1238
		}
1239
		disk_put_part(part);
1240
	}
1241
	class_dev_iter_exit(&iter);
1242 1243 1244 1245
	return devt;
}
EXPORT_SYMBOL(blk_lookup_devt);

Linus Torvalds's avatar
Linus Torvalds committed
1246 1247
struct gendisk *alloc_disk(int minors)
{
1248 1249
	return alloc_disk_node(minors, -1);
}
1250
EXPORT_SYMBOL(alloc_disk);
1251 1252 1253 1254 1255

struct gendisk *alloc_disk_node(int minors, int node_id)
{
	struct gendisk *disk;

1256 1257
	disk = kmalloc_node(sizeof(struct gendisk),
				GFP_KERNEL | __GFP_ZERO, node_id);
Linus Torvalds's avatar
Linus Torvalds committed
1258
	if (disk) {
1259
		if (!init_part_stats(&disk->part0)) {
Linus Torvalds's avatar
Linus Torvalds committed
1260 1261 1262
			kfree(disk);
			return NULL;
		}
1263
		disk->node_id = node_id;
1264 1265
		if (disk_expand_part_tbl(disk, 0)) {
			free_part_stats(&disk->part0);
Tejun Heo's avatar
Tejun Heo committed
1266 1267
			kfree(disk);
			return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1268
		}
1269
		disk->part_tbl->part[0] = &disk->part0;
1270 1271

		hd_ref_init(&disk->part0);
Tejun Heo's avatar
Tejun Heo committed
1272

Linus Torvalds's avatar
Linus Torvalds committed
1273 1274
		disk->minors = minors;
		rand_initialize_disk(disk);
1275 1276 1277
		disk_to_dev(disk)->class = &block_class;
		disk_to_dev(disk)->type = &disk_type;
		device_initialize(disk_to_dev(disk));
Linus Torvalds's avatar
Linus Torvalds committed
1278 1279 1280
	}
	return disk;
}
1281
EXPORT_SYMBOL(alloc_disk_node);
Linus Torvalds's avatar
Linus Torvalds committed
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292

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;
1293
	kobj = kobject_get(&disk_to_dev(disk)->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
	if (kobj == NULL) {