check.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619
  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. #include <linux/init.h>
  16. #include <linux/module.h>
  17. #include <linux/fs.h>
  18. #include <linux/kmod.h>
  19. #include <linux/ctype.h>
  20. #include "check.h"
  21. #include "acorn.h"
  22. #include "amiga.h"
  23. #include "atari.h"
  24. #include "ldm.h"
  25. #include "mac.h"
  26. #include "msdos.h"
  27. #include "osf.h"
  28. #include "sgi.h"
  29. #include "sun.h"
  30. #include "ibm.h"
  31. #include "ultrix.h"
  32. #include "efi.h"
  33. #include "karma.h"
  34. #ifdef CONFIG_BLK_DEV_MD
  35. extern void md_autodetect_dev(dev_t dev);
  36. #endif
  37. int warn_no_part = 1; /*This is ugly: should make genhd removable media aware*/
  38. static int (*check_part[])(struct parsed_partitions *, struct block_device *) = {
  39. /*
  40. * Probe partition formats with tables at disk address 0
  41. * that also have an ADFS boot block at 0xdc0.
  42. */
  43. #ifdef CONFIG_ACORN_PARTITION_ICS
  44. adfspart_check_ICS,
  45. #endif
  46. #ifdef CONFIG_ACORN_PARTITION_POWERTEC
  47. adfspart_check_POWERTEC,
  48. #endif
  49. #ifdef CONFIG_ACORN_PARTITION_EESOX
  50. adfspart_check_EESOX,
  51. #endif
  52. /*
  53. * Now move on to formats that only have partition info at
  54. * disk address 0xdc0. Since these may also have stale
  55. * PC/BIOS partition tables, they need to come before
  56. * the msdos entry.
  57. */
  58. #ifdef CONFIG_ACORN_PARTITION_CUMANA
  59. adfspart_check_CUMANA,
  60. #endif
  61. #ifdef CONFIG_ACORN_PARTITION_ADFS
  62. adfspart_check_ADFS,
  63. #endif
  64. #ifdef CONFIG_EFI_PARTITION
  65. efi_partition, /* this must come before msdos */
  66. #endif
  67. #ifdef CONFIG_SGI_PARTITION
  68. sgi_partition,
  69. #endif
  70. #ifdef CONFIG_LDM_PARTITION
  71. ldm_partition, /* this must come before msdos */
  72. #endif
  73. #ifdef CONFIG_MSDOS_PARTITION
  74. msdos_partition,
  75. #endif
  76. #ifdef CONFIG_OSF_PARTITION
  77. osf_partition,
  78. #endif
  79. #ifdef CONFIG_SUN_PARTITION
  80. sun_partition,
  81. #endif
  82. #ifdef CONFIG_AMIGA_PARTITION
  83. amiga_partition,
  84. #endif
  85. #ifdef CONFIG_ATARI_PARTITION
  86. atari_partition,
  87. #endif
  88. #ifdef CONFIG_MAC_PARTITION
  89. mac_partition,
  90. #endif
  91. #ifdef CONFIG_ULTRIX_PARTITION
  92. ultrix_partition,
  93. #endif
  94. #ifdef CONFIG_IBM_PARTITION
  95. ibm_partition,
  96. #endif
  97. #ifdef CONFIG_KARMA_PARTITION
  98. karma_partition,
  99. #endif
  100. NULL
  101. };
  102. /*
  103. * disk_name() is used by partition check code and the genhd driver.
  104. * It formats the devicename of the indicated disk into
  105. * the supplied buffer (of size at least 32), and returns
  106. * a pointer to that same buffer (for convenience).
  107. */
  108. char *disk_name(struct gendisk *hd, int part, char *buf)
  109. {
  110. if (!part)
  111. snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
  112. else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
  113. snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, part);
  114. else
  115. snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, part);
  116. return buf;
  117. }
  118. const char *bdevname(struct block_device *bdev, char *buf)
  119. {
  120. int part = MINOR(bdev->bd_dev) - bdev->bd_disk->first_minor;
  121. return disk_name(bdev->bd_disk, part, buf);
  122. }
  123. EXPORT_SYMBOL(bdevname);
  124. /*
  125. * There's very little reason to use this, you should really
  126. * have a struct block_device just about everywhere and use
  127. * bdevname() instead.
  128. */
  129. const char *__bdevname(dev_t dev, char *buffer)
  130. {
  131. scnprintf(buffer, BDEVNAME_SIZE, "unknown-block(%u,%u)",
  132. MAJOR(dev), MINOR(dev));
  133. return buffer;
  134. }
  135. EXPORT_SYMBOL(__bdevname);
  136. static struct parsed_partitions *
  137. check_partition(struct gendisk *hd, struct block_device *bdev)
  138. {
  139. struct parsed_partitions *state;
  140. int i, res, err;
  141. state = kmalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
  142. if (!state)
  143. return NULL;
  144. disk_name(hd, 0, state->name);
  145. printk(KERN_INFO " %s:", state->name);
  146. if (isdigit(state->name[strlen(state->name)-1]))
  147. sprintf(state->name, "p");
  148. state->limit = hd->minors;
  149. i = res = err = 0;
  150. while (!res && check_part[i]) {
  151. memset(&state->parts, 0, sizeof(state->parts));
  152. res = check_part[i++](state, bdev);
  153. if (res < 0) {
  154. /* We have hit an I/O error which we don't report now.
  155. * But record it, and let the others do their job.
  156. */
  157. err = res;
  158. res = 0;
  159. }
  160. }
  161. if (res > 0)
  162. return state;
  163. if (err)
  164. /* The partition is unrecognized. So report I/O errors if there were any */
  165. res = err;
  166. if (!res)
  167. printk(" unknown partition table\n");
  168. else if (warn_no_part)
  169. printk(" unable to read partition table\n");
  170. kfree(state);
  171. return ERR_PTR(res);
  172. }
  173. /*
  174. * sysfs bindings for partitions
  175. */
  176. struct part_attribute {
  177. struct attribute attr;
  178. ssize_t (*show)(struct hd_struct *,char *);
  179. ssize_t (*store)(struct hd_struct *,const char *, size_t);
  180. };
  181. static ssize_t
  182. part_attr_show(struct kobject * kobj, struct attribute * attr, char * page)
  183. {
  184. struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
  185. struct part_attribute * part_attr = container_of(attr,struct part_attribute,attr);
  186. ssize_t ret = 0;
  187. if (part_attr->show)
  188. ret = part_attr->show(p, page);
  189. return ret;
  190. }
  191. static ssize_t
  192. part_attr_store(struct kobject * kobj, struct attribute * attr,
  193. const char *page, size_t count)
  194. {
  195. struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
  196. struct part_attribute * part_attr = container_of(attr,struct part_attribute,attr);
  197. ssize_t ret = 0;
  198. if (part_attr->store)
  199. ret = part_attr->store(p, page, count);
  200. return ret;
  201. }
  202. static struct sysfs_ops part_sysfs_ops = {
  203. .show = part_attr_show,
  204. .store = part_attr_store,
  205. };
  206. static ssize_t part_uevent_store(struct hd_struct * p,
  207. const char *page, size_t count)
  208. {
  209. kobject_uevent(&p->kobj, KOBJ_ADD);
  210. return count;
  211. }
  212. static ssize_t part_dev_read(struct hd_struct * p, char *page)
  213. {
  214. struct gendisk *disk = container_of(p->kobj.parent,struct gendisk,kobj);
  215. dev_t dev = MKDEV(disk->major, disk->first_minor + p->partno);
  216. return print_dev_t(page, dev);
  217. }
  218. static ssize_t part_start_read(struct hd_struct * p, char *page)
  219. {
  220. return sprintf(page, "%llu\n",(unsigned long long)p->start_sect);
  221. }
  222. static ssize_t part_size_read(struct hd_struct * p, char *page)
  223. {
  224. return sprintf(page, "%llu\n",(unsigned long long)p->nr_sects);
  225. }
  226. static ssize_t part_stat_read(struct hd_struct * p, char *page)
  227. {
  228. return sprintf(page, "%8u %8llu %8u %8llu\n",
  229. p->ios[0], (unsigned long long)p->sectors[0],
  230. p->ios[1], (unsigned long long)p->sectors[1]);
  231. }
  232. static struct part_attribute part_attr_uevent = {
  233. .attr = {.name = "uevent", .mode = S_IWUSR },
  234. .store = part_uevent_store
  235. };
  236. static struct part_attribute part_attr_dev = {
  237. .attr = {.name = "dev", .mode = S_IRUGO },
  238. .show = part_dev_read
  239. };
  240. static struct part_attribute part_attr_start = {
  241. .attr = {.name = "start", .mode = S_IRUGO },
  242. .show = part_start_read
  243. };
  244. static struct part_attribute part_attr_size = {
  245. .attr = {.name = "size", .mode = S_IRUGO },
  246. .show = part_size_read
  247. };
  248. static struct part_attribute part_attr_stat = {
  249. .attr = {.name = "stat", .mode = S_IRUGO },
  250. .show = part_stat_read
  251. };
  252. #ifdef CONFIG_FAIL_MAKE_REQUEST
  253. static ssize_t part_fail_store(struct hd_struct * p,
  254. const char *buf, size_t count)
  255. {
  256. int i;
  257. if (count > 0 && sscanf(buf, "%d", &i) > 0)
  258. p->make_it_fail = (i == 0) ? 0 : 1;
  259. return count;
  260. }
  261. static ssize_t part_fail_read(struct hd_struct * p, char *page)
  262. {
  263. return sprintf(page, "%d\n", p->make_it_fail);
  264. }
  265. static struct part_attribute part_attr_fail = {
  266. .attr = {.name = "make-it-fail", .mode = S_IRUGO | S_IWUSR },
  267. .store = part_fail_store,
  268. .show = part_fail_read
  269. };
  270. #endif
  271. static struct attribute * default_attrs[] = {
  272. &part_attr_uevent.attr,
  273. &part_attr_dev.attr,
  274. &part_attr_start.attr,
  275. &part_attr_size.attr,
  276. &part_attr_stat.attr,
  277. #ifdef CONFIG_FAIL_MAKE_REQUEST
  278. &part_attr_fail.attr,
  279. #endif
  280. NULL,
  281. };
  282. extern struct subsystem block_subsys;
  283. static void part_release(struct kobject *kobj)
  284. {
  285. struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
  286. kfree(p);
  287. }
  288. struct kobj_type ktype_part = {
  289. .release = part_release,
  290. .default_attrs = default_attrs,
  291. .sysfs_ops = &part_sysfs_ops,
  292. };
  293. static inline void partition_sysfs_add_subdir(struct hd_struct *p)
  294. {
  295. struct kobject *k;
  296. k = kobject_get(&p->kobj);
  297. p->holder_dir = kobject_add_dir(k, "holders");
  298. kobject_put(k);
  299. }
  300. static inline void disk_sysfs_add_subdirs(struct gendisk *disk)
  301. {
  302. struct kobject *k;
  303. k = kobject_get(&disk->kobj);
  304. disk->holder_dir = kobject_add_dir(k, "holders");
  305. disk->slave_dir = kobject_add_dir(k, "slaves");
  306. kobject_put(k);
  307. }
  308. void delete_partition(struct gendisk *disk, int part)
  309. {
  310. struct hd_struct *p = disk->part[part-1];
  311. if (!p)
  312. return;
  313. if (!p->nr_sects)
  314. return;
  315. disk->part[part-1] = NULL;
  316. p->start_sect = 0;
  317. p->nr_sects = 0;
  318. p->ios[0] = p->ios[1] = 0;
  319. p->sectors[0] = p->sectors[1] = 0;
  320. sysfs_remove_link(&p->kobj, "subsystem");
  321. kobject_unregister(p->holder_dir);
  322. kobject_uevent(&p->kobj, KOBJ_REMOVE);
  323. kobject_del(&p->kobj);
  324. kobject_put(&p->kobj);
  325. }
  326. void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len, int flags)
  327. {
  328. struct hd_struct *p;
  329. p = kmalloc(sizeof(*p), GFP_KERNEL);
  330. if (!p)
  331. return;
  332. memset(p, 0, sizeof(*p));
  333. p->start_sect = start;
  334. p->nr_sects = len;
  335. p->partno = part;
  336. p->policy = disk->policy;
  337. if (isdigit(disk->kobj.name[strlen(disk->kobj.name)-1]))
  338. snprintf(p->kobj.name,KOBJ_NAME_LEN,"%sp%d",disk->kobj.name,part);
  339. else
  340. snprintf(p->kobj.name,KOBJ_NAME_LEN,"%s%d",disk->kobj.name,part);
  341. p->kobj.parent = &disk->kobj;
  342. p->kobj.ktype = &ktype_part;
  343. kobject_init(&p->kobj);
  344. kobject_add(&p->kobj);
  345. if (!disk->part_uevent_suppress)
  346. kobject_uevent(&p->kobj, KOBJ_ADD);
  347. sysfs_create_link(&p->kobj, &block_subsys.kset.kobj, "subsystem");
  348. if (flags & ADDPART_FLAG_WHOLEDISK) {
  349. static struct attribute addpartattr = {
  350. .name = "whole_disk",
  351. .mode = S_IRUSR | S_IRGRP | S_IROTH,
  352. .owner = THIS_MODULE,
  353. };
  354. sysfs_create_file(&p->kobj, &addpartattr);
  355. }
  356. partition_sysfs_add_subdir(p);
  357. disk->part[part-1] = p;
  358. }
  359. static char *make_block_name(struct gendisk *disk)
  360. {
  361. char *name;
  362. static char *block_str = "block:";
  363. int size;
  364. char *s;
  365. size = strlen(block_str) + strlen(disk->disk_name) + 1;
  366. name = kmalloc(size, GFP_KERNEL);
  367. if (!name)
  368. return NULL;
  369. strcpy(name, block_str);
  370. strcat(name, disk->disk_name);
  371. /* ewww... some of these buggers have / in name... */
  372. s = strchr(name, '/');
  373. if (s)
  374. *s = '!';
  375. return name;
  376. }
  377. static int disk_sysfs_symlinks(struct gendisk *disk)
  378. {
  379. struct device *target = get_device(disk->driverfs_dev);
  380. int err;
  381. char *disk_name = NULL;
  382. if (target) {
  383. disk_name = make_block_name(disk);
  384. if (!disk_name) {
  385. err = -ENOMEM;
  386. goto err_out;
  387. }
  388. err = sysfs_create_link(&disk->kobj, &target->kobj, "device");
  389. if (err)
  390. goto err_out_disk_name;
  391. err = sysfs_create_link(&target->kobj, &disk->kobj, disk_name);
  392. if (err)
  393. goto err_out_dev_link;
  394. }
  395. err = sysfs_create_link(&disk->kobj, &block_subsys.kset.kobj,
  396. "subsystem");
  397. if (err)
  398. goto err_out_disk_name_lnk;
  399. kfree(disk_name);
  400. return 0;
  401. err_out_disk_name_lnk:
  402. if (target) {
  403. sysfs_remove_link(&target->kobj, disk_name);
  404. err_out_dev_link:
  405. sysfs_remove_link(&disk->kobj, "device");
  406. err_out_disk_name:
  407. kfree(disk_name);
  408. err_out:
  409. put_device(target);
  410. }
  411. return err;
  412. }
  413. /* Not exported, helper to add_disk(). */
  414. void register_disk(struct gendisk *disk)
  415. {
  416. struct block_device *bdev;
  417. char *s;
  418. int i;
  419. struct hd_struct *p;
  420. int err;
  421. strlcpy(disk->kobj.name,disk->disk_name,KOBJ_NAME_LEN);
  422. /* ewww... some of these buggers have / in name... */
  423. s = strchr(disk->kobj.name, '/');
  424. if (s)
  425. *s = '!';
  426. if ((err = kobject_add(&disk->kobj)))
  427. return;
  428. err = disk_sysfs_symlinks(disk);
  429. if (err) {
  430. kobject_del(&disk->kobj);
  431. return;
  432. }
  433. disk_sysfs_add_subdirs(disk);
  434. /* No minors to use for partitions */
  435. if (disk->minors == 1)
  436. goto exit;
  437. /* No such device (e.g., media were just removed) */
  438. if (!get_capacity(disk))
  439. goto exit;
  440. bdev = bdget_disk(disk, 0);
  441. if (!bdev)
  442. goto exit;
  443. /* scan partition table, but suppress uevents */
  444. bdev->bd_invalidated = 1;
  445. disk->part_uevent_suppress = 1;
  446. err = blkdev_get(bdev, FMODE_READ, 0);
  447. disk->part_uevent_suppress = 0;
  448. if (err < 0)
  449. goto exit;
  450. blkdev_put(bdev);
  451. exit:
  452. /* announce disk after possible partitions are already created */
  453. kobject_uevent(&disk->kobj, KOBJ_ADD);
  454. /* announce possible partitions */
  455. for (i = 1; i < disk->minors; i++) {
  456. p = disk->part[i-1];
  457. if (!p || !p->nr_sects)
  458. continue;
  459. kobject_uevent(&p->kobj, KOBJ_ADD);
  460. }
  461. }
  462. int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
  463. {
  464. struct parsed_partitions *state;
  465. int p, res;
  466. if (bdev->bd_part_count)
  467. return -EBUSY;
  468. res = invalidate_partition(disk, 0);
  469. if (res)
  470. return res;
  471. bdev->bd_invalidated = 0;
  472. for (p = 1; p < disk->minors; p++)
  473. delete_partition(disk, p);
  474. if (disk->fops->revalidate_disk)
  475. disk->fops->revalidate_disk(disk);
  476. if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))
  477. return 0;
  478. if (IS_ERR(state)) /* I/O error reading the partition table */
  479. return -EIO;
  480. for (p = 1; p < state->limit; p++) {
  481. sector_t size = state->parts[p].size;
  482. sector_t from = state->parts[p].from;
  483. if (!size)
  484. continue;
  485. if (from + size > get_capacity(disk)) {
  486. printk(" %s: p%d exceeds device capacity\n",
  487. disk->disk_name, p);
  488. }
  489. add_partition(disk, p, from, size, state->parts[p].flags);
  490. #ifdef CONFIG_BLK_DEV_MD
  491. if (state->parts[p].flags & ADDPART_FLAG_RAID)
  492. md_autodetect_dev(bdev->bd_dev+p);
  493. #endif
  494. }
  495. kfree(state);
  496. return 0;
  497. }
  498. unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
  499. {
  500. struct address_space *mapping = bdev->bd_inode->i_mapping;
  501. struct page *page;
  502. page = read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
  503. NULL);
  504. if (!IS_ERR(page)) {
  505. wait_on_page_locked(page);
  506. if (!PageUptodate(page))
  507. goto fail;
  508. if (PageError(page))
  509. goto fail;
  510. p->v = page;
  511. return (unsigned char *)page_address(page) + ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9);
  512. fail:
  513. page_cache_release(page);
  514. }
  515. p->v = NULL;
  516. return NULL;
  517. }
  518. EXPORT_SYMBOL(read_dev_sector);
  519. void del_gendisk(struct gendisk *disk)
  520. {
  521. int p;
  522. /* invalidate stuff */
  523. for (p = disk->minors - 1; p > 0; p--) {
  524. invalidate_partition(disk, p);
  525. delete_partition(disk, p);
  526. }
  527. invalidate_partition(disk, 0);
  528. disk->capacity = 0;
  529. disk->flags &= ~GENHD_FL_UP;
  530. unlink_gendisk(disk);
  531. disk_stat_set_all(disk, 0);
  532. disk->stamp = 0;
  533. kobject_uevent(&disk->kobj, KOBJ_REMOVE);
  534. kobject_unregister(disk->holder_dir);
  535. kobject_unregister(disk->slave_dir);
  536. if (disk->driverfs_dev) {
  537. char *disk_name = make_block_name(disk);
  538. sysfs_remove_link(&disk->kobj, "device");
  539. if (disk_name) {
  540. sysfs_remove_link(&disk->driverfs_dev->kobj, disk_name);
  541. kfree(disk_name);
  542. }
  543. put_device(disk->driverfs_dev);
  544. disk->driverfs_dev = NULL;
  545. }
  546. sysfs_remove_link(&disk->kobj, "subsystem");
  547. kobject_del(&disk->kobj);
  548. }