1/* 2 * fs/partitions/check.c 3 * 4 * Code extracted from drivers/block/genhd.c 5 * Copyright (C) 1991-1998 Linus Torvalds 6 * Re-organised Feb 1998 Russell King 7 * 8 * We now have independent partition support from the 9 * block drivers, which allows all the partition code to 10 * be grouped in one location, and it to be mostly self 11 * contained. 12 * 13 * Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl} 14 */ 15 16#include <linux/init.h> 17#include <linux/module.h> 18#include <linux/fs.h> 19#include <linux/slab.h> 20#include <linux/kmod.h> 21#include <linux/ctype.h> 22#include <linux/genhd.h> 23#include <linux/blktrace_api.h> 24 25#include "check.h" 26 27#include "acorn.h" 28#include "amiga.h" 29#include "atari.h" 30#include "ldm.h" 31#include "mac.h" 32#include "msdos.h" 33#include "osf.h" 34#include "sgi.h" 35#include "sun.h" 36#include "ibm.h" 37#include "ultrix.h" 38#include "efi.h" 39#include "karma.h" 40#include "sysv68.h" 41 42#ifdef CONFIG_BLK_DEV_MD 43extern void md_autodetect_dev(dev_t dev); 44#endif 45 46int warn_no_part = 1; /*This is ugly: should make genhd removable media aware*/ 47 48static int (*check_part[])(struct parsed_partitions *) = { 49 /* 50 * Probe partition formats with tables at disk address 0 51 * that also have an ADFS boot block at 0xdc0. 52 */ 53#ifdef CONFIG_ACORN_PARTITION_ICS 54 adfspart_check_ICS, 55#endif 56#ifdef CONFIG_ACORN_PARTITION_POWERTEC 57 adfspart_check_POWERTEC, 58#endif 59#ifdef CONFIG_ACORN_PARTITION_EESOX 60 adfspart_check_EESOX, 61#endif 62 63 /* 64 * Now move on to formats that only have partition info at 65 * disk address 0xdc0. Since these may also have stale 66 * PC/BIOS partition tables, they need to come before 67 * the msdos entry. 68 */ 69#ifdef CONFIG_ACORN_PARTITION_CUMANA 70 adfspart_check_CUMANA, 71#endif 72#ifdef CONFIG_ACORN_PARTITION_ADFS 73 adfspart_check_ADFS, 74#endif 75 76#ifdef CONFIG_EFI_PARTITION 77 efi_partition, /* this must come before msdos */ 78#endif 79#ifdef CONFIG_SGI_PARTITION 80 sgi_partition, 81#endif 82#ifdef CONFIG_LDM_PARTITION 83 ldm_partition, /* this must come before msdos */ 84#endif 85#ifdef CONFIG_MSDOS_PARTITION 86 msdos_partition, 87#endif 88#ifdef CONFIG_OSF_PARTITION 89 osf_partition, 90#endif 91#ifdef CONFIG_SUN_PARTITION 92 sun_partition, 93#endif 94#ifdef CONFIG_AMIGA_PARTITION 95 amiga_partition, 96#endif 97#ifdef CONFIG_ATARI_PARTITION 98 atari_partition, 99#endif 100#ifdef CONFIG_MAC_PARTITION 101 mac_partition, 102#endif 103#ifdef CONFIG_ULTRIX_PARTITION 104 ultrix_partition, 105#endif 106#ifdef CONFIG_IBM_PARTITION 107 ibm_partition, 108#endif 109#ifdef CONFIG_KARMA_PARTITION 110 karma_partition, 111#endif 112#ifdef CONFIG_SYSV68_PARTITION 113 sysv68_partition, 114#endif 115 NULL 116}; 117 118/* 119 * disk_name() is used by partition check code and the genhd driver. 120 * It formats the devicename of the indicated disk into 121 * the supplied buffer (of size at least 32), and returns 122 * a pointer to that same buffer (for convenience). 123 */ 124 125char *disk_name(struct gendisk *hd, int partno, char *buf) 126{ 127 if (!partno) 128 snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name); 129 else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) 130 snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, partno); 131 else 132 snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, partno); 133 134 return buf; 135} 136 137const char *bdevname(struct block_device *bdev, char *buf) 138{ 139 return disk_name(bdev->bd_disk, bdev->bd_part->partno, buf); 140} 141 142EXPORT_SYMBOL(bdevname); 143 144/* 145 * There's very little reason to use this, you should really 146 * have a struct block_device just about everywhere and use 147 * bdevname() instead. 148 */ 149const char *__bdevname(dev_t dev, char *buffer) 150{ 151 scnprintf(buffer, BDEVNAME_SIZE, "unknown-block(%u,%u)", 152 MAJOR(dev), MINOR(dev)); 153 return buffer; 154} 155 156EXPORT_SYMBOL(__bdevname); 157 158static struct parsed_partitions * 159check_partition(struct gendisk *hd, struct block_device *bdev) 160{ 161 struct parsed_partitions *state; 162 int i, res, err; 163 164 state = kzalloc(sizeof(struct parsed_partitions), GFP_KERNEL); 165 if (!state) 166 return NULL; 167 state->pp_buf = (char *)__get_free_page(GFP_KERNEL); 168 if (!state->pp_buf) { 169 kfree(state); 170 return NULL; 171 } 172 state->pp_buf[0] = '\0'; 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])) 178 sprintf(state->name, "p"); 179 180 state->limit = disk_max_parts(hd); 181 i = res = err = 0; 182 while (!res && check_part[i]) { 183 memset(&state->parts, 0, sizeof(state->parts)); 184 res = check_part[i++](state); 185 if (res < 0) { 186 /* We have hit an I/O error which we don't report now. 187 * But record it, and let the others do their job. 188 */ 189 err = res; 190 res = 0; 191 } 192 193 } 194 if (res > 0) { 195 printk(KERN_INFO "%s", state->pp_buf); 196 197 free_page((unsigned long)state->pp_buf); 198 return state; 199 } 200 if (state->access_beyond_eod) 201 err = -ENOSPC; 202 if (err) 203 /* The partition is unrecognized. So report I/O errors if there were any */ 204 res = err; 205 if (!res) 206 strlcat(state->pp_buf, " unknown partition table\n", PAGE_SIZE); 207 else if (warn_no_part) 208 strlcat(state->pp_buf, " unable to read partition table\n", PAGE_SIZE); 209 210 printk(KERN_INFO "%s", state->pp_buf); 211 212 free_page((unsigned long)state->pp_buf); 213 kfree(state); 214 return ERR_PTR(res); 215} 216 217static ssize_t part_partition_show(struct device *dev, 218 struct device_attribute *attr, char *buf) 219{ 220 struct hd_struct *p = dev_to_part(dev); 221 222 return sprintf(buf, "%d\n", p->partno); 223} 224 225static ssize_t part_start_show(struct device *dev, 226 struct device_attribute *attr, char *buf) 227{ 228 struct hd_struct *p = dev_to_part(dev); 229 230 return sprintf(buf, "%llu\n",(unsigned long long)p->start_sect); 231} 232 233ssize_t part_size_show(struct device *dev, 234 struct device_attribute *attr, char *buf) 235{ 236 struct hd_struct *p = dev_to_part(dev); 237 return sprintf(buf, "%llu\n",(unsigned long long)p->nr_sects); 238} 239 240ssize_t part_alignment_offset_show(struct device *dev, 241 struct device_attribute *attr, char *buf) 242{ 243 struct hd_struct *p = dev_to_part(dev); 244 return sprintf(buf, "%llu\n", (unsigned long long)p->alignment_offset); 245} 246 247ssize_t part_discard_alignment_show(struct device *dev, 248 struct device_attribute *attr, char *buf) 249{ 250 struct hd_struct *p = dev_to_part(dev); 251 return sprintf(buf, "%u\n", p->discard_alignment); 252} 253 254ssize_t part_stat_show(struct device *dev, 255 struct device_attribute *attr, char *buf) 256{ 257 struct hd_struct *p = dev_to_part(dev); 258 int cpu; 259 260 cpu = part_stat_lock(); 261 part_round_stats(cpu, p); 262 part_stat_unlock(); 263 return sprintf(buf, 264 "%8lu %8lu %8llu %8u " 265 "%8lu %8lu %8llu %8u " 266 "%8u %8u %8u" 267 "\n", 268 part_stat_read(p, ios[READ]), 269 part_stat_read(p, merges[READ]), 270 (unsigned long long)part_stat_read(p, sectors[READ]), 271 jiffies_to_msecs(part_stat_read(p, ticks[READ])), 272 part_stat_read(p, ios[WRITE]), 273 part_stat_read(p, merges[WRITE]), 274 (unsigned long long)part_stat_read(p, sectors[WRITE]), 275 jiffies_to_msecs(part_stat_read(p, ticks[WRITE])), 276 part_in_flight(p), 277 jiffies_to_msecs(part_stat_read(p, io_ticks)), 278 jiffies_to_msecs(part_stat_read(p, time_in_queue))); 279} 280 281ssize_t part_inflight_show(struct device *dev, 282 struct device_attribute *attr, char *buf) 283{ 284 struct hd_struct *p = dev_to_part(dev); 285 286 return sprintf(buf, "%8u %8u\n", p->in_flight[0], p->in_flight[1]); 287} 288 289#ifdef CONFIG_FAIL_MAKE_REQUEST 290ssize_t part_fail_show(struct device *dev, 291 struct device_attribute *attr, char *buf) 292{ 293 struct hd_struct *p = dev_to_part(dev); 294 295 return sprintf(buf, "%d\n", p->make_it_fail); 296} 297 298ssize_t part_fail_store(struct device *dev, 299 struct device_attribute *attr, 300 const char *buf, size_t count) 301{ 302 struct hd_struct *p = dev_to_part(dev); 303 int i; 304 305 if (count > 0 && sscanf(buf, "%d", &i) > 0) 306 p->make_it_fail = (i == 0) ? 0 : 1; 307 308 return count; 309} 310#endif 311 312static DEVICE_ATTR(partition, S_IRUGO, part_partition_show, NULL); 313static DEVICE_ATTR(start, S_IRUGO, part_start_show, NULL); 314static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL); 315static DEVICE_ATTR(alignment_offset, S_IRUGO, part_alignment_offset_show, NULL); 316static DEVICE_ATTR(discard_alignment, S_IRUGO, part_discard_alignment_show, 317 NULL); 318static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL); 319static DEVICE_ATTR(inflight, S_IRUGO, part_inflight_show, NULL); 320#ifdef CONFIG_FAIL_MAKE_REQUEST 321static struct device_attribute dev_attr_fail = 322 __ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store); 323#endif 324 325static struct attribute *part_attrs[] = { 326 &dev_attr_partition.attr, 327 &dev_attr_start.attr, 328 &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 337}; 338 339static struct attribute_group part_attr_group = { 340 .attrs = part_attrs, 341}; 342 343static const struct attribute_group *part_attr_groups[] = { 344 &part_attr_group, 345#ifdef CONFIG_BLK_DEV_IO_TRACE 346 &blk_trace_attr_group, 347#endif 348 NULL 349}; 350 351static void part_release(struct device *dev) 352{ 353 struct hd_struct *p = dev_to_part(dev); 354 free_part_stats(p); 355 kfree(p); 356} 357 358struct device_type part_type = { 359 .name = "partition", 360 .groups = part_attr_groups, 361 .release = part_release, 362}; 363 364static void delete_partition_rcu_cb(struct rcu_head *head) 365{ 366 struct hd_struct *part = container_of(head, struct hd_struct, rcu_head); 367 368 part->start_sect = 0; 369 part->nr_sects = 0; 370 part_stat_set_all(part, 0); 371 put_device(part_to_dev(part)); 372} 373 374void delete_partition(struct gendisk *disk, int partno) 375{ 376 struct disk_part_tbl *ptbl = disk->part_tbl; 377 struct hd_struct *part; 378 379 if (partno >= ptbl->len) 380 return; 381 382 part = ptbl->part[partno]; 383 if (!part) 384 return; 385 386 blk_free_devt(part_devt(part)); 387 rcu_assign_pointer(ptbl->part[partno], NULL); 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); 393} 394 395static ssize_t whole_disk_show(struct device *dev, 396 struct device_attribute *attr, char *buf) 397{ 398 return 0; 399} 400static DEVICE_ATTR(whole_disk, S_IRUSR | S_IRGRP | S_IROTH, 401 whole_disk_show, NULL); 402 403struct hd_struct *add_partition(struct gendisk *disk, int partno, 404 sector_t start, sector_t len, int flags) 405{ 406 struct hd_struct *p; 407 dev_t devt = MKDEV(0, 0); 408 struct device *ddev = disk_to_dev(disk); 409 struct device *pdev; 410 struct disk_part_tbl *ptbl; 411 const char *dname; 412 int err; 413 414 err = disk_expand_part_tbl(disk, partno); 415 if (err) 416 return ERR_PTR(err); 417 ptbl = disk->part_tbl; 418 419 if (ptbl->part[partno]) 420 return ERR_PTR(-EBUSY); 421 422 p = kzalloc(sizeof(*p), GFP_KERNEL); 423 if (!p) 424 return ERR_PTR(-EBUSY); 425 426 if (!init_part_stats(p)) { 427 err = -ENOMEM; 428 goto out_free; 429 } 430 pdev = part_to_dev(p); 431 432 p->start_sect = start; 433 p->alignment_offset = 434 queue_limit_alignment_offset(&disk->queue->limits, start); 435 p->discard_alignment = 436 queue_limit_discard_alignment(&disk->queue->limits, start); 437 p->nr_sects = len; 438 p->partno = partno; 439 p->policy = get_disk_ro(disk); 440 441 dname = dev_name(ddev); 442 if (isdigit(dname[strlen(dname) - 1])) 443 dev_set_name(pdev, "%sp%d", dname, partno); 444 else 445 dev_set_name(pdev, "%s%d", dname, partno); 446 447 device_initialize(pdev); 448 pdev->class = &block_class; 449 pdev->type = &part_type; 450 pdev->parent = ddev; 451 452 err = blk_alloc_devt(p, &devt); 453 if (err) 454 goto out_free_stats; 455 pdev->devt = devt; 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 goto out_put; 462 463 err = -ENOMEM; 464 p->holder_dir = kobject_create_and_add("holders", &pdev->kobj); 465 if (!p->holder_dir) 466 goto out_del; 467 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 } 474 475 /* everything is up and running, commence */ 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 484out_free_stats: 485 free_part_stats(p); 486out_free: 487 kfree(p); 488 return ERR_PTR(err); 489out_del: 490 kobject_put(p->holder_dir); 491 device_del(pdev); 492out_put: 493 put_device(pdev); 494 blk_free_devt(devt); 495 return ERR_PTR(err); 496} 497 498/* Not exported, helper to add_disk(). */ 499void register_disk(struct gendisk *disk) 500{ 501 struct device *ddev = disk_to_dev(disk); 502 struct block_device *bdev; 503 struct disk_part_iter piter; 504 struct hd_struct *part; 505 int err; 506 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)) 515 return; 516#ifndef CONFIG_SYSFS_DEPRECATED 517 err = sysfs_create_link(block_depr, &ddev->kobj, 518 kobject_name(&ddev->kobj)); 519 if (err) { 520 device_del(ddev); 521 return; 522 } 523#endif 524 disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj); 525 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj); 526 527 /* No minors to use for partitions */ 528 if (!disk_partitionable(disk)) 529 goto exit; 530 531 /* No such device (e.g., media were just removed) */ 532 if (!get_capacity(disk)) 533 goto exit; 534 535 bdev = bdget_disk(disk, 0); 536 if (!bdev) 537 goto exit; 538 539 bdev->bd_invalidated = 1; 540 err = blkdev_get(bdev, FMODE_READ); 541 if (err < 0) 542 goto exit; 543 blkdev_put(bdev, FMODE_READ); 544 545exit: 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 disk_part_iter_init(&piter, disk, 0); 552 while ((part = disk_part_iter_next(&piter))) 553 kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD); 554 disk_part_iter_exit(&piter); 555} 556 557static bool disk_unlock_native_capacity(struct gendisk *disk) 558{ 559 const struct block_device_operations *bdops = disk->fops; 560 561 if (bdops->unlock_native_capacity && 562 !(disk->flags & GENHD_FL_NATIVE_CAPACITY)) { 563 printk(KERN_CONT "enabling native capacity\n"); 564 bdops->unlock_native_capacity(disk); 565 disk->flags |= GENHD_FL_NATIVE_CAPACITY; 566 return true; 567 } else { 568 printk(KERN_CONT "truncated\n"); 569 return false; 570 } 571} 572 573int rescan_partitions(struct gendisk *disk, struct block_device *bdev) 574{ 575 struct parsed_partitions *state = NULL; 576 struct disk_part_iter piter; 577 struct hd_struct *part; 578 int p, highest, res; 579rescan: 580 if (state && !IS_ERR(state)) { 581 kfree(state); 582 state = NULL; 583 } 584 585 if (bdev->bd_part_count) 586 return -EBUSY; 587 res = invalidate_partition(disk, 0); 588 if (res) 589 return res; 590 591 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY); 592 while ((part = disk_part_iter_next(&piter))) 593 delete_partition(disk, part->partno); 594 disk_part_iter_exit(&piter); 595 596 if (disk->fops->revalidate_disk) 597 disk->fops->revalidate_disk(disk); 598 check_disk_size_change(disk, bdev); 599 bdev->bd_invalidated = 0; 600 if (!get_capacity(disk) || !(state = check_partition(disk, bdev))) 601 return 0; 602 if (IS_ERR(state)) { 603 /* 604 * I/O error reading the partition table. If any 605 * partition code tried to read beyond EOD, retry 606 * after unlocking native capacity. 607 */ 608 if (PTR_ERR(state) == -ENOSPC) { 609 printk(KERN_WARNING "%s: partition table beyond EOD, ", 610 disk->disk_name); 611 if (disk_unlock_native_capacity(disk)) 612 goto rescan; 613 } 614 return -EIO; 615 } 616 /* 617 * If any partition code tried to read beyond EOD, try 618 * unlocking native capacity even if partition table is 619 * sucessfully read as we could be missing some partitions. 620 */ 621 if (state->access_beyond_eod) { 622 printk(KERN_WARNING 623 "%s: partition table partially beyond EOD, ", 624 disk->disk_name); 625 if (disk_unlock_native_capacity(disk)) 626 goto rescan; 627 } 628 629 /* tell userspace that the media / partition table may have changed */ 630 kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE); 631 632 /* Detect the highest partition number and preallocate 633 * disk->part_tbl. This is an optimization and not strictly 634 * necessary. 635 */ 636 for (p = 1, highest = 0; p < state->limit; p++) 637 if (state->parts[p].size) 638 highest = p; 639 640 disk_expand_part_tbl(disk, highest); 641 642 /* add partitions */ 643 for (p = 1; p < state->limit; p++) { 644 sector_t size, from; 645 646 size = state->parts[p].size; 647 if (!size) 648 continue; 649 650 from = state->parts[p].from; 651 if (from >= get_capacity(disk)) { 652 printk(KERN_WARNING 653 "%s: p%d start %llu is beyond EOD, ", 654 disk->disk_name, p, (unsigned long long) from); 655 if (disk_unlock_native_capacity(disk)) 656 goto rescan; 657 continue; 658 } 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 /* free state and restart */ 667 goto rescan; 668 } else { 669 /* 670 * we can not ignore partitions of broken tables 671 * created by for example camera firmware, but 672 * we limit them to the end of the disk to avoid 673 * creating invalid block devices 674 */ 675 size = get_capacity(disk) - from; 676 } 677 } 678 part = add_partition(disk, p, from, size, 679 state->parts[p].flags); 680 if (IS_ERR(part)) { 681 printk(KERN_ERR " %s: p%d could not be added: %ld\n", 682 disk->disk_name, p, -PTR_ERR(part)); 683 continue; 684 } 685#ifdef CONFIG_BLK_DEV_MD 686 if (state->parts[p].flags & ADDPART_FLAG_RAID) 687 md_autodetect_dev(part_to_dev(part)->devt); 688#endif 689 } 690 kfree(state); 691 return 0; 692} 693 694unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p) 695{ 696 struct address_space *mapping = bdev->bd_inode->i_mapping; 697 struct page *page; 698 699 page = read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)), 700 NULL); 701 if (!IS_ERR(page)) { 702 if (PageError(page)) 703 goto fail; 704 p->v = page; 705 return (unsigned char *)page_address(page) + ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9); 706fail: 707 page_cache_release(page); 708 } 709 p->v = NULL; 710 return NULL; 711} 712 713EXPORT_SYMBOL(read_dev_sector); 714 715void del_gendisk(struct gendisk *disk) 716{ 717 struct disk_part_iter piter; 718 struct hd_struct *part; 719 720 /* invalidate stuff */ 721 disk_part_iter_init(&piter, disk, 722 DISK_PITER_INCL_EMPTY | DISK_PITER_REVERSE); 723 while ((part = disk_part_iter_next(&piter))) { 724 invalidate_partition(disk, part->partno); 725 delete_partition(disk, part->partno); 726 } 727 disk_part_iter_exit(&piter); 728 729 invalidate_partition(disk, 0); 730 blk_free_devt(disk_to_dev(disk)->devt); 731 set_capacity(disk, 0); 732 disk->flags &= ~GENHD_FL_UP; 733 unlink_gendisk(disk); 734 part_stat_set_all(&disk->part0, 0); 735 disk->part0.stamp = 0; 736 737 kobject_put(disk->part0.holder_dir); 738 kobject_put(disk->slave_dir); 739 disk->driverfs_dev = NULL; 740#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)); 744} 745