check.c 18.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 *  fs/partitions/check.c
 *
 *  Code extracted from drivers/block/genhd.c
 *  Copyright (C) 1991-1998  Linus Torvalds
 *  Re-organised Feb 1998 Russell King
 *
 *  We now have independent partition support from the
 *  block drivers, which allows all the partition code to
 *  be grouped in one location, and it to be mostly self
 *  contained.
 *
 *  Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl}
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
19
#include <linux/slab.h>
L
Linus Torvalds 已提交
20 21
#include <linux/kmod.h>
#include <linux/ctype.h>
22
#include <linux/genhd.h>
23
#include <linux/blktrace_api.h>
L
Linus Torvalds 已提交
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

#include "check.h"

#include "acorn.h"
#include "amiga.h"
#include "atari.h"
#include "ldm.h"
#include "mac.h"
#include "msdos.h"
#include "osf.h"
#include "sgi.h"
#include "sun.h"
#include "ibm.h"
#include "ultrix.h"
#include "efi.h"
39
#include "karma.h"
40
#include "sysv68.h"
L
Linus Torvalds 已提交
41 42 43 44 45 46 47

#ifdef CONFIG_BLK_DEV_MD
extern void md_autodetect_dev(dev_t dev);
#endif

int warn_no_part = 1; /*This is ugly: should make genhd removable media aware*/

48
static int (*check_part[])(struct parsed_partitions *) = {
L
Linus Torvalds 已提交
49 50 51 52 53 54 55 56 57 58 59 60 61 62 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 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
	/*
	 * Probe partition formats with tables at disk address 0
	 * that also have an ADFS boot block at 0xdc0.
	 */
#ifdef CONFIG_ACORN_PARTITION_ICS
	adfspart_check_ICS,
#endif
#ifdef CONFIG_ACORN_PARTITION_POWERTEC
	adfspart_check_POWERTEC,
#endif
#ifdef CONFIG_ACORN_PARTITION_EESOX
	adfspart_check_EESOX,
#endif

	/*
	 * Now move on to formats that only have partition info at
	 * disk address 0xdc0.  Since these may also have stale
	 * PC/BIOS partition tables, they need to come before
	 * the msdos entry.
	 */
#ifdef CONFIG_ACORN_PARTITION_CUMANA
	adfspart_check_CUMANA,
#endif
#ifdef CONFIG_ACORN_PARTITION_ADFS
	adfspart_check_ADFS,
#endif

#ifdef CONFIG_EFI_PARTITION
	efi_partition,		/* this must come before msdos */
#endif
#ifdef CONFIG_SGI_PARTITION
	sgi_partition,
#endif
#ifdef CONFIG_LDM_PARTITION
	ldm_partition,		/* this must come before msdos */
#endif
#ifdef CONFIG_MSDOS_PARTITION
	msdos_partition,
#endif
#ifdef CONFIG_OSF_PARTITION
	osf_partition,
#endif
#ifdef CONFIG_SUN_PARTITION
	sun_partition,
#endif
#ifdef CONFIG_AMIGA_PARTITION
	amiga_partition,
#endif
#ifdef CONFIG_ATARI_PARTITION
	atari_partition,
#endif
#ifdef CONFIG_MAC_PARTITION
	mac_partition,
#endif
#ifdef CONFIG_ULTRIX_PARTITION
	ultrix_partition,
#endif
#ifdef CONFIG_IBM_PARTITION
	ibm_partition,
108 109 110
#endif
#ifdef CONFIG_KARMA_PARTITION
	karma_partition,
111 112 113
#endif
#ifdef CONFIG_SYSV68_PARTITION
	sysv68_partition,
L
Linus Torvalds 已提交
114 115 116 117 118 119 120 121 122 123 124
#endif
	NULL
};
 
/*
 * disk_name() is used by partition check code and the genhd driver.
 * It formats the devicename of the indicated disk into
 * the supplied buffer (of size at least 32), and returns
 * a pointer to that same buffer (for convenience).
 */

