1/* 2 * gendisk handling 3 */ 4 5#include <linux/module.h> 6#include <linux/fs.h> 7#include <linux/genhd.h> 8#include <linux/kdev_t.h> 9#include <linux/kernel.h> 10#include <linux/blkdev.h> 11#include <linux/init.h> 12#include <linux/spinlock.h> 13#include <linux/seq_file.h> 14#include <linux/slab.h> 15#include <linux/kmod.h> 16#include <linux/kobj_map.h> 17#include <linux/buffer_head.h> 18#include <linux/mutex.h> 19 20struct kset block_subsys; 21static DEFINE_MUTEX(block_subsys_lock); 22 23/* 24 * Can be deleted altogether. Later. 25 * 26 */ 27static struct blk_major_name { 28 struct blk_major_name *next; 29 int major; 30 char name[16]; 31} *major_names[BLKDEV_MAJOR_HASH_SIZE]; 32 33/* index in the above - for now: assume no multimajor ranges */ 34static inline int major_to_index(int major) 35{ 36 return major % BLKDEV_MAJOR_HASH_SIZE; 37} 38 39#ifdef CONFIG_PROC_FS 40 41void blkdev_show(struct seq_file *f, off_t offset) 42{ 43 struct blk_major_name *dp; 44 45 if (offset < BLKDEV_MAJOR_HASH_SIZE) { 46 mutex_lock(&block_subsys_lock); 47 for (dp = major_names[offset]; dp; dp = dp->next) 48 seq_printf(f, "%3d %s\n", dp->major, dp->name); 49 mutex_unlock(&block_subsys_lock); 50 } 51} 52 53#endif /* CONFIG_PROC_FS */ 54 55int register_blkdev(unsigned int major, const char *name) 56{ 57 struct blk_major_name **n, *p; 58 int index, ret = 0; 59 60 mutex_lock(&block_subsys_lock); 61 62 /* temporary */ 63 if (major == 0) { 64 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) { 65 if (major_names[index] == NULL) 66 break; 67 } 68 69 if (index == 0) { 70 printk("register_blkdev: failed to get major for %s\n", 71 name); 72 ret = -EBUSY; 73 goto out; 74 } 75 major = index; 76 ret = major; 77 } 78 79 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL); 80 if (p == NULL) { 81 ret = -ENOMEM; 82 goto out; 83 } 84 85 p->major = major; 86 strlcpy(p->name, name, sizeof(p->name)); 87 p->next = NULL; 88 index = major_to_index(major); 89 90 for (n = &major_names[index]; *n; n = &(*n)->next) { 91 if ((*n)->major == major) 92 break; 93 } 94 if (!*n) 95 *n = p; 96 else 97 ret = -EBUSY; 98 99 if (ret < 0) { 100 printk("register_blkdev: cannot get major %d for %s\n", 101 major, name); 102 kfree(p); 103 } 104out: 105 mutex_unlock(&block_subsys_lock); 106 return ret; 107} 108 109EXPORT_SYMBOL(register_blkdev); 110 111/* todo: make void - error printk here */ 112int unregister_blkdev(unsigned int major, const char *name) 113{ 114 struct blk_major_name **n; 115 struct blk_major_name *p = NULL; 116 int index = major_to_index(major); 117 int ret = 0; 118 119 mutex_lock(&block_subsys_lock); 120 for (n = &major_names[index]; *n; n = &(*n)->next) 121 if ((*n)->major == major) 122 break; 123 if (!*n || strcmp((*n)->name, name)) 124 ret = -EINVAL; 125 else { 126 p = *n; 127 *n = p->next; 128 } 129 mutex_unlock(&block_subsys_lock); 130 kfree(p); 131 132 return ret; 133} 134 135EXPORT_SYMBOL(unregister_blkdev); 136 137static struct kobj_map *bdev_map; 138 139/* 140 * Register device numbers dev..(dev+range-1) 141 * range must be nonzero 142 * The hash chain is sorted on range, so that subranges can override. 143 */ 144void blk_register_region(dev_t dev, unsigned long range, struct module *module, 145 struct kobject *(*probe)(dev_t, int *, void *), 146 int (*lock)(dev_t, void *), void *data) 147{ 148 kobj_map(bdev_map, dev, range, module, probe, lock, data); 149} 150 151EXPORT_SYMBOL(blk_register_region); 152 153void blk_unregister_region(dev_t dev, unsigned long range) 154{ 155 kobj_unmap(bdev_map, dev, range); 156} 157 158EXPORT_SYMBOL(blk_unregister_region); 159 160static struct kobject *exact_match(dev_t dev, int *part, void *data) 161{ 162 struct gendisk *p = data; 163 return &p->kobj; 164} 165 166static int exact_lock(dev_t dev, void *data) 167{ 168 struct gendisk *p = data; 169 170 if (!get_disk(p)) 171 return -1; 172 return 0; 173} 174 175/** 176 * add_disk - add partitioning information to kernel list 177 * @disk: per-device partitioning information 178 * 179 * This function registers the partitioning information in @disk 180 * with the kernel. 181 */ 182void add_disk(struct gendisk *disk) 183{ 184 disk->flags |= GENHD_FL_UP; 185 blk_register_region(MKDEV(disk->major, disk->first_minor), 186 disk->minors, NULL, exact_match, exact_lock, disk); 187 register_disk(disk); 188 blk_register_queue(disk); 189} 190 191EXPORT_SYMBOL(add_disk); 192EXPORT_SYMBOL(del_gendisk); /* in partitions/check.c */ 193 194void unlink_gendisk(struct gendisk *disk) 195{ 196 blk_unregister_queue(disk); 197 blk_unregister_region(MKDEV(disk->major, disk->first_minor), 198 disk->minors); 199} 200 201#define to_disk(obj) container_of(obj,struct gendisk,kobj) 202 203/** 204 * get_gendisk - get partitioning information for a given device 205 * @dev: device to get partitioning information for 206 * 207 * This function gets the structure containing partitioning 208 * information for the given device @dev. 209 */ 210struct gendisk *get_gendisk(dev_t dev, int *part) 211{ 212 struct kobject *kobj = kobj_lookup(bdev_map, dev, part); 213 return kobj ? to_disk(kobj) : NULL; 214} 215 216/* 217 * print a full list of all partitions - intended for places where the root 218 * filesystem can't be mounted and thus to give the victim some idea of what 219 * went wrong 220 */ 221void __init printk_all_partitions(void) 222{ 223 int n; 224 struct gendisk *sgp; 225 226 mutex_lock(&block_subsys_lock); 227 /* For each block device... */ 228 list_for_each_entry(sgp, &block_subsys.list, kobj.entry) { 229 char buf[BDEVNAME_SIZE]; 230 /* 231 * Don't show empty devices or things that have been surpressed 232 */ 233 if (get_capacity(sgp) == 0 || 234 (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)) 235 continue; 236 237 /* 238 * Note, unlike /proc/partitions, I am showing the numbers in 239 * hex - the same format as the root= option takes. 240 */ 241 printk("%02x%02x %10llu %s", 242 sgp->major, sgp->first_minor, 243 (unsigned long long)get_capacity(sgp) >> 1, 244 disk_name(sgp, 0, buf)); 245 if (sgp->driverfs_dev != NULL && 246 sgp->driverfs_dev->driver != NULL) 247 printk(" driver: %s\n", 248 sgp->driverfs_dev->driver->name); 249 else 250 printk(" (driver?)\n"); 251 252 /* now show the partitions */ 253 for (n = 0; n < sgp->minors - 1; ++n) { 254 if (sgp->part[n] == NULL) 255 continue; 256 if (sgp->part[n]->nr_sects == 0) 257 continue; 258 printk(" %02x%02x %10llu %s\n", 259 sgp->major, n + 1 + sgp->first_minor, 260 (unsigned long long)sgp->part[n]->nr_sects >> 1, 261 disk_name(sgp, n + 1, buf)); 262 } /* partition subloop */ 263 } /* Block device loop */ 264 265 mutex_unlock(&block_subsys_lock); 266 return; 267} 268 269#ifdef CONFIG_PROC_FS 270/* iterator */ 271static void *part_start(struct seq_file *part, loff_t *pos) 272{ 273 struct list_head *p; 274 loff_t l = *pos; 275 276 mutex_lock(&block_subsys_lock); 277 list_for_each(p, &block_subsys.list) 278 if (!l--) 279 return list_entry(p, struct gendisk, kobj.entry); 280 return NULL; 281} 282 283static void *part_next(struct seq_file *part, void *v, loff_t *pos) 284{ 285 struct list_head *p = ((struct gendisk *)v)->kobj.entry.next; 286 ++*pos; 287 return p==&block_subsys.list ? NULL : 288 list_entry(p, struct gendisk, kobj.entry); 289} 290 291static void part_stop(struct seq_file *part, void *v) 292{ 293 mutex_unlock(&block_subsys_lock); 294} 295 296static int show_partition(struct seq_file *part, void *v) 297{ 298 struct gendisk *sgp = v; 299 int n; 300 char buf[BDEVNAME_SIZE]; 301 302 if (&sgp->kobj.entry == block_subsys.list.next) 303 seq_puts(part, "major minor #blocks name\n\n"); 304 305 /* Don't show non-partitionable removeable devices or empty devices */ 306 if (!get_capacity(sgp) || 307 (sgp->minors == 1 && (sgp->flags & GENHD_FL_REMOVABLE))) 308 return 0; 309 if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO) 310 return 0; 311 312 /* show the full disk and all non-0 size partitions of it */ 313 seq_printf(part, "%4d %4d %10llu %s\n", 314 sgp->major, sgp->first_minor, 315 (unsigned long long)get_capacity(sgp) >> 1, 316 disk_name(sgp, 0, buf)); 317 for (n = 0; n < sgp->minors - 1; n++) { 318 if (!sgp->part[n]) 319 continue; 320 if (sgp->part[n]->nr_sects == 0) 321 continue; 322 seq_printf(part, "%4d %4d %10llu %s\n", 323 sgp->major, n + 1 + sgp->first_minor, 324 (unsigned long long)sgp->part[n]->nr_sects >> 1 , 325 disk_name(sgp, n + 1, buf)); 326 } 327 328 return 0; 329} 330 331struct seq_operations partitions_op = { 332 .start =part_start, 333 .next = part_next, 334 .stop = part_stop, 335 .show = show_partition 336}; 337#endif 338 339 340extern int blk_dev_init(void); 341 342static struct kobject *base_probe(dev_t dev, int *part, void *data) 343{ 344 if (request_module("block-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0) 345 /* Make old-style 2.4 aliases work */ 346 request_module("block-major-%d", MAJOR(dev)); 347 return NULL; 348} 349 350static int __init genhd_device_init(void) 351{ 352 int err; 353 354 bdev_map = kobj_map_init(base_probe, &block_subsys_lock); 355 blk_dev_init(); 356 err = subsystem_register(&block_subsys); 357 if (err < 0) 358 printk(KERN_WARNING "%s: subsystem_register error: %d\n", 359 __FUNCTION__, err); 360 return err; 361} 362 363subsys_initcall(genhd_device_init); 364 365 366 367/* 368 * kobject & sysfs bindings for block devices 369 */ 370static ssize_t disk_attr_show(struct kobject *kobj, struct attribute *attr, 371 char *page) 372{ 373 struct gendisk *disk = to_disk(kobj); 374 struct disk_attribute *disk_attr = 375 container_of(attr,struct disk_attribute,attr); 376 ssize_t ret = -EIO; 377 378 if (disk_attr->show) 379 ret = disk_attr->show(disk,page); 380 return ret; 381} 382 383static ssize_t disk_attr_store(struct kobject * kobj, struct attribute * attr, 384 const char *page, size_t count) 385{ 386 struct gendisk *disk = to_disk(kobj); 387 struct disk_attribute *disk_attr = 388 container_of(attr,struct disk_attribute,attr); 389 ssize_t ret = 0; 390 391 if (disk_attr->store) 392 ret = disk_attr->store(disk, page, count); 393 return ret; 394} 395 396static struct sysfs_ops disk_sysfs_ops = { 397 .show = &disk_attr_show, 398 .store = &disk_attr_store, 399}; 400 401static ssize_t disk_uevent_store(struct gendisk * disk, 402 const char *buf, size_t count) 403{ 404 kobject_uevent(&disk->kobj, KOBJ_ADD); 405 return count; 406} 407static ssize_t disk_dev_read(struct gendisk * disk, char *page) 408{ 409 dev_t base = MKDEV(disk->major, disk->first_minor); 410 return print_dev_t(page, base); 411} 412static ssize_t disk_range_read(struct gendisk * disk, char *page) 413{ 414 return sprintf(page, "%d\n", disk->minors); 415} 416static ssize_t disk_removable_read(struct gendisk * disk, char *page) 417{ 418 return sprintf(page, "%d\n", 419 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0)); 420 421} 422static ssize_t disk_size_read(struct gendisk * disk, char *page) 423{ 424 return sprintf(page, "%llu\n", (unsigned long long)get_capacity(disk)); 425} 426static ssize_t disk_capability_read(struct gendisk *disk, char *page) 427{ 428 return sprintf(page, "%x\n", disk->flags); 429} 430static ssize_t disk_stats_read(struct gendisk * disk, char *page) 431{ 432 preempt_disable(); 433 disk_round_stats(disk); 434 preempt_enable(); 435 return sprintf(page, 436 "%8lu %8lu %8llu %8u " 437 "%8lu %8lu %8llu %8u " 438 "%8u %8u %8u" 439 "\n", 440 disk_stat_read(disk, ios[READ]), 441 disk_stat_read(disk, merges[READ]), 442 (unsigned long long)disk_stat_read(disk, sectors[READ]), 443 jiffies_to_msecs(disk_stat_read(disk, ticks[READ])), 444 disk_stat_read(disk, ios[WRITE]), 445 disk_stat_read(disk, merges[WRITE]), 446 (unsigned long long)disk_stat_read(disk, sectors[WRITE]), 447 jiffies_to_msecs(disk_stat_read(disk, ticks[WRITE])), 448 disk->in_flight, 449 jiffies_to_msecs(disk_stat_read(disk, io_ticks)), 450 jiffies_to_msecs(disk_stat_read(disk, time_in_queue))); 451} 452static struct disk_attribute disk_attr_uevent = { 453 .attr = {.name = "uevent", .mode = S_IWUSR }, 454 .store = disk_uevent_store 455}; 456static struct disk_attribute disk_attr_dev = { 457 .attr = {.name = "dev", .mode = S_IRUGO }, 458 .show = disk_dev_read 459}; 460static struct disk_attribute disk_attr_range = { 461 .attr = {.name = "range", .mode = S_IRUGO }, 462 .show = disk_range_read 463}; 464static struct disk_attribute disk_attr_removable = { 465 .attr = {.name = "removable", .mode = S_IRUGO }, 466 .show = disk_removable_read 467}; 468static struct disk_attribute disk_attr_size = { 469 .attr = {.name = "size", .mode = S_IRUGO }, 470 .show = disk_size_read 471}; 472static struct disk_attribute disk_attr_capability = { 473 .attr = {.name = "capability", .mode = S_IRUGO }, 474 .show = disk_capability_read 475}; 476static struct disk_attribute disk_attr_stat = { 477 .attr = {.name = "stat", .mode = S_IRUGO }, 478 .show = disk_stats_read 479}; 480 481#ifdef CONFIG_FAIL_MAKE_REQUEST 482 483static ssize_t disk_fail_store(struct gendisk * disk, 484 const char *buf, size_t count) 485{ 486 int i; 487 488 if (count > 0 && sscanf(buf, "%d", &i) > 0) { 489 if (i == 0) 490 disk->flags &= ~GENHD_FL_FAIL; 491 else 492 disk->flags |= GENHD_FL_FAIL; 493 } 494 495 return count; 496} 497static ssize_t disk_fail_read(struct gendisk * disk, char *page) 498{ 499 return sprintf(page, "%d\n", disk->flags & GENHD_FL_FAIL ? 1 : 0); 500} 501static struct disk_attribute disk_attr_fail = { 502 .attr = {.name = "make-it-fail", .mode = S_IRUGO | S_IWUSR }, 503 .store = disk_fail_store, 504 .show = disk_fail_read 505}; 506 507#endif 508 509static struct attribute * default_attrs[] = { 510 &disk_attr_uevent.attr, 511 &disk_attr_dev.attr, 512 &disk_attr_range.attr, 513 &disk_attr_removable.attr, 514 &disk_attr_size.attr, 515 &disk_attr_stat.attr, 516 &disk_attr_capability.attr, 517#ifdef CONFIG_FAIL_MAKE_REQUEST 518 &disk_attr_fail.attr, 519#endif 520 NULL, 521}; 522 523static void disk_release(struct kobject * kobj) 524{ 525 struct gendisk *disk = to_disk(kobj); 526 kfree(disk->random); 527 kfree(disk->part); 528 free_disk_stats(disk); 529 kfree(disk); 530} 531 532static struct kobj_type ktype_block = { 533 .release = disk_release, 534 .sysfs_ops = &disk_sysfs_ops, 535 .default_attrs = default_attrs, 536}; 537 538extern struct kobj_type ktype_part; 539 540static int block_uevent_filter(struct kset *kset, struct kobject *kobj) 541{ 542 struct kobj_type *ktype = get_ktype(kobj); 543 544 return ((ktype == &ktype_block) || (ktype == &ktype_part)); 545} 546 547static int block_uevent(struct kset *kset, struct kobject *kobj, char **envp, 548 int num_envp, char *buffer, int buffer_size) 549{ 550 struct kobj_type *ktype = get_ktype(kobj); 551 struct device *physdev; 552 struct gendisk *disk; 553 struct hd_struct *part; 554 int length = 0; 555 int i = 0; 556 557 if (ktype == &ktype_block) { 558 disk = container_of(kobj, struct gendisk, kobj); 559 add_uevent_var(envp, num_envp, &i, buffer, buffer_size, 560 &length, "MINOR=%u", disk->first_minor); 561 } else if (ktype == &ktype_part) { 562 disk = container_of(kobj->parent, struct gendisk, kobj); 563 part = container_of(kobj, struct hd_struct, kobj); 564 add_uevent_var(envp, num_envp, &i, buffer, buffer_size, 565 &length, "MINOR=%u", 566 disk->first_minor + part->partno); 567 } else 568 return 0; 569 570 add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length, 571 "MAJOR=%u", disk->major); 572 573 /* add physical device, backing this device */ 574 physdev = disk->driverfs_dev; 575 if (physdev) { 576 char *path = kobject_get_path(&physdev->kobj, GFP_KERNEL); 577 578 add_uevent_var(envp, num_envp, &i, buffer, buffer_size, 579 &length, "PHYSDEVPATH=%s", path); 580 kfree(path); 581 582 if (physdev->bus) 583 add_uevent_var(envp, num_envp, &i, 584 buffer, buffer_size, &length, 585 "PHYSDEVBUS=%s", 586 physdev->bus->name); 587 588 if (physdev->driver) 589 add_uevent_var(envp, num_envp, &i, 590 buffer, buffer_size, &length, 591 "PHYSDEVDRIVER=%s", 592 physdev->driver->name); 593 } 594 595 /* terminate, set to next free slot, shrink available space */ 596 envp[i] = NULL; 597 envp = &envp[i]; 598 num_envp -= i; 599 buffer = &buffer[length]; 600 buffer_size -= length; 601 602 return 0; 603} 604 605static struct kset_uevent_ops block_uevent_ops = { 606 .filter = block_uevent_filter, 607 .uevent = block_uevent, 608}; 609 610decl_subsys(block, &ktype_block, &block_uevent_ops); 611 612/* 613 * aggregate disk stat collector. Uses the same stats that the sysfs 614 * entries do, above, but makes them available through one seq_file. 615 * Watching a few disks may be efficient through sysfs, but watching 616 * all of them will be more efficient through this interface. 617 * 618 * The output looks suspiciously like /proc/partitions with a bunch of 619 * extra fields. 620 */ 621 622/* iterator */ 623static void *diskstats_start(struct seq_file *part, loff_t *pos) 624{ 625 loff_t k = *pos; 626 struct list_head *p; 627 628 mutex_lock(&block_subsys_lock); 629 list_for_each(p, &block_subsys.list) 630 if (!k--) 631 return list_entry(p, struct gendisk, kobj.entry); 632 return NULL; 633} 634 635static void *diskstats_next(struct seq_file *part, void *v, loff_t *pos) 636{ 637 struct list_head *p = ((struct gendisk *)v)->kobj.entry.next; 638 ++*pos; 639 return p==&block_subsys.list ? NULL : 640 list_entry(p, struct gendisk, kobj.entry); 641} 642 643static void diskstats_stop(struct seq_file *part, void *v) 644{ 645 mutex_unlock(&block_subsys_lock); 646} 647 648static int diskstats_show(struct seq_file *s, void *v) 649{ 650 struct gendisk *gp = v; 651 char buf[BDEVNAME_SIZE]; 652 int n = 0; 653 654 /* 655 if (&sgp->kobj.entry == block_subsys.kset.list.next) 656 seq_puts(s, "major minor name" 657 " rio rmerge rsect ruse wio wmerge " 658 "wsect wuse running use aveq" 659 "\n\n"); 660 */ 661 662 preempt_disable(); 663 disk_round_stats(gp); 664 preempt_enable(); 665 seq_printf(s, "%4d %4d %s %lu %lu %llu %u %lu %lu %llu %u %u %u %u\n", 666 gp->major, n + gp->first_minor, disk_name(gp, n, buf), 667 disk_stat_read(gp, ios[0]), disk_stat_read(gp, merges[0]), 668 (unsigned long long)disk_stat_read(gp, sectors[0]), 669 jiffies_to_msecs(disk_stat_read(gp, ticks[0])), 670 disk_stat_read(gp, ios[1]), disk_stat_read(gp, merges[1]), 671 (unsigned long long)disk_stat_read(gp, sectors[1]), 672 jiffies_to_msecs(disk_stat_read(gp, ticks[1])), 673 gp->in_flight, 674 jiffies_to_msecs(disk_stat_read(gp, io_ticks)), 675 jiffies_to_msecs(disk_stat_read(gp, time_in_queue))); 676 677 /* now show all non-0 size partitions of it */ 678 for (n = 0; n < gp->minors - 1; n++) { 679 struct hd_struct *hd = gp->part[n]; 680 681 if (hd && hd->nr_sects) 682 seq_printf(s, "%4d %4d %s %u %u %u %u\n", 683 gp->major, n + gp->first_minor + 1, 684 disk_name(gp, n + 1, buf), 685 hd->ios[0], hd->sectors[0], 686 hd->ios[1], hd->sectors[1]); 687 } 688 689 return 0; 690} 691 692struct seq_operations diskstats_op = { 693 .start = diskstats_start, 694 .next = diskstats_next, 695 .stop = diskstats_stop, 696 .show = diskstats_show 697}; 698 699static void media_change_notify_thread(struct work_struct *work) 700{ 701 struct gendisk *gd = container_of(work, struct gendisk, async_notify); 702 char event[] = "MEDIA_CHANGE=1"; 703 char *envp[] = { event, NULL }; 704 705 /* 706 * set enviroment vars to indicate which event this is for 707 * so that user space will know to go check the media status. 708 */ 709 kobject_uevent_env(&gd->kobj, KOBJ_CHANGE, envp); 710 put_device(gd->driverfs_dev); 711} 712 713void genhd_media_change_notify(struct gendisk *disk) 714{ 715 get_device(disk->driverfs_dev); 716 schedule_work(&disk->async_notify); 717} 718EXPORT_SYMBOL_GPL(genhd_media_change_notify); 719 720struct gendisk *alloc_disk(int minors) 721{ 722 return alloc_disk_node(minors, -1); 723} 724 725struct gendisk *alloc_disk_node(int minors, int node_id) 726{ 727 struct gendisk *disk; 728 729 disk = kmalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id); 730 if (disk) { 731 memset(disk, 0, sizeof(struct gendisk)); 732 if (!init_disk_stats(disk)) { 733 kfree(disk); 734 return NULL; 735 } 736 if (minors > 1) { 737 int size = (minors - 1) * sizeof(struct hd_struct *); 738 disk->part = kmalloc_node(size, GFP_KERNEL, node_id); 739 if (!disk->part) { 740 kfree(disk); 741 return NULL; 742 } 743 memset(disk->part, 0, size); 744 } 745 disk->minors = minors; 746 kobj_set_kset_s(disk,block_subsys); 747 kobject_init(&disk->kobj); 748 rand_initialize_disk(disk); 749 INIT_WORK(&disk->async_notify, 750 media_change_notify_thread); 751 } 752 return disk; 753} 754 755EXPORT_SYMBOL(alloc_disk); 756EXPORT_SYMBOL(alloc_disk_node); 757 758struct kobject *get_disk(struct gendisk *disk) 759{ 760 struct module *owner; 761 struct kobject *kobj; 762 763 if (!disk->fops) 764 return NULL; 765 owner = disk->fops->owner; 766 if (owner && !try_module_get(owner)) 767 return NULL; 768 kobj = kobject_get(&disk->kobj); 769 if (kobj == NULL) { 770 module_put(owner); 771 return NULL; 772 } 773 return kobj; 774 775} 776 777EXPORT_SYMBOL(get_disk); 778 779void put_disk(struct gendisk *disk) 780{ 781 if (disk) 782 kobject_put(&disk->kobj); 783} 784 785EXPORT_SYMBOL(put_disk); 786 787void set_device_ro(struct block_device *bdev, int flag) 788{ 789 if (bdev->bd_contains != bdev) 790 bdev->bd_part->policy = flag; 791 else 792 bdev->bd_disk->policy = flag; 793} 794 795EXPORT_SYMBOL(set_device_ro); 796 797void set_disk_ro(struct gendisk *disk, int flag) 798{ 799 int i; 800 disk->policy = flag; 801 for (i = 0; i < disk->minors - 1; i++) 802 if (disk->part[i]) disk->part[i]->policy = flag; 803} 804 805EXPORT_SYMBOL(set_disk_ro); 806 807int bdev_read_only(struct block_device *bdev) 808{ 809 if (!bdev) 810 return 0; 811 else if (bdev->bd_contains != bdev) 812 return bdev->bd_part->policy; 813 else 814 return bdev->bd_disk->policy; 815} 816 817EXPORT_SYMBOL(bdev_read_only); 818 819int invalidate_partition(struct gendisk *disk, int index) 820{ 821 int res = 0; 822 struct block_device *bdev = bdget_disk(disk, index); 823 if (bdev) { 824 fsync_bdev(bdev); 825 res = __invalidate_device(bdev); 826 bdput(bdev); 827 } 828 return res; 829} 830 831EXPORT_SYMBOL(invalidate_partition); 832