![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genhd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / block|
Return to genhd.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / block |
1.1 root 1: /*
2: * Code extracted from
3: * linux/kernel/hd.c
4: *
5: * Copyright (C) 1991, 1992 Linus Torvalds
6: *
7: *
8: * Thanks to Branko Lankester, [email protected], who found a bug
9: * in the early extended-partition checks and added DM partitions
10: *
11: * Support for DiskManager v6.0x added by Mark Lord,
12: * with information provided by OnTrack. This now works for linux fdisk
13: * and LILO, as well as loadlin and bootln. Note that disks other than
14: * /dev/hda *must* have a "DOS" type 0x51 partition in the first slot (hda1).
15: *
16: * More flexible handling of extended partitions - aeb, 950831
17: *
18: * Check partition table on IDE disks for common CHS translations
19: */
20:
21: #include <linux/config.h>
22: #include <linux/fs.h>
23: #include <linux/genhd.h>
24: #include <linux/kernel.h>
25: #include <linux/major.h>
26: #include <linux/string.h>
27: #ifdef CONFIG_BLK_DEV_INITRD
28: #include <linux/blk.h>
29: #endif
30:
31: #include <asm/system.h>
32:
33: /*
34: * Many architectures don't like unaligned accesses, which is
35: * frequently the case with the nr_sects and start_sect partition
36: * table entries.
37: */
38: #include <asm/unaligned.h>
39:
40: #define SYS_IND(p) get_unaligned(&p->sys_ind)
41: #define NR_SECTS(p) get_unaligned(&p->nr_sects)
42: #define START_SECT(p) get_unaligned(&p->start_sect)
43:
44:
45: struct gendisk *gendisk_head = NULL;
46:
47: static int current_minor = 0;
48: extern int *blk_size[];
49: extern void rd_load(void);
50: extern void initrd_load(void);
51:
52: extern int chr_dev_init(void);
53: extern int blk_dev_init(void);
54: extern int scsi_dev_init(void);
55: extern int net_dev_init(void);
56:
57: /*
58: * disk_name() is used by genhd.c and md.c.
59: * It formats the devicename of the indicated disk
60: * into the supplied buffer, and returns a pointer
61: * to that same buffer (for convenience).
62: */
63: char *disk_name (struct gendisk *hd, int minor, char *buf)
64: {
65: unsigned int part;
66: const char *maj = hd->major_name;
67: char unit = (minor >> hd->minor_shift) + 'a';
68:
69: #ifdef CONFIG_BLK_DEV_IDE
70: /*
71: * IDE devices use multiple major numbers, but the drives
72: * are named as: {hda,hdb}, {hdc,hdd}, {hde,hdf}, {hdg,hdh}..
73: * This requires special handling here.
74: */
75: switch (hd->major) {
76: case IDE3_MAJOR:
77: unit += 2;
78: case IDE2_MAJOR:
79: unit += 2;
80: case IDE1_MAJOR:
81: unit += 2;
82: case IDE0_MAJOR:
83: maj = "hd";
84: }
85: #endif
86: part = minor & ((1 << hd->minor_shift) - 1);
87: if (part)
88: sprintf(buf, "%s%c%d", maj, unit, part);
89: else
90: sprintf(buf, "%s%c", maj, unit);
91: return buf;
92: }
93:
94: static void add_partition (struct gendisk *hd, int minor, int start, int size)
95: {
96: char buf[8];
97: hd->part[minor].start_sect = start;
98: hd->part[minor].nr_sects = size;
99: printk(" %s", disk_name(hd, minor, buf));
100: }
101:
102: static inline int is_extended_partition(struct partition *p)
103: {
104: return (SYS_IND(p) == DOS_EXTENDED_PARTITION ||
105: SYS_IND(p) == WIN98_EXTENDED_PARTITION ||
106: SYS_IND(p) == LINUX_EXTENDED_PARTITION);
107: }
108:
109: #ifdef CONFIG_MSDOS_PARTITION
110: /*
111: * Create devices for each logical partition in an extended partition.
112: * The logical partitions form a linked list, with each entry being
113: * a partition table with two entries. The first entry
114: * is the real data partition (with a start relative to the partition
115: * table start). The second is a pointer to the next logical partition
116: * (with a start relative to the entire extended partition).
117: * We do not create a Linux partition for the partition tables, but
118: * only for the actual data partitions.
119: */
120:
121: static void extended_partition(struct gendisk *hd, kdev_t dev)
122: {
123: struct buffer_head *bh;
124: struct partition *p;
125: unsigned long first_sector, first_size, this_sector, this_size;
126: int mask = (1 << hd->minor_shift) - 1;
127: int i;
128:
129: first_sector = hd->part[MINOR(dev)].start_sect;
130: first_size = hd->part[MINOR(dev)].nr_sects;
131: this_sector = first_sector;
132:
133: while (1) {
134: if ((current_minor & mask) == 0)
135: return;
136: if (!(bh = bread(dev,0,1024)))
137: return;
138: /*
139: * This block is from a device that we're about to stomp on.
140: * So make sure nobody thinks this block is usable.
141: */
142: bh->b_state = 0;
143:
144: if (*(unsigned short *) (bh->b_data+510) != 0xAA55)
145: goto done;
146:
147: p = (struct partition *) (0x1BE + bh->b_data);
148:
149: this_size = hd->part[MINOR(dev)].nr_sects;
150:
151: /*
152: * Usually, the first entry is the real data partition,
153: * the 2nd entry is the next extended partition, or empty,
154: * and the 3rd and 4th entries are unused.
155: * However, DRDOS sometimes has the extended partition as
156: * the first entry (when the data partition is empty),
157: * and OS/2 seems to use all four entries.
158: */
159:
160: /*
161: * First process the data partition(s)
162: */
163: for (i=0; i<4; i++, p++) {
164: if (!NR_SECTS(p) || is_extended_partition(p))
165: continue;
166:
167: /* Check the 3rd and 4th entries -
168: these sometimes contain random garbage */
169: if (i >= 2
170: && START_SECT(p) + NR_SECTS(p) > this_size
171: && (this_sector + START_SECT(p) < first_sector ||
172: this_sector + START_SECT(p) + NR_SECTS(p) >
173: first_sector + first_size))
174: continue;
175:
176: add_partition(hd, current_minor, this_sector+START_SECT(p), NR_SECTS(p));
177: current_minor++;
178: if ((current_minor & mask) == 0)
179: goto done;
180: }
181: /*
182: * Next, process the (first) extended partition, if present.
183: * (So far, there seems to be no reason to make
184: * extended_partition() recursive and allow a tree
185: * of extended partitions.)
186: * It should be a link to the next logical partition.
187: * Create a minor for this just long enough to get the next
188: * partition table. The minor will be reused for the next
189: * data partition.
190: */
191: p -= 4;
192: for (i=0; i<4; i++, p++)
193: if(NR_SECTS(p) && is_extended_partition(p))
194: break;
195: if (i == 4)
196: goto done; /* nothing left to do */
197:
198: hd->part[current_minor].nr_sects = NR_SECTS(p);
199: hd->part[current_minor].start_sect = first_sector + START_SECT(p);
200: this_sector = first_sector + START_SECT(p);
201: dev = MKDEV(hd->major, current_minor);
202: brelse(bh);
203: }
204: done:
205: brelse(bh);
206: }
207:
208: #ifdef CONFIG_BSD_DISKLABEL
209: /*
210: * Create devices for BSD partitions listed in a disklabel, under a
211: * dos-like partition. See extended_partition() for more information.
212: */
213: static void bsd_disklabel_partition(struct gendisk *hd, kdev_t dev)
214: {
215: struct buffer_head *bh;
216: struct bsd_disklabel *l;
217: struct bsd_partition *p;
218: int mask = (1 << hd->minor_shift) - 1;
219:
220: if (!(bh = bread(dev,0,1024)))
221: return;
222: bh->b_state = 0;
223: l = (struct bsd_disklabel *) (bh->b_data+512);
224: if (l->d_magic != BSD_DISKMAGIC) {
225: brelse(bh);
226: return;
227: }
228:
229: p = &l->d_partitions[0];
230: while (p - &l->d_partitions[0] <= BSD_MAXPARTITIONS) {
231: if ((current_minor & mask) >= (4 + hd->max_p))
232: break;
233:
234: if (p->p_fstype != BSD_FS_UNUSED) {
235: add_partition(hd, current_minor, p->p_offset, p->p_size);
236: current_minor++;
237: }
238: p++;
239: }
240: brelse(bh);
241:
242: }
243: #endif
244:
245: static int msdos_partition(struct gendisk *hd, kdev_t dev, unsigned long first_sector)
246: {
247: int i, minor = current_minor;
248: struct buffer_head *bh;
249: struct partition *p;
250: unsigned char *data;
251: int mask = (1 << hd->minor_shift) - 1;
252: #ifdef CONFIG_BLK_DEV_IDE
253: int tested_for_xlate = 0;
254:
255: read_mbr:
256: #endif
257: if (!(bh = bread(dev,0,1024))) {
258: printk(" unable to read partition table\n");
259: return -1;
260: }
261: data = bh->b_data;
262: /* In some cases we modify the geometry */
263: /* of the drive (below), so ensure that */
264: /* nobody else tries to re-use this data. */
265: bh->b_state = 0;
266: #ifdef CONFIG_BLK_DEV_IDE
267: check_table:
268: #endif
269: if (*(unsigned short *) (0x1fe + data) != 0xAA55) {
270: brelse(bh);
271: return 0;
272: }
273: p = (struct partition *) (0x1be + data);
274:
275: #ifdef CONFIG_BLK_DEV_IDE
276: if (!tested_for_xlate++) { /* Do this only once per disk */
277: /*
278: * Look for various forms of IDE disk geometry translation
279: */
280: extern int ide_xlate_1024(kdev_t, int, const char *);
281: unsigned int sig = *(unsigned short *)(data + 2);
282: if (SYS_IND(p) == EZD_PARTITION) {
283: /*
284: * The remainder of the disk must be accessed using
285: * a translated geometry that reduces the number of
286: * apparent cylinders to less than 1024 if possible.
287: *
288: * ide_xlate_1024() will take care of the necessary
289: * adjustments to fool fdisk/LILO and partition check.
290: */
291: if (ide_xlate_1024(dev, -1, " [EZD]")) {
292: data += 512;
293: goto check_table;
294: }
295: } else if (SYS_IND(p) == DM6_PARTITION) {
296:
297: /*
298: * Everything on the disk is offset by 63 sectors,
299: * including a "new" MBR with its own partition table,
300: * and the remainder of the disk must be accessed using
301: * a translated geometry that reduces the number of
302: * apparent cylinders to less than 1024 if possible.
303: *
304: * ide_xlate_1024() will take care of the necessary
305: * adjustments to fool fdisk/LILO and partition check.
306: */
307: if (ide_xlate_1024(dev, 1, " [DM6:DDO]")) {
308: brelse(bh);
309: goto read_mbr; /* start over with new MBR */
310: }
311: } else if (sig <= 0x1ae && *(unsigned short *)(data + sig) == 0x55AA
312: && (1 & *(unsigned char *)(data + sig + 2)) )
313: {
314: /*
315: * DM6 signature in MBR, courtesy of OnTrack
316: */
317: (void) ide_xlate_1024 (dev, 0, " [DM6:MBR]");
318: } else if (SYS_IND(p) == DM6_AUX1PARTITION || SYS_IND(p) == DM6_AUX3PARTITION) {
319: /*
320: * DM6 on other than the first (boot) drive
321: */
322: (void) ide_xlate_1024(dev, 0, " [DM6:AUX]");
323: } else {
324: /*
325: * Examine the partition table for common translations.
326: * This is necessary for drives for situations where
327: * the translated geometry is unavailable from the BIOS.
328: */
329: for (i = 0; i < 4 ; i++) {
330: struct partition *q = &p[i];
331: if (NR_SECTS(q)
332: && (q->sector & 63) == 1
333: && (q->end_sector & 63) == 63) {
334: unsigned int heads = q->end_head + 1;
335: if (heads == 32 || heads == 64 || heads == 128 || heads == 255) {
336:
337: (void) ide_xlate_1024(dev, heads, " [PTBL]");
338: break;
339: }
340: }
341: }
342: }
343: }
344: #endif /* CONFIG_BLK_DEV_IDE */
345:
346: current_minor += 4; /* first "extra" minor (for extended partitions) */
347: for (i=1 ; i<=4 ; minor++,i++,p++) {
348: if (!NR_SECTS(p))
349: continue;
350: add_partition(hd, minor, first_sector+START_SECT(p), NR_SECTS(p));
351: if (is_extended_partition(p)) {
352: printk(" <");
353: /*
354: * If we are rereading the partition table, we need
355: * to set the size of the partition so that we will
356: * be able to bread the block containing the extended
357: * partition info.
358: */
359: hd->sizes[minor] = hd->part[minor].nr_sects
360: >> (BLOCK_SIZE_BITS - 9);
361: extended_partition(hd, MKDEV(hd->major, minor));
362: printk(" >");
363: /* prevent someone doing mkfs or mkswap on an
364: extended partition, but leave room for LILO */
365: if (hd->part[minor].nr_sects > 2)
366: hd->part[minor].nr_sects = 2;
367: }
368: #ifdef CONFIG_BSD_DISKLABEL
369: if (SYS_IND(p) == BSD_PARTITION) {
370: printk(" <");
371: bsd_disklabel_partition(hd, MKDEV(hd->major, minor));
372: printk(" >");
373: }
374: #endif
375: }
376: /*
377: * Check for old-style Disk Manager partition table
378: */
379: if (*(unsigned short *) (data+0xfc) == 0x55AA) {
380: p = (struct partition *) (0x1be + data);
381: for (i = 4 ; i < 16 ; i++, current_minor++) {
382: p--;
383: if ((current_minor & mask) == 0)
384: break;
385: if (!(START_SECT(p) && NR_SECTS(p)))
386: continue;
387: add_partition(hd, current_minor, START_SECT(p), NR_SECTS(p));
388: }
389: }
390: printk("\n");
391: brelse(bh);
392: return 1;
393: }
394:
395: #endif /* CONFIG_MSDOS_PARTITION */
396:
397: #ifdef CONFIG_OSF_PARTITION
398:
399: static int osf_partition(struct gendisk *hd, unsigned int dev, unsigned long first_sector)
400: {
401: int i;
402: int mask = (1 << hd->minor_shift) - 1;
403: struct buffer_head *bh;
404: struct disklabel {
405: u32 d_magic;
406: u16 d_type,d_subtype;
407: u8 d_typename[16];
408: u8 d_packname[16];
409: u32 d_secsize;
410: u32 d_nsectors;
411: u32 d_ntracks;
412: u32 d_ncylinders;
413: u32 d_secpercyl;
414: u32 d_secprtunit;
415: u16 d_sparespertrack;
416: u16 d_sparespercyl;
417: u32 d_acylinders;
418: u16 d_rpm, d_interleave, d_trackskew, d_cylskew;
419: u32 d_headswitch, d_trkseek, d_flags;
420: u32 d_drivedata[5];
421: u32 d_spare[5];
422: u32 d_magic2;
423: u16 d_checksum;
424: u16 d_npartitions;
425: u32 d_bbsize, d_sbsize;
426: struct d_partition {
427: u32 p_size;
428: u32 p_offset;
429: u32 p_fsize;
430: u8 p_fstype;
431: u8 p_frag;
432: u16 p_cpg;
433: } d_partitions[8];
434: } * label;
435: struct d_partition * partition;
436: #define DISKLABELMAGIC (0x82564557UL)
437:
438: if (!(bh = bread(dev,0,1024))) {
439: printk("unable to read partition table\n");
440: return -1;
441: }
442: label = (struct disklabel *) (bh->b_data+64);
443: partition = label->d_partitions;
444: if (label->d_magic != DISKLABELMAGIC) {
445: printk("magic: %08x\n", label->d_magic);
446: brelse(bh);
447: return 0;
448: }
449: if (label->d_magic2 != DISKLABELMAGIC) {
450: printk("magic2: %08x\n", label->d_magic2);
451: brelse(bh);
452: return 0;
453: }
454: for (i = 0 ; i < label->d_npartitions; i++, partition++) {
455: if ((current_minor & mask) == 0)
456: break;
457: if (partition->p_size)
458: add_partition(hd, current_minor,
459: first_sector+partition->p_offset,
460: partition->p_size);
461: current_minor++;
462: }
463: printk("\n");
464: brelse(bh);
465: return 1;
466: }
467:
468: #endif /* CONFIG_OSF_PARTITION */
469:
470: #ifdef CONFIG_SUN_PARTITION
471:
472: static int sun_partition(struct gendisk *hd, kdev_t dev, unsigned long first_sector)
473: {
474: int i, csum;
475: unsigned short *ush;
476: struct buffer_head *bh;
477: struct sun_disklabel {
478: unsigned char info[128]; /* Informative text string */
479: unsigned char spare[292]; /* Boot information etc. */
480: unsigned short rspeed; /* Disk rotational speed */
481: unsigned short pcylcount; /* Physical cylinder count */
482: unsigned short sparecyl; /* extra sects per cylinder */
483: unsigned char spare2[4]; /* More magic... */
484: unsigned short ilfact; /* Interleave factor */
485: unsigned short ncyl; /* Data cylinder count */
486: unsigned short nacyl; /* Alt. cylinder count */
487: unsigned short ntrks; /* Tracks per cylinder */
488: unsigned short nsect; /* Sectors per track */
489: unsigned char spare3[4]; /* Even more magic... */
490: struct sun_partition {
491: __u32 start_cylinder;
492: __u32 num_sectors;
493: } partitions[8];
494: unsigned short magic; /* Magic number */
495: unsigned short csum; /* Label xor'd checksum */
496: } * label;
497: struct sun_partition *p;
498: int other_endian;
499: unsigned long spc;
500: #define SUN_LABEL_MAGIC 0xDABE
501: #define SUN_LABEL_MAGIC_SWAPPED 0xBEDA
502: /* No need to optimize these macros since they are called only when reading
503: * the partition table. This occurs only at each disk change. */
504: #define SWAP16(x) (other_endian ? (((__u16)(x) & 0xFF) << 8) \
505: | (((__u16)(x) & 0xFF00) >> 8) \
506: : (__u16)(x))
507: #define SWAP32(x) (other_endian ? (((__u32)(x) & 0xFF) << 24) \
508: | (((__u32)(x) & 0xFF00) << 8) \
509: | (((__u32)(x) & 0xFF0000) >> 8) \
510: | (((__u32)(x) & 0xFF000000) >> 24) \
511: : (__u32)(x))
512:
513: if(!(bh = bread(dev, 0, 1024))) {
514: printk("Dev %s: unable to read partition table\n",
515: kdevname(dev));
516: return -1;
517: }
518: label = (struct sun_disklabel *) bh->b_data;
519: p = label->partitions;
520: if (label->magic != SUN_LABEL_MAGIC && label->magic != SUN_LABEL_MAGIC_SWAPPED) {
521: printk("Dev %s Sun disklabel: bad magic %04x\n",
522: kdevname(dev), label->magic);
523: brelse(bh);
524: return 0;
525: }
526: other_endian = (label->magic == SUN_LABEL_MAGIC_SWAPPED);
527: /* Look at the checksum */
528: ush = ((unsigned short *) (label+1)) - 1;
529: for(csum = 0; ush >= ((unsigned short *) label);)
530: csum ^= *ush--;
531: if(csum) {
532: printk("Dev %s Sun disklabel: Csum bad, label corrupted\n",
533: kdevname(dev));
534: brelse(bh);
535: return 0;
536: }
537: /* All Sun disks have 8 partition entries */
538: spc = SWAP16(label->ntrks) * SWAP16(label->nsect);
539: for(i=0; i < 8; i++, p++) {
540: unsigned long st_sector;
541:
542: /* We register all partitions, even if zero size, so that
543: * the minor numbers end up ok as per SunOS interpretation.
544: */
545: st_sector = first_sector + SWAP32(p->start_cylinder) * spc;
546: add_partition(hd, current_minor, st_sector, SWAP32(p->num_sectors));
547: current_minor++;
548: }
549: printk("\n");
550: brelse(bh);
551: return 1;
552: #undef SWAP16
553: #undef SWAP32
554: }
555:
556: #endif /* CONFIG_SUN_PARTITION */
557:
558: #ifdef CONFIG_AMIGA_PARTITION
559: #include <asm/byteorder.h>
560: #include <linux/affs_hardblocks.h>
561:
562: static __inline__ __u32
563: checksum_block(__u32 *m, int size)
564: {
565: __u32 sum = 0;
566:
567: while (size--)
568: sum += htonl(*m++);
569: return sum;
570: }
571:
572: static int
573: amiga_partition(struct gendisk *hd, unsigned int dev, unsigned long first_sector)
574: {
575: struct buffer_head *bh;
576: struct RigidDiskBlock *rdb;
577: struct PartitionBlock *pb;
578: int start_sect;
579: int nr_sects;
580: int blk;
581: int part, res;
582:
583: set_blocksize(dev,512);
584: res = 0;
585:
586: for (blk = 0; blk < RDB_ALLOCATION_LIMIT; blk++) {
587: if(!(bh = bread(dev,blk,512))) {
588: printk("Dev %d: unable to read RDB block %d\n",dev,blk);
589: goto rdb_done;
590: }
591: if (*(__u32 *)bh->b_data == htonl(IDNAME_RIGIDDISK)) {
592: rdb = (struct RigidDiskBlock *)bh->b_data;
593: if (checksum_block((__u32 *)bh->b_data,htonl(rdb->rdb_SummedLongs) & 0x7F)) {
594: printk("Dev %d: RDB in block %d has bad checksum\n",dev,blk);
595: brelse(bh);
596: continue;
597: }
598: printk(" RDSK");
599: blk = htonl(rdb->rdb_PartitionList);
600: brelse(bh);
601: for (part = 1; blk > 0 && part <= 16; part++) {
602: if (!(bh = bread(dev,blk,512))) {
603: printk("Dev %d: unable to read partition block %d\n",
604: dev,blk);
605: goto rdb_done;
606: }
607: pb = (struct PartitionBlock *)bh->b_data;
608: blk = htonl(pb->pb_Next);
609: if (pb->pb_ID == htonl(IDNAME_PARTITION) && checksum_block(
610: (__u32 *)pb,htonl(pb->pb_SummedLongs) & 0x7F) == 0 ) {
611:
612: /* Tell Kernel about it */
613:
614: if (!(nr_sects = (htonl(pb->pb_Environment[10]) + 1 -
615: htonl(pb->pb_Environment[9])) *
616: htonl(pb->pb_Environment[3]) *
617: htonl(pb->pb_Environment[5]))) {
618: continue;
619: }
620: start_sect = htonl(pb->pb_Environment[9]) *
621: htonl(pb->pb_Environment[3]) *
622: htonl(pb->pb_Environment[5]);
623: add_partition(hd,current_minor,start_sect,nr_sects);
624: current_minor++;
625: res = 1;
626: }
627: brelse(bh);
628: }
629: printk("\n");
630: break;
631: }
632: }
633:
634: rdb_done:
635: set_blocksize(dev,BLOCK_SIZE);
636: return res;
637: }
638: #endif /* CONFIG_AMIGA_PARTITION */
639:
640: static void check_partition(struct gendisk *hd, kdev_t dev)
641: {
642: static int first_time = 1;
643: unsigned long first_sector;
644: char buf[8];
645:
646: if (first_time)
647: printk("Partition check:\n");
648: first_time = 0;
649: first_sector = hd->part[MINOR(dev)].start_sect;
650:
651: /*
652: * This is a kludge to allow the partition check to be
653: * skipped for specific drives (e.g. IDE cd-rom drives)
654: */
655: if ((int)first_sector == -1) {
656: hd->part[MINOR(dev)].start_sect = 0;
657: return;
658: }
659:
660: printk(" %s:", disk_name(hd, MINOR(dev), buf));
661: #ifdef CONFIG_MSDOS_PARTITION
662: if (msdos_partition(hd, dev, first_sector))
663: return;
664: #endif
665: #ifdef CONFIG_OSF_PARTITION
666: if (osf_partition(hd, dev, first_sector))
667: return;
668: #endif
669: #ifdef CONFIG_SUN_PARTITION
670: if(sun_partition(hd, dev, first_sector))
671: return;
672: #endif
673: #ifdef CONFIG_AMIGA_PARTITION
674: if(amiga_partition(hd, dev, first_sector))
675: return;
676: #endif
677: printk(" unknown partition table\n");
678: }
679:
680: /* This function is used to re-read partition tables for removable disks.
681: Much of the cleanup from the old partition tables should have already been
682: done */
683:
684: /* This function will re-read the partition tables for a given device,
685: and set things back up again. There are some important caveats,
686: however. You must ensure that no one is using the device, and no one
687: can start using the device while this function is being executed. */
688:
689: void resetup_one_dev(struct gendisk *dev, int drive)
690: {
691: int i;
692: int first_minor = drive << dev->minor_shift;
693: int end_minor = first_minor + dev->max_p;
694:
695: blk_size[dev->major] = NULL;
696: current_minor = 1 + first_minor;
697: check_partition(dev, MKDEV(dev->major, first_minor));
698:
699: /*
700: * We need to set the sizes array before we will be able to access
701: * any of the partitions on this device.
702: */
703: if (dev->sizes != NULL) { /* optional safeguard in ll_rw_blk.c */
704: for (i = first_minor; i < end_minor; i++)
705: dev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
706: blk_size[dev->major] = dev->sizes;
707: }
708: }
709:
710: static void setup_dev(struct gendisk *dev)
711: {
712: int i, drive;
713: int end_minor = dev->max_nr * dev->max_p;
714:
715: blk_size[dev->major] = NULL;
716: for (i = 0 ; i < end_minor; i++) {
717: dev->part[i].start_sect = 0;
718: dev->part[i].nr_sects = 0;
719: }
720: dev->init(dev);
721: for (drive = 0 ; drive < dev->nr_real ; drive++) {
722: int first_minor = drive << dev->minor_shift;
723: current_minor = 1 + first_minor;
724: check_partition(dev, MKDEV(dev->major, first_minor));
725: }
726: if (dev->sizes != NULL) { /* optional safeguard in ll_rw_blk.c */
727: for (i = 0; i < end_minor; i++)
728: dev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
729: blk_size[dev->major] = dev->sizes;
730: }
731: }
732:
733: void device_setup(void)
734: {
735: extern void console_map_init(void);
736: struct gendisk *p;
737: int nr=0;
738:
739: chr_dev_init();
740: blk_dev_init();
741: sti();
742: #ifdef CONFIG_SCSI
743: scsi_dev_init();
744: #endif
745: #ifdef CONFIG_INET
746: net_dev_init();
747: #endif
748: console_map_init();
749:
750: for (p = gendisk_head ; p ; p=p->next) {
751: setup_dev(p);
752: nr += p->nr_real;
753: }
754: #ifdef CONFIG_BLK_DEV_RAM
755: #ifdef CONFIG_BLK_DEV_INITRD
756: if (initrd_start && mount_initrd) initrd_load();
757: else
758: #endif
759: rd_load();
760: #endif
761: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.