125
char *disk_name(struct gendisk *hd, int partno, char *buf)
L
Linus Torvalds 已提交
126
{
127
	if (!partno)
L
Linus Torvalds 已提交
128 129
		snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
	else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
130
		snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, partno);
L
Linus Torvalds 已提交
131
	else
132
		snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, partno);
L
Linus Torvalds 已提交
133 134 135 136 137 138

	return buf;
}

const char *bdevname(struct block_device *bdev, char *buf)
{
T
Tejun Heo 已提交
139
	return disk_name(bdev->bd_disk, bdev->bd_part->partno, buf);
L
Linus Torvalds 已提交
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
}

EXPORT_SYMBOL(bdevname);

/*
 * There's very little reason to use this, you should really
 * have a struct block_device just about everywhere and use
 * bdevname() instead.
 */
const char *__bdevname(dev_t dev, char *buffer)
{
	scnprintf(buffer, BDEVNAME_SIZE, "unknown-block(%u,%u)",
				MAJOR(dev), MINOR(dev));
	return buffer;
}

EXPORT_SYMBOL(__bdevname);

static struct parsed_partitions *
check_partition(struct gendisk *hd, struct block_device *bdev)
{
	struct parsed_partitions *state;
S
Suzuki K P 已提交
162
	int i, res, err;
L
Linus Torvalds 已提交
163

164
	state = kzalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
L
Linus Torvalds 已提交
165 166
	if (!state)
		return NULL;
167 168 169 170 171 172
	state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
	if (!state->pp_buf) {
		kfree(state);
		return NULL;
	}
	state->pp_buf[0] = '\0';
L
Linus Torvalds 已提交
173

174
	state->bdev = bdev;
175
	disk_name(hd, 0, state->name);
176
	snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
177
	if (isdigit(state->name[strlen(state->name)-1]))
L
Linus Torvalds 已提交
178
		sprintf(state->name, "p");
179

T
Tejun Heo 已提交
180
	state->limit = disk_max_parts(hd);
S
Suzuki K P 已提交
181
	i = res = err = 0;
L
Linus Torvalds 已提交
182 183
	while (!res && check_part[i]) {
		memset(&state->parts, 0, sizeof(state->parts));
184
		res = check_part[i++](state);
S
Suzuki K P 已提交
185 186 187 188 189 190 191 192
		if (res < 0) {
			/* We have hit an I/O error which we don't report now.
		 	* But record it, and let the others do their job.
		 	*/
			err = res;
			res = 0;
		}

L
Linus Torvalds 已提交
193
	}
194 195 196 197
	if (res > 0) {
		printk(KERN_INFO "%s", state->pp_buf);

		free_page((unsigned long)state->pp_buf);
L
Linus Torvalds 已提交
198
		return state;
199
	}
200 201
	if (state->access_beyond_eod)
		err = -ENOSPC;
202
	if (err)
S
Suzuki K P 已提交
203 204
	/* The partition is unrecognized. So report I/O errors if there were any */
		res = err;
L
Linus Torvalds 已提交
205
	if (!res)
206
		strlcat(state->pp_buf, " unknown partition table\n", PAGE_SIZE);
L
Linus Torvalds 已提交
207
	else if (warn_no_part)
208 209 210 211 212
		strlcat(state->pp_buf, " unable to read partition table\n", PAGE_SIZE);

	printk(KERN_INFO "%s", state->pp_buf);

	free_page((unsigned long)state->pp_buf);
L
Linus Torvalds 已提交
213
	kfree(state);
214
	return ERR_PTR(res);
L
Linus Torvalds 已提交
215 216
}

217 218 219 220 221 222 223 224
static ssize_t part_partition_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct hd_struct *p = dev_to_part(dev);

	return sprintf(buf, "%d\n", p->partno);
}

225 226
static ssize_t part_start_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
227
{
228
	struct hd_struct *p = dev_to_part(dev);
229

230
	return sprintf(buf, "%llu\n",(unsigned long long)p->start_sect);
L
Linus Torvalds 已提交
231 232
}

