genhd.c 17 KB

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