开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
msdos.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：17k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

msdos.c：源码内容
  1. /*
  2.  *  fs/partitions/msdos.c
  3.  *
  4.  *  Code extracted from drivers/block/genhd.c
  5.  *  Copyright (C) 1991-1998  Linus Torvalds
  6.  *
  7.  *  Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
  8.  *  in the early extended-partition checks and added DM partitions
  9.  *
  10.  *  Support for DiskManager v6.0x added by Mark Lord,
  11.  *  with information provided by OnTrack.  This now works for linux fdisk
  12.  *  and LILO, as well as loadlin and bootln.  Note that disks other than
  13.  *  /dev/hda *must* have a "DOS" type 0x51 partition in the first slot (hda1).
  14.  *
  15.  *  More flexible handling of extended partitions - aeb, 950831
  16.  *
  17.  *  Check partition table on IDE disks for common CHS translations
  18.  *
  19.  *  Re-organised Feb 1998 Russell King
  20.  */
  22. #include <linux/config.h>
  23. #include <linux/fs.h>
  24. #include <linux/genhd.h>
  25. #include <linux/kernel.h>
  26. #include <linux/major.h>
  27. #include <linux/string.h>
  28. #include <linux/blk.h>
  30. #ifdef CONFIG_BLK_DEV_IDE
  31. #include <linux/ide.h> /* IDE xlate */
  32. #endif /* CONFIG_BLK_DEV_IDE */
  34. #include <asm/system.h>
  36. #include "check.h"
  37. #include "msdos.h"
  39. #if CONFIG_BLK_DEV_MD
  40. extern void md_autodetect_dev(kdev_t dev);
  41. #endif
  43. /*
  44.  * Many architectures don't like unaligned accesses, which is
  45.  * frequently the case with the nr_sects and start_sect partition
  46.  * table entries.
  47.  */
  48. #include <asm/unaligned.h>
  50. #define SYS_IND(p) (get_unaligned(&p->sys_ind))
  51. #define NR_SECTS(p) ({ __typeof__(p->nr_sects) __a =
  52. get_unaligned(&p->nr_sects);
  53. le32_to_cpu(__a); 
  54. })
  56. #define START_SECT(p) ({ __typeof__(p->start_sect) __a =
  57. get_unaligned(&p->start_sect);
  58. le32_to_cpu(__a); 
  59. })
  61. static inline int is_extended_partition(struct partition *p)
  62. {
  63. return (SYS_IND(p) == DOS_EXTENDED_PARTITION ||
  64. SYS_IND(p) == WIN98_EXTENDED_PARTITION ||
  65. SYS_IND(p) == LINUX_EXTENDED_PARTITION);
  66. }
  68. /*
  69.  * partition_name() formats the short partition name into the supplied
  70.  * buffer, and returns a pointer to that buffer.
  71.  * Used by several partition types which makes conditional inclusion messy,
  72.  * use __attribute__ ((unused)) instead.
  73.  */
  74. static char __attribute__ ((unused))
  75. *partition_name (struct gendisk *hd, int minor, char *buf)
  76. {
  77. #ifdef CONFIG_DEVFS_FS
  78. sprintf(buf, "p%d", (minor & ((1 << hd->minor_shift) - 1)));
  79. return buf;
  80. #else
  81. return disk_name(hd, minor, buf);
  82. #endif
  83. }
  85. #define MSDOS_LABEL_MAGIC1 0x55
  86. #define MSDOS_LABEL_MAGIC2 0xAA
  88. static inline int
  89. msdos_magic_present(unsigned char *p)
  90. {
  91. return (p[0] == MSDOS_LABEL_MAGIC1 && p[1] == MSDOS_LABEL_MAGIC2);
  92. }
  94. /*
  95.  * Create devices for each logical partition in an extended partition.
  96.  * The logical partitions form a linked list, with each entry being
  97.  * a partition table with two entries.  The first entry
  98.  * is the real data partition (with a start relative to the partition
  99.  * table start).  The second is a pointer to the next logical partition
  100.  * (with a start relative to the entire extended partition).
  101.  * We do not create a Linux partition for the partition tables, but
  102.  * only for the actual data partitions.
  103.  */
  105. static void extended_partition(struct gendisk *hd, struct block_device *bdev,
  106. int minor, unsigned long first_size, int *current_minor)
  107. {
  108. struct partition *p;
  109. Sector sect;
  110. unsigned char *data;
  111. unsigned long first_sector, this_sector, this_size;
  112. int mask = (1 << hd->minor_shift) - 1;
  113. int sector_size = get_hardsect_size(to_kdev_t(bdev->bd_dev)) / 512;
  114. int loopct = 0; /* number of links followed
  115.    without finding a data partition */
  116. int i;
  118. this_sector = first_sector = hd->part[minor].start_sect;
  119. this_size = first_size;
  121. while (1) {
  122. if (++loopct > 100)
  123. return;
  124. if ((*current_minor & mask) == 0)
  125. return;
  126. data = read_dev_sector(bdev, this_sector, &sect);
  127. if (!data)
  128. return;
  130. if (!msdos_magic_present(data + 510))
  131. goto done; 
  133. p = (struct partition *) (data + 0x1be);
  135. /*
  136.  * Usually, the first entry is the real data partition,
  137.  * the 2nd entry is the next extended partition, or empty,
  138.  * and the 3rd and 4th entries are unused.
  139.  * However, DRDOS sometimes has the extended partition as
  140.  * the first entry (when the data partition is empty),
  141.  * and OS/2 seems to use all four entries.
  142.  */
  144. /* 
  145.  * First process the data partition(s)
  146.  */
  147. for (i=0; i<4; i++, p++) {
  148. unsigned long offs, size, next;
  149. if (!NR_SECTS(p) || is_extended_partition(p))
  150. continue;
  152. /* Check the 3rd and 4th entries -
  153.    these sometimes contain random garbage */
  154. offs = START_SECT(p)*sector_size;
  155. size = NR_SECTS(p)*sector_size;
  156. next = this_sector + offs;
  157. if (i >= 2) {
  158. if (offs + size > this_size)
  159. continue;
  160. if (next < first_sector)
  161. continue;
  162. if (next + size > first_sector + first_size)
  163. continue;
  164. }
  166. add_gd_partition(hd, *current_minor, next, size);
  167. #if CONFIG_BLK_DEV_MD
  168. if (SYS_IND(p) == LINUX_RAID_PARTITION) {
  169.     md_autodetect_dev(MKDEV(hd->major,*current_minor));
  170. }
  171. #endif
  173. (*current_minor)++;
  174. loopct = 0;
  175. if ((*current_minor & mask) == 0)
  176. goto done;
  177. }
  178. /*
  179.  * Next, process the (first) extended partition, if present.
  180.  * (So far, there seems to be no reason to make
  181.  *  extended_partition()  recursive and allow a tree
  182.  *  of extended partitions.)
  183.  * It should be a link to the next logical partition.
  184.  * Create a minor for this just long enough to get the next
  185.  * partition table.  The minor will be reused for the next
  186.  * data partition.
  187.  */
  188. p -= 4;
  189. for (i=0; i<4; i++, p++)
  190. if (NR_SECTS(p) && is_extended_partition(p))
  191. break;
  192. if (i == 4)
  193. goto done;  /* nothing left to do */
  195. this_sector = first_sector + START_SECT(p) * sector_size;
  196. this_size = NR_SECTS(p) * sector_size;
  197. minor = *current_minor;
  198. put_dev_sector(sect);
  199. }
  200. done:
  201. put_dev_sector(sect);
  202. }
  204. /* james@bpgc.com: Solaris has a nasty indicator: 0x82 which also
  205.    indicates linux swap.  Be careful before believing this is Solaris. */
  207. static void
  208. solaris_x86_partition(struct gendisk *hd, struct block_device *bdev,
  209. int minor, int *current_minor)
  210. {
  212. #ifdef CONFIG_SOLARIS_X86_PARTITION
  213. long offset = hd->part[minor].start_sect;
  214. Sector sect;
  215. struct solaris_x86_vtoc *v;
  216. struct solaris_x86_slice *s;
  217. int mask = (1 << hd->minor_shift) - 1;
  218. int i;
  219. char buf[40];
  221. v = (struct solaris_x86_vtoc *)read_dev_sector(bdev, offset+1, &sect);
  222. if (!v)
  223. return;
  224. if (le32_to_cpu(v->v_sanity) != SOLARIS_X86_VTOC_SANE) {
  225. put_dev_sector(sect);
  226. return;
  227. }
  228. printk(" %s: <solaris:", partition_name(hd, minor, buf));
  229. if (le32_to_cpu(v->v_version) != 1) {
  230. printk("  cannot handle version %d vtoc>n",
  231. le32_to_cpu(v->v_version));
  232. put_dev_sector(sect);
  233. return;
  234. }
  235. for (i=0; i<SOLARIS_X86_NUMSLICE; i++) {
  236. if ((*current_minor & mask) == 0)
  237. break;
  238. s = &v->v_slice[i];
  240. if (s->s_size == 0)
  241. continue;
  242. printk(" [s%d]", i);
  243. /* solaris partitions are relative to current MS-DOS
  244.  * one but add_gd_partition starts relative to sector
  245.  * zero of the disk.  Therefore, must add the offset
  246.  * of the current partition */
  247. add_gd_partition(hd, *current_minor,
  248.  le32_to_cpu(s->s_start)+offset,
  249.  le32_to_cpu(s->s_size));
  250. (*current_minor)++;
  251. }
  252. put_dev_sector(sect);
  253. printk(" >n");
  254. #endif
  255. }
  257. #ifdef CONFIG_BSD_DISKLABEL
  258. static void
  259. check_and_add_bsd_partition(struct gendisk *hd, struct bsd_partition *bsd_p,
  260. int baseminor, int *current_minor)
  261. {
  262. int i, bsd_start, bsd_size;
  264. bsd_start = le32_to_cpu(bsd_p->p_offset);
  265. bsd_size = le32_to_cpu(bsd_p->p_size);
  267. /* check relative position of already allocated partitions */
  268. for (i = baseminor+1; i < *current_minor; i++) {
  269. int start = hd->part[i].start_sect;
  270. int size = hd->part[i].nr_sects;
  272. if (start+size <= bsd_start || start >= bsd_start+bsd_size)
  273. continue; /* no overlap */
  275. if (start == bsd_start && size == bsd_size)
  276. return; /* equal -> no need to add */
  278. if (start <= bsd_start && start+size >= bsd_start+bsd_size) {
  279. /* bsd living within dos partition */
  280. #ifdef DEBUG_BSD_DISKLABEL
  281. printk("w: %d %ld+%ld,%d+%d", 
  282.        i, start, size, bsd_start, bsd_size);
  283. #endif
  284. break; /* ok */
  285. }
  287. /* ouch: bsd and linux overlap */
  288. #ifdef DEBUG_BSD_DISKLABEL
  289. printk("???: %d %ld+%ld,%d+%d",
  290.        i, start, size, bsd_start, bsd_size);
  291. #endif
  292. printk("???");
  293. return;
  294. }
  296. add_gd_partition(hd, *current_minor, bsd_start, bsd_size);
  297. (*current_minor)++;
  298. }
  300. /* 
  301.  * Create devices for BSD partitions listed in a disklabel, under a
  302.  * dos-like partition. See extended_partition() for more information.
  303.  */
  304. static void do_bsd_partition(struct gendisk *hd, struct block_device *bdev,
  305. int minor, int *current_minor, char *name, int max_partitions)
  306. {
  307. long offset = hd->part[minor].start_sect;
  308. Sector sect;
  309. struct bsd_disklabel *l;
  310. struct bsd_partition *p;
  311. int mask = (1 << hd->minor_shift) - 1;
  312. int baseminor = (minor & ~mask);
  313. char buf[40];
  315. l = (struct bsd_disklabel *)read_dev_sector(bdev, offset+1, &sect);
  316. if (!l)
  317. return;
  318. if (le32_to_cpu(l->d_magic) != BSD_DISKMAGIC) {
  319. put_dev_sector(sect);
  320. return;
  321. }
  322. printk(" %s: <%s:", partition_name(hd, minor, buf), name);
  324. if (le16_to_cpu(l->d_npartitions) < max_partitions)
  325. max_partitions = le16_to_cpu(l->d_npartitions);
  326. for (p = l->d_partitions; p - l->d_partitions <  max_partitions; p++) {
  327. if ((*current_minor & mask) == 0)
  328. break;
  329. if (p->p_fstype == BSD_FS_UNUSED) 
  330. continue;
  331. check_and_add_bsd_partition(hd, p, baseminor, current_minor);
  332. }
  333. put_dev_sector(sect);
  334. printk(" >n");
  335. }
  336. #endif
  338. static void bsd_partition(struct gendisk *hd, struct block_device *bdev,
  339. int minor, int *current_minor)
  340. {
  341. #ifdef CONFIG_BSD_DISKLABEL
  342. do_bsd_partition(hd, bdev, minor, current_minor, "bsd",
  343. BSD_MAXPARTITIONS);
  344. #endif
  345. }
  347. static void netbsd_partition(struct gendisk *hd, struct block_device *bdev,
  348. int minor, int *current_minor)
  349. {
  350. #ifdef CONFIG_BSD_DISKLABEL
  351. do_bsd_partition(hd, bdev, minor, current_minor, "netbsd",
  352. BSD_MAXPARTITIONS);
  353. #endif
  354. }
  356. static void openbsd_partition(struct gendisk *hd, struct block_device *bdev,
  357. int minor, int *current_minor)
  358. {
  359. #ifdef CONFIG_BSD_DISKLABEL
  360. do_bsd_partition(hd, bdev, minor, current_minor,
  361. "openbsd", OPENBSD_MAXPARTITIONS);
  362. #endif
  363. }
  365. /*
  366.  * Create devices for Unixware partitions listed in a disklabel, under a
  367.  * dos-like partition. See extended_partition() for more information.
  368.  */
  369. static void unixware_partition(struct gendisk *hd, struct block_device *bdev,
  370. int minor, int *current_minor)
  371. {
  372. #ifdef CONFIG_UNIXWARE_DISKLABEL
  373. long offset = hd->part[minor].start_sect;
  374. Sector sect;
  375. struct unixware_disklabel *l;
  376. struct unixware_slice *p;
  377. int mask = (1 << hd->minor_shift) - 1;
  378. char buf[40];
  380. l = (struct unixware_disklabel *)read_dev_sector(bdev, offset+29, &sect);
  381. if (!l)
  382. return;
  383. if (le32_to_cpu(l->d_magic) != UNIXWARE_DISKMAGIC ||
  384.     le32_to_cpu(l->vtoc.v_magic) != UNIXWARE_DISKMAGIC2) {
  385. put_dev_sector(sect);
  386. return;
  387. }
  388. printk(" %s: <unixware:", partition_name(hd, minor, buf));
  389. p = &l->vtoc.v_slice[1];
  390. /* I omit the 0th slice as it is the same as whole disk. */
  391. while (p - &l->vtoc.v_slice[0] < UNIXWARE_NUMSLICE) {
  392. if ((*current_minor & mask) == 0)
  393. break;
  395. if (p->s_label != UNIXWARE_FS_UNUSED) {
  396. add_gd_partition(hd, *current_minor, START_SECT(p),
  397.  NR_SECTS(p));
  398. (*current_minor)++;
  399. }
  400. p++;
  401. }
  402. put_dev_sector(sect);
  403. printk(" >n");
  404. #endif
  405. }
  407. /*
  408.  * Minix 2.0.0/2.0.2 subpartition support.
  409.  * Anand Krishnamurthy <anandk@wiproge.med.ge.com>
  410.  * Rajeev V. Pillai    <rajeevvp@yahoo.com>
  411.  */
  412. static void minix_partition(struct gendisk *hd, struct block_device *bdev,
  413. int minor, int *current_minor)
  414. {
  415. #ifdef CONFIG_MINIX_SUBPARTITION
  416. long offset = hd->part[minor].start_sect;
  417. Sector sect;
  418. unsigned char *data;
  419. struct partition *p;
  420. int mask = (1 << hd->minor_shift) - 1;
  421. int i;
  422. char buf[40];
  424. data = read_dev_sector(bdev, offset, &sect);
  425. if (!data)
  426. return;
  428. p = (struct partition *)(data + 0x1be);
  430. /* The first sector of a Minix partition can have either
  431.  * a secondary MBR describing its subpartitions, or
  432.  * the normal boot sector. */
  433. if (msdos_magic_present (data + 510) &&
  434.     SYS_IND(p) == MINIX_PARTITION) { /* subpartition table present */
  436. printk(" %s: <minix:", partition_name(hd, minor, buf));
  437. for (i = 0; i < MINIX_NR_SUBPARTITIONS; i++, p++) {
  438. if ((*current_minor & mask) == 0)
  439. break;
  440. /* add each partition in use */
  441. if (SYS_IND(p) == MINIX_PARTITION) {
  442. add_gd_partition(hd, *current_minor,
  443.       START_SECT(p), NR_SECTS(p));
  444. (*current_minor)++;
  445. }
  446. }
  447. printk(" >n");
  448. }
  449. put_dev_sector(sect);
  450. #endif /* CONFIG_MINIX_SUBPARTITION */
  451. }
  453. static struct {
  454. unsigned char id;
  455. void (*parse)(struct gendisk *, struct block_device *, int, int *);
  456. } subtypes[] = {
  457. {BSD_PARTITION, bsd_partition},
  458. {NETBSD_PARTITION, netbsd_partition},
  459. {OPENBSD_PARTITION, openbsd_partition},
  460. {MINIX_PARTITION, minix_partition},
  461. {UNIXWARE_PARTITION, unixware_partition},
  462. {SOLARIS_X86_PARTITION, solaris_x86_partition},
  463. {0, NULL},
  464. };
  465. /*
  466.  * Look for various forms of IDE disk geometry translation
  467.  */
  468. static int handle_ide_mess(struct block_device *bdev)
  469. {
  470. #ifdef CONFIG_BLK_DEV_IDE
  471. Sector sect;
  472. unsigned char *data;
  473. kdev_t dev = to_kdev_t(bdev->bd_dev);
  474. unsigned int sig;
  475. int heads = 0;
  476. struct partition *p;
  477. int i;
  478. /*
  479.  * The i386 partition handling programs very often
  480.  * make partitions end on cylinder boundaries.
  481.  * There is no need to do so, and Linux fdisk doesnt always
  482.  * do this, and Windows NT on Alpha doesnt do this either,
  483.  * but still, this helps to guess #heads.
  484.  */
  485. data = read_dev_sector(bdev, 0, &sect);
  486. if (!data)
  487. return -1;
  488. if (!msdos_magic_present(data + 510)) {
  489. put_dev_sector(sect);
  490. return 0;
  491. }
  492. sig = le16_to_cpu(*(unsigned short *)(data + 2));
  493. p = (struct partition *) (data + 0x1be);
  494. for (i = 0; i < 4; i++) {
  495. struct partition *q = &p[i];
  496. if (NR_SECTS(q)) {
  497. if ((q->sector & 63) == 1 &&
  498.     (q->end_sector & 63) == 63)
  499. heads = q->end_head + 1;
  500. break;
  501. }
  502. }
  503. if (SYS_IND(p) == EZD_PARTITION) {
  504. /*
  505.  * Accesses to sector 0 must go to sector 1 instead.
  506.  */
  507. if (ide_xlate_1024(dev, -1, heads, " [EZD]"))
  508. goto reread;
  509. } else if (SYS_IND(p) == DM6_PARTITION) {
  511. /*
  512.  * Everything on the disk is offset by 63 sectors,
  513.  * including a "new" MBR with its own partition table.
  514.  */
  515. if (ide_xlate_1024(dev, 1, heads, " [DM6:DDO]"))
  516. goto reread;
  517. } else if (sig <= 0x1ae &&
  518.    data[sig] == 0xAA && data[sig+1] == 0x55 &&
  519.    (data[sig+2] & 1)) {
  520. /* DM6 signature in MBR, courtesy of OnTrack */
  521. (void) ide_xlate_1024 (dev, 0, heads, " [DM6:MBR]");
  522. } else if (SYS_IND(p) == DM6_AUX1PARTITION ||
  523.    SYS_IND(p) == DM6_AUX3PARTITION) {
  524. /*
  525.  * DM6 on other than the first (boot) drive
  526.  */
  527. (void) ide_xlate_1024(dev, 0, heads, " [DM6:AUX]");
  528. } else {
  529. (void) ide_xlate_1024(dev, 2, heads, " [PTBL]");
  530. }
  531. put_dev_sector(sect);
  532. return 1;
  534. reread:
  535. put_dev_sector(sect);
  536. /* Flush the cache */
  537. invalidate_bdev(bdev, 1);
  538. truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
  539. #endif /* CONFIG_BLK_DEV_IDE */
  540. return 1;
  541. }
  542.  
  543. int msdos_partition(struct gendisk *hd, struct block_device *bdev,
  544.     unsigned long first_sector, int first_part_minor)
  545. {
  546. int i, minor = first_part_minor;
  547. Sector sect;
  548. struct partition *p;
  549. unsigned char *data;
  550. int mask = (1 << hd->minor_shift) - 1;
  551. int sector_size = get_hardsect_size(to_kdev_t(bdev->bd_dev)) / 512;
  552. int current_minor = first_part_minor;
  553. int err;
  555. err = handle_ide_mess(bdev);
  556. if (err <= 0)
  557. return err;
  558. data = read_dev_sector(bdev, 0, &sect);
  559. if (!data)
  560. return -1;
  561. if (!msdos_magic_present(data + 510)) {
  562. put_dev_sector(sect);
  563. return 0;
  564. }
  565. p = (struct partition *) (data + 0x1be);
  567. /*
  568.  * Look for partitions in two passes:
  569.  * First find the primary and DOS-type extended partitions.
  570.  * On the second pass look inside *BSD, Unixware and Solaris partitions.
  571.  */
  573. current_minor += 4;
  574. for (i=1 ; i<=4 ; minor++,i++,p++) {
  575. if (!NR_SECTS(p))
  576. continue;
  577. add_gd_partition(hd, minor,
  578. first_sector+START_SECT(p)*sector_size,
  579. NR_SECTS(p)*sector_size);
  580. #if CONFIG_BLK_DEV_MD
  581. if (SYS_IND(p) == LINUX_RAID_PARTITION) {
  582. md_autodetect_dev(MKDEV(hd->major,minor));
  583. }
  584. #endif
  585. if (is_extended_partition(p)) {
  586. unsigned long size = hd->part[minor].nr_sects;
  587. printk(" <");
  588. /* prevent someone doing mkfs or mkswap on an
  589.    extended partition, but leave room for LILO */
  590. if (size > 2)
  591. hd->part[minor].nr_sects = 2;
  592. extended_partition(hd, bdev, minor, size, &current_minor);
  593. printk(" >");
  594. }
  595. }
  597. /*
  598.  *  Check for old-style Disk Manager partition table
  599.  */
  600. if (msdos_magic_present(data + 0xfc)) {
  601. p = (struct partition *) (0x1be + data);
  602. for (i = 4 ; i < 16 ; i++, current_minor++) {
  603. p--;
  604. if ((current_minor & mask) == 0)
  605. break;
  606. if (!(START_SECT(p) && NR_SECTS(p)))
  607. continue;
  608. add_gd_partition(hd, current_minor, START_SECT(p), NR_SECTS(p));
  609. }
  610. }
  611. printk("n");
  613. /* second pass - output for each on a separate line */
  614. minor -= 4;
  615. p = (struct partition *) (0x1be + data);
  616. for (i=1 ; i<=4 ; minor++,i++,p++) {
  617. unsigned char id = SYS_IND(p);
  618. int n;
  620. if (!NR_SECTS(p))
  621. continue;
  623. for (n = 0; subtypes[n].parse && id != subtypes[n].id; n++)
  624. ;
  626. if (subtypes[n].parse)
  627. subtypes[n].parse(hd, bdev, minor, &current_minor);
  628. }
  629. put_dev_sector(sect);
  630. return 1;
  631. }