T
Tejun Heo 已提交
233 234
ssize_t part_size_show(struct device *dev,
		       struct device_attribute *attr, char *buf)
235
{
236 237
	struct hd_struct *p = dev_to_part(dev);
	return sprintf(buf, "%llu\n",(unsigned long long)p->nr_sects);
238
}
239

240 241 242 243 244 245 246
ssize_t part_alignment_offset_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct hd_struct *p = dev_to_part(dev);
	return sprintf(buf, "%llu\n", (unsigned long long)p->alignment_offset);
}

247 248 249 250 251 252 253
ssize_t part_discard_alignment_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct hd_struct *p = dev_to_part(dev);
	return sprintf(buf, "%u\n", p->discard_alignment);
}

T
Tejun Heo 已提交
254 255
ssize_t part_stat_show(struct device *dev,
		       struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
256
{
257
	struct hd_struct *p = dev_to_part(dev);
T
Tejun Heo 已提交
258
	int cpu;
259

T
Tejun Heo 已提交
260
	cpu = part_stat_lock();
T
Tejun Heo 已提交
261
	part_round_stats(cpu, p);
T
Tejun Heo 已提交
262
	part_stat_unlock();
263 264 265 266 267 268 269 270 271 272 273 274 275
	return sprintf(buf,
		"%8lu %8lu %8llu %8u "
		"%8lu %8lu %8llu %8u "
		"%8u %8u %8u"
		"\n",
		part_stat_read(p, ios[READ]),
		part_stat_read(p, merges[READ]),
		(unsigned long long)part_stat_read(p, sectors[READ]),
		jiffies_to_msecs(part_stat_read(p, ticks[READ])),
		part_stat_read(p, ios[WRITE]),
		part_stat_read(p, merges[WRITE]),
		(unsigned long long)part_stat_read(p, sectors[WRITE]),
		jiffies_to_msecs(part_stat_read(p, ticks[WRITE])),
276
		part_in_flight(p),
277 278
		jiffies_to_msecs(part_stat_read(p, io_ticks)),
		jiffies_to_msecs(part_stat_read(p, time_in_queue)));
L
Linus Torvalds 已提交
279 280
}

281 282 283 284 285 286 287 288
ssize_t part_inflight_show(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct hd_struct *p = dev_to_part(dev);

	return sprintf(buf, "%8u %8u\n", p->in_flight[0], p->in_flight[1]);
}

289
#ifdef CONFIG_FAIL_MAKE_REQUEST
290 291
ssize_t part_fail_show(struct device *dev,
		       struct device_attribute *attr, char *buf)
292 293
{
	struct hd_struct *p = dev_to_part(dev);
294

295 296 297
	return sprintf(buf, "%d\n", p->make_it_fail);
}

298 299 300
ssize_t part_fail_store(struct device *dev,
			struct device_attribute *attr,
			const char *buf, size_t count)
301
{
302
	struct hd_struct *p = dev_to_part(dev);
303 304 305 306 307 308 309
	int i;

	if (count > 0 && sscanf(buf, "%d", &i) > 0)
		p->make_it_fail = (i == 0) ? 0 : 1;

	return count;
}
310
#endif
311

312
static DEVICE_ATTR(partition, S_IRUGO, part_partition_show, NULL);
313 314
static DEVICE_ATTR(start, S_IRUGO, part_start_show, NULL);
static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
315
static DEVICE_ATTR(alignment_offset, S_IRUGO, part_alignment_offset_show, NULL);
316 317
static DEVICE_ATTR(discard_alignment, S_IRUGO, part_discard_alignment_show,
		   NULL);
318
static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
319
static DEVICE_ATTR(inflight, S_IRUGO, part_inflight_show, NULL);
320 321 322
#ifdef CONFIG_FAIL_MAKE_REQUEST
static struct device_attribute dev_attr_fail =
	__ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store);
323 324
#endif

325
static struct attribute *part_attrs[] = {
326
	&dev_attr_partition.attr,
327 328
	&dev_attr_start.attr,
	&dev_attr_size.attr,
329
	&dev_attr_alignment_offset.attr,
330
	&dev_attr_discard_alignment.attr,
331
	&dev_attr_stat.attr,
332
	&dev_attr_inflight.attr,
333
#ifdef CONFIG_FAIL_MAKE_REQUEST
334
	&dev_attr_fail.attr,
335
#endif
336
	NULL
L
Linus Torvalds 已提交
337 338
};

339 340 341
static struct attribute_group part_attr_group = {
	.attrs = part_attrs,
};
L
Linus Torvalds 已提交
342

343
static const struct attribute_group *part_attr_groups[] = {
344
	&part_attr_group,
345 346 347
#ifdef CONFIG_BLK_DEV_IO_TRACE
	&blk_trace_attr_group,
#endif
348 349 350 351
	NULL
};

static void part_release(struct device *dev)
L
Linus Torvalds 已提交
352
{
353
	struct hd_struct *p = dev_to_part(dev);
354
	free_part_stats(p);
L
Linus Torvalds 已提交
355 356 357
	kfree(p);
}

358 359 360
struct device_type part_type = {
	.name		= "partition",
	.groups		= part_attr_groups,
L
Linus Torvalds 已提交
361 362 363
	.release	= part_release,
};

364 365 366 367 368 369 370
static void delete_partition_rcu_cb(struct rcu_head *head)
{
	struct hd_struct *part = container_of(head, struct hd_struct, rcu_head);

	part->start_sect = 0;
	part->nr_sects = 0;
	part_stat_set_all(part, 0);
371
	put_device(part_to_dev(part));
372 373
}

374
void delete_partition(struct gendisk *disk, int partno)
L
Linus Torvalds 已提交
375
{
T
Tejun Heo 已提交
376
	struct disk_part_tbl *ptbl = disk->part_tbl;
377
	struct hd_struct *part;
378

T
Tejun Heo 已提交
379 380 381 382
	if (partno >= ptbl->len)
		return;

	part = ptbl->part[partno];
383
	if (!part)
L
Linus Torvalds 已提交
384
		return;
385

T
Tejun Heo 已提交
386
	blk_free_devt(part_devt(part));
T
Tejun Heo 已提交
387
	rcu_assign_pointer(ptbl->part[partno], NULL);
N
Neil Brown 已提交
388
	rcu_assign_pointer(ptbl->last_lookup, NULL);
389
	kobject_put(part->holder_dir);
390
	device_del(part_to_dev(part));
391 392

	call_rcu(&part->rcu_head, delete_partition_rcu_cb);
L
Linus Torvalds 已提交
393 394
}

395 396 397 398 399 400 401 402
static ssize_t whole_disk_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	return 0;
}
static DEVICE_ATTR(whole_disk, S_IRUSR | S_IRGRP | S_IROTH,
		   whole_disk_show, NULL);

403 404
struct hd_struct *add_partition(struct gendisk *disk, int partno,
				sector_t start, sector_t len, int flags)
L
Linus Torvalds 已提交
405 406
{
	struct hd_struct *p;
T
Tejun Heo 已提交
407
	dev_t devt = MKDEV(0, 0);
408 409
	struct device *ddev = disk_to_dev(disk);
	struct device *pdev;
T
Tejun Heo 已提交
410
	struct disk_part_tbl *ptbl;
411
	const char *dname;
412
	int err;
L
Linus Torvalds 已提交
413

T
Tejun Heo 已提交
414 415
	err = disk_expand_part_tbl(disk, partno);
	if (err)
416
		return ERR_PTR(err);
T
Tejun Heo 已提交
417 418 419
	ptbl = disk->part_tbl;

	if (ptbl->part[partno])
420
		return ERR_PTR(-EBUSY);
421

422
	p = kzalloc(sizeof(*p), GFP_KERNEL);
L
Linus Torvalds 已提交
423
	if (!p)
424
		return ERR_PTR(-EBUSY);
425

426
	if (!init_part_stats(p)) {
427
		err = -ENOMEM;
428
		goto out_free;
429
	}
430 431
	pdev = part_to_dev(p);

L
Linus Torvalds 已提交
432
	p->start_sect = start;
433 434 435 436
	p->alignment_offset =
		queue_limit_alignment_offset(&disk->queue->limits, start);
	p->discard_alignment =
		queue_limit_discard_alignment(&disk->queue->limits, start);
L
Linus Torvalds 已提交
437
	p->nr_sects = len;
438
	p->partno = partno;
T
Tejun Heo 已提交
439
	p->policy = get_disk_ro(disk);
L
Linus Torvalds 已提交
440

441 442
	dname = dev_name(ddev);
	if (isdigit(dname[strlen(dname) - 1]))
443
		dev_set_name(pdev, "%sp%d", dname, partno);
L
Linus Torvalds 已提交
444
	else
445
		dev_set_name(pdev, "%s%d", dname, partno);
446

447 448 449 450
	device_initialize(pdev);
	pdev->class = &block_class;
	pdev->type = &part_type;
	pdev->parent = ddev;
451

T
Tejun Heo 已提交
452 453
	err = blk_alloc_devt(p, &devt);
	if (err)
T
Tejun Heo 已提交
454
		goto out_free_stats;
455
	pdev->devt = devt;
T
Tejun Heo 已提交
456

457
	/* delay uevent until 'holders' subdir is created */
458
	dev_set_uevent_suppress(pdev, 1);
459
	err = device_add(pdev);
460
	if (err)
461 462 463
		goto out_put;

	err = -ENOMEM;
464
	p->holder_dir = kobject_create_and_add("holders", &pdev->kobj);
465 466 467
	if (!p->holder_dir)
		goto out_del;

468
	dev_set_uevent_suppress(pdev, 0);
469
	if (flags & ADDPART_FLAG_WHOLEDISK) {
470
		err = device_create_file(pdev, &dev_attr_whole_disk);
471
		if (err)
472
			goto out_del;
473
	}
L
Linus Torvalds 已提交
474

475
	/* everything is up and running, commence */
T
Tejun Heo 已提交
476
	rcu_assign_pointer(ptbl->part[partno], p);
477

478
	/* suppress uevent if the disk supresses it */
479
	if (!dev_get_uevent_suppress(ddev))
480
		kobject_uevent(&pdev->kobj, KOBJ_ADD);
481

482
	return p;
483

T
Tejun Heo 已提交
484 485
out_free_stats:
	free_part_stats(p);
486 487
out_free:
	kfree(p);
488
	return ERR_PTR(err);
489 490
out_del:
	kobject_put(p->holder_dir);
491
	device_del(pdev);
492
out_put:
493
	put_device(pdev);
T
Tejun Heo 已提交
494
	blk_free_devt(devt);
495
	return ERR_PTR(err);
L
Linus Torvalds 已提交
496 497 498 499 500
}

/* Not exported, helper to add_disk(). */
void register_disk(struct gendisk *disk)
{
501
	struct device *ddev = disk_to_dev(disk);
L
Linus Torvalds 已提交
502
	struct block_device *bdev;
503 504
	struct disk_part_iter piter;
	struct hd_struct *part;
L
Linus Torvalds 已提交
505 506
	int err;

507
	ddev->parent = disk->driverfs_dev;
508

509
	dev_set_name(ddev, disk->disk_name);
510 511

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

514
	if (device_add(ddev))
L
Linus Torvalds 已提交
515
		return;
516
#ifndef CONFIG_SYSFS_DEPRECATED
517 518
	err = sysfs_create_link(block_depr, &ddev->kobj,
				kobject_name(&ddev->kobj));
519
	if (err) {
520
		device_del(ddev);
521 522
		return;
	}
523
#endif
524 525
	disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
	disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
L
Linus Torvalds 已提交
526 527

	/* No minors to use for partitions */
T
Tejun Heo 已提交
528
	if (!disk_partitionable(disk))
529
		goto exit;
L
Linus Torvalds 已提交
530 531 532

	/* No such device (e.g., media were just removed) */
	if (!get_capacity(disk))
533
		goto exit;
L
Linus Torvalds 已提交
534 535 536

	bdev = bdget_disk(disk, 0);
	if (!bdev)
537
		goto exit;
L
Linus Torvalds 已提交
538 539

	bdev->bd_invalidated = 1;
540
	err = blkdev_get(bdev, FMODE_READ);
541 542
	if (err < 0)
		goto exit;
A
Al Viro 已提交
543
	blkdev_put(bdev, FMODE_READ);
544 545

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

	/* announce possible partitions */
551 552
	disk_part_iter_init(&piter, disk, 0);
	while ((part = disk_part_iter_next(&piter)))
553
		kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD);
554
	disk_part_iter_exit(&piter);
L
Linus Torvalds 已提交
555 556
}

557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
static bool disk_unlock_native_capacity(struct gendisk *disk)
{
	const struct block_device_operations *bdops = disk->fops;

	if (bdops->unlock_native_capacity &&
	    !(disk->flags & GENHD_FL_NATIVE_CAPACITY)) {
		printk(KERN_CONT "enabling native capacity\n");
		bdops->unlock_native_capacity(disk);
		disk->flags |= GENHD_FL_NATIVE_CAPACITY;
		return true;
	} else {
		printk(KERN_CONT "truncated\n");
		return false;
	}
}

L
Linus Torvalds 已提交
573 574
int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
{
575
	struct parsed_partitions *state = NULL;
576 577
	struct disk_part_iter piter;
	struct hd_struct *part;
T
Tejun Heo 已提交
578
	int p, highest, res;
579
rescan:
580 581 582 583 584
	if (state && !IS_ERR(state)) {
		kfree(state);
		state = NULL;
	}

L
Linus Torvalds 已提交
585 586 587 588 589
	if (bdev->bd_part_count)
		return -EBUSY;
	res = invalidate_partition(disk, 0);
	if (res)
		return res;
590 591 592 593 594 595

	disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
	while ((part = disk_part_iter_next(&piter)))
		delete_partition(disk, part->partno);
	disk_part_iter_exit(&piter);

L
Linus Torvalds 已提交
596 597
	if (disk->fops->revalidate_disk)
		disk->fops->revalidate_disk(disk);
598 599
	check_disk_size_change(disk, bdev);
	bdev->bd_invalidated = 0;
L
Linus Torvalds 已提交
600 601
	if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))
		return 0;
602 603 604 605 606 607 608 609 610 611 612 613
	if (IS_ERR(state)) {
		/*
		 * I/O error reading the partition table.  If any
		 * partition code tried to read beyond EOD, retry
		 * after unlocking native capacity.
		 */
		if (PTR_ERR(state) == -ENOSPC) {
			printk(KERN_WARNING "%s: partition table beyond EOD, ",
			       disk->disk_name);
			if (disk_unlock_native_capacity(disk))
				goto rescan;
		}
614
		return -EIO;
615 616 617 618 619 620 621 622 623 624 625 626 627
	}
	/*
	 * If any partition code tried to read beyond EOD, try
	 * unlocking native capacity even if partition table is
	 * sucessfully read as we could be missing some partitions.
	 */
	if (state->access_beyond_eod) {
		printk(KERN_WARNING
		       "%s: partition table partially beyond EOD, ",
		       disk->disk_name);
		if (disk_unlock_native_capacity(disk))
			goto rescan;
	}
628 629

	/* tell userspace that the media / partition table may have changed */
630
	kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
631

T
Tejun Heo 已提交
632 633 634 635 636 637 638 639 640 641 642
	/* Detect the highest partition number and preallocate
	 * disk->part_tbl.  This is an optimization and not strictly
	 * necessary.
	 */
	for (p = 1, highest = 0; p < state->limit; p++)
		if (state->parts[p].size)
			highest = p;

	disk_expand_part_tbl(disk, highest);

	/* add partitions */
L
Linus Torvalds 已提交
643
	for (p = 1; p < state->limit; p++) {
644
		sector_t size, from;
645

646
		size = state->parts[p].size;
L
Linus Torvalds 已提交
647 648
		if (!size)
			continue;
649 650

		from = state->parts[p].from;
651 652
		if (from >= get_capacity(disk)) {
			printk(KERN_WARNING
653
			       "%s: p%d start %llu is beyond EOD, ",
654
			       disk->disk_name, p, (unsigned long long) from);
655 656
			if (disk_unlock_native_capacity(disk))
				goto rescan;
657 658
			continue;
		}
659

660
		if (from + size > get_capacity(disk)) {
661
			printk(KERN_WARNING
662
			       "%s: p%d size %llu extends beyond EOD, ",
663
			       disk->disk_name, p, (unsigned long long) size);
664

665
			if (disk_unlock_native_capacity(disk)) {
666 667
				/* free state and restart */
				goto rescan;
668 669 670 671 672 673 674 675 676
			} else {
				/*
				 * we can not ignore partitions of broken tables
				 * created by for example camera firmware, but
				 * we limit them to the end of the disk to avoid
				 * creating invalid block devices
				 */
				size = get_capacity(disk) - from;
			}
677
		}
678 679 680 681 682
		part = add_partition(disk, p, from, size,
				     state->parts[p].flags);
		if (IS_ERR(part)) {
			printk(KERN_ERR " %s: p%d could not be added: %ld\n",
			       disk->disk_name, p, -PTR_ERR(part));
683
			continue;
684
		}
L
Linus Torvalds 已提交
685
#ifdef CONFIG_BLK_DEV_MD
686
		if (state->parts[p].flags & ADDPART_FLAG_RAID)
T
Tejun Heo 已提交
687
			md_autodetect_dev(part_to_dev(part)->devt);
L
Linus Torvalds 已提交
688 689 690 691 692 693 694 695 696 697 698
#endif
	}
	kfree(state);
	return 0;
}

unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
{
	struct address_space *mapping = bdev->bd_inode->i_mapping;
	struct page *page;

699 700
	page = read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
				 NULL);
L
Linus Torvalds 已提交
701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
	if (!IS_ERR(page)) {
		if (PageError(page))
			goto fail;
		p->v = page;
		return (unsigned char *)page_address(page) +  ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9);
fail:
		page_cache_release(page);
	}
	p->v = NULL;
	return NULL;
}

EXPORT_SYMBOL(read_dev_sector);

void del_gendisk(struct gendisk *disk)
{
717 718
	struct disk_part_iter piter;
	struct hd_struct *part;
L
Linus Torvalds 已提交
719 720

	/* invalidate stuff */
721 722 723 724 725
	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);
L
Linus Torvalds 已提交
726
	}
727 728
	disk_part_iter_exit(&piter);

L
Linus Torvalds 已提交
729
	invalidate_partition(disk, 0);
730
	blk_free_devt(disk_to_dev(disk)->devt);
731
	set_capacity(disk, 0);
L
Linus Torvalds 已提交
732 733
	disk->flags &= ~GENHD_FL_UP;
	unlink_gendisk(disk);
T
Tejun Heo 已提交
734 735
	part_stat_set_all(&disk->part0, 0);
	disk->part0.stamp = 0;
L
Linus Torvalds 已提交
736

737
	kobject_put(disk->part0.holder_dir);
738
	kobject_put(disk->slave_dir);
739 740
	disk->driverfs_dev = NULL;
#ifndef CONFIG_SYSFS_DEPRECATED
741
	sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
742
#endif
743
	device_del(disk_to_dev(disk));
L
Linus Torvalds 已提交
744
}