/*
* rescuept - Andries Brouwer - aeb@cwi.nl - 1999
*
* This may be distributed under the GPL.
*
* call: rescuept /dev/xxx
*
* The output is a proposed partition table, in the
* form of input to sfdisk. Typical use:
*
* ./rescuept /dev/xxx > xxx.pt
* now look at xxx.pt to see whether it resembles what
* you expected, and possibly edit the partition types;
* if you are satisfied, then
* sfdisk /dev/xxx < xxx.pt
* will restore your partition table. If you are cautious, use
* sfdisk /dev/xxx -O xxx.old < xxx.pt
* so that the original state can be retrieved using
* sfdisk /dev/xxx -I xxx.old
*
* Here xxx stands for hda or hdb or sda or sdb or ...
*/
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#ifndef BLKGETSIZE
#define BLKGETSIZE _IO(0x12,96)
#endif
char *progname;
char *device;
#define MAXPARTITIONS 100
#define MAXPAGESZ 65536
#define BUFSZ 1024000
#define BUFSECS (BUFSZ/512)
char buf[BUFSZ];
int bufstart = -1;
typedef unsigned int uint32;
typedef int sint32;
typedef unsigned short uint16;
typedef short sint16;
typedef unsigned char uchar;
void read_sectors(int fd, char *buf, int sectornr, int sectorct) {
extern long long llseek();
long long offset;
int n;
offset = sectornr;
offset *= 512;
if (llseek(fd, offset, SEEK_SET) != offset) {
fprintf(stderr, "%s: llseek error\n", progname);
exit(1);
}
n = read(fd, buf, sectorct*512);
if (n != sectorct*512) {
if (n == -1)
perror("read");
fprintf(stderr, "%s: error reading sectors %d-%d\n",
progname, sectornr, sectornr+sectorct-1);
exit(1);
}
}
/*
* Partition table stuff
*/
struct partition {
unsigned char bootable; /* 0 or 0x80 */
uchar begin_chs[3];
unsigned char sys_type;
uchar end_chs[3];
unsigned int start_sect; /* starting sector counting from 0 */
unsigned int nr_sects; /* nr of sectors in partition */
};
int
is_extended(unsigned char sys_type) {
return (sys_type == 0x5 || sys_type == 0xf || sys_type == 0x85);
}
/*
* List of (extended) partition table sectors found
*/
struct epts {
int secno;
char pt4[64];
} epts[MAXPARTITIONS];
int eptsct;
void addepts(int secno, char *data) {
if (eptsct >= MAXPARTITIONS)
return; /* ignore */
epts[eptsct].secno = secno;
memcpy(epts[eptsct].pt4, data+512-66, 64);
eptsct++;
}
/*
* List of guessed partitions
*/
struct pt {
int pno;
int start;
int size;
unsigned char type;
} pts[MAXPARTITIONS];
int partno;
void addpart(int start, int size, unsigned char type) {
if (partno >= MAXPARTITIONS)
return; /* ignore */
pts[partno].start = start;
pts[partno].size = size;
pts[partno].type = type;
partno++;
}
void outparts() {
int i;
for(i=0; i<partno; i++)
printf("%s%d : start=%9d, size=%8d, Id=%2x\n",
device, pts[i].pno,
pts[i].start, pts[i].size, pts[i].type);
}
void outmsg(char *msg, int start, int nextstart, unsigned char type) {
printf("# %5d MB %16s (type %2x): sectors %9d-%9d\n",
((nextstart-start)+1024)/2048, msg, type, start, nextstart-1);
}
int
create_extended_partition(int fd, int secno, int size) {
int sec = secno;
int cursec = secno;
int pno = partno; /* number of extd partition */
int ei = eptsct-1;
unsigned char type = 0x5;
int lastseen = secno;
int ok = 0;
if (epts[ei].secno != secno) {
fprintf(stderr, "%s: program bug\n", progname);
exit(1);
}
outmsg("candidate ext pt", secno, secno+1, type);
addpart(secno, 1, type); /* size to be filled in later */
while(1) {
char buf[512];
struct partition *p1, *p2, *pr, *pe;
p1 = (struct partition *)(& epts[ei].pt4[0]);
p2 = (struct partition *)(& epts[ei].pt4[16]);
/* for the time being we just ignore the rest */
if (is_extended(p1->sys_type)) {
pr = p2;
pe = p1;
} else if (is_extended(p2->sys_type)) {
pr = p1;
pe = p2;
} else if (p1->sys_type == 0) {
pr = p2;
pe = 0;
} else if (p2->sys_type == 0) {
pr = p1;
pe = 0;
} else
break;
/* first handle the real partition, if any */
if (pr->sys_type != 0) {
int ss = cursec + pr->start_sect;
int es = ss + pr->nr_sects;
outmsg("found in ept", ss, es, pr->sys_type);
addpart(ss, pr->nr_sects, pr->sys_type);
if (lastseen < es - 1)
lastseen = es - 1;
if (lastseen >= size)
break;
}
/* then the extended link */
if (!pe) {
ok = 1;
break;
}
type = pe->sys_type;
cursec = sec + pe->start_sect;
if (cursec >= size)
break;
read_sectors(fd, buf, cursec, 1);
addepts(cursec, buf);
ei = eptsct-1;
}
if (!ok || lastseen == secno) {
printf("# retracted\n");
partno = pno;
return 0;
}
pts[pno].type = type;
pts[pno].size = lastseen+1-secno;
outmsg("extended part ok", secno, lastseen+1, type);
return lastseen;
}
/*
* Recognize an ext2 superblock
*/
#define EXT2_SUPER_MAGIC 0xEF53
struct ext2_super_block {
uint32 s_inodes_count; /* 0: Inodes count */
uint32 s_blocks_count; /* 4: Blocks count */
uint32 s_r_blocks_count; /* 8: Reserved blocks count */
uint32 s_free_blocks_count; /* 12: Free blocks count */
uint32 s_free_inodes_count; /* 16: Free inodes count */
uint32 s_first_data_block; /* 20: First Data Block */
uint32 s_log_block_size; /* 24: Block size */
sint32 s_log_frag_size; /* 28: Fragment size */
uint32 s_blocks_per_group; /* 32: # Blocks per group */
uint32 s_frags_per_group; /* 36: # Fragments per group */
uint32 s_inodes_per_group; /* 40: # Inodes per group */
uint32 s_mtime; /* 44: Mount time */
uint32 s_wtime; /* 48: Write time */
uint16 s_mnt_count; /* 52: Mount count */
sint16 s_max_mnt_count; /* 54: Maximal mount count */
uint16 s_magic; /* 56: Magic signature */
uint16 s_state; /* 58: File system state */
uint16 s_errors; /* 60: Behaviour when detecting errors */
uint16 s_minor_rev_level; /* 62: minor revision level */
uint32 s_lastcheck; /* 64: time of last check */
uint32 s_checkinterval; /* 68: max. time between checks */
uint32 s_creator_os; /* 72: OS */
uint32 s_rev_level; /* 76: Revision level */
uint16 s_def_resuid; /* 80: Default uid for reserved blocks */
uint16 s_def_resgid; /* 82: Default gid for reserved blocks */
/* more stuff in later versions - especially s_block_group_nr is useful */
uint32 s_first_ino; /* 84: First non-reserved inode */
uint16 s_inode_size; /* 88: size of inode structure */
uint16 s_block_group_nr; /* 90: block group # of this superblock */
uint32 s_feature_compat; /* 92: compatible feature set */
uint32 s_feature_incompat; /* 96: incompatible feature set */
uint32 s_feature_ro_compat; /* 100: readonly-compatible feature set */
uchar s_uuid[16]; /* 104: 128-bit uuid for volume */
char s_volume_name[16]; /* 120: volume name */
char s_last_mounted[64]; /* 136: directory where last mounted */
uint32 s_algorithm_usage_bitmap;/* 200: For compression */
uchar s_prealloc_blocks; /* 204: Nr of blocks to try to preallocate*/
uchar s_prealloc_dir_blocks; /* 205: Nr to preallocate for dirs */
uchar s_reserved[818]; /* 206-1023 */
};
/*
* Heuristic to weed out false alarms for ext2 superblocks.
* Recompile this after 2005, of if you destroy things that
* have not been written the past ten years.
*/
#define YEAR (60*60*24*365)
#define LOWERLIMIT (1992-1970)*YEAR
#define UPPERLIMIT (2005-1970)*YEAR
int
is_time(uint32 t) {
return (t >= LOWERLIMIT && t <= UPPERLIMIT);
}
int
is_ztime(uint32 t) {
return (t == 0 || (t >= LOWERLIMIT && t <= UPPERLIMIT));
}
/*
* Recognize a FAT filesystem
*/
struct fat_boot_sector_start {
uchar jump_code[3]; /* 0: Bootstrap short or near jump */
/* usually jump code (e.g. eb 3e or eb 58) + nop (0x90) */
uchar system_id[8]; /* 3: OEM Name */
/* fat16: MSDOS5.0 or MSWIN4.0 or ... */
/* fat32: MSWIN4.1 (=W95 OSR2) */
/* BIOS Parameter Block (BPB) */
uchar sector_size[2]; /* 11: bytes/sector (usually 512 or 2048) */
uchar cluster_size; /* 13: sectors/cluster (a power of two in 1..128) */
uint16 reserved; /* 14: reserved sectors (I see 1 for FAT16, 17 for FAT32) */
/* The # of sectors preceding the first FAT,
including the boot sector, so at least 1 */
uchar fats; /* 16: # of copies of FAT (usually 2) */
uchar dir_entries[2]; /* 17: max # of root directory entries (n/a for FAT32) */
/* (usually 512; 0 for FAT32) */
uchar sectors[2]; /* 19: total # of sectors (in <32MB partn) or 0 */
uchar media; /* 21: media code (0xf8 for hard disks) */
uint16 fat_length; /* 22: sectors/FAT (n/a: 0 for FAT32) */
uint16 secs_track; /* 24: S = # sectors/track (in 1..63) */
uint16 heads; /* 26: H = # of heads (in 1..255) */
uint32 hidden; /* 28: # of hidden sectors in partition, before boot sector */
/* (offset from cyl boundary - often equal to S) */
uint32 total_sect; /* 32: # of sectors (if sectors == 0) */
};
/* Media descriptor byte:
f8 hard disk
Floppy types:
f0 3.5" 36/2/80 2880k
f0 3.5" 18/2/80 1440k
f9 3.5" 9/2/80 720k
f9 5.25" 15/2/80 1200k
fa both 9/1/80 320k
fb both 9/2/80 640k
fc 5.25" 9/1/40 180k
fd 5.25" 9/2/40 360k
fe 5.25" 8/1/40 160k
ff 5.25" 8/2/40 320k
Conclusion: this byte does not differentiate between 3.5" and 5.25",
it does not give the capacity or the number of sectors per track.
However, maybe C and H can be derived.
*/
struct fat_boot_sector_middle { /* offset 36-61 for FAT16, 64-89 for FAT32 */
/* Extended BIOS Parameter Block */
uchar drive_number; /* 0: logical drive number of partition */
/* (typically 0 for floppy, 0x80 for each disk) */
uchar current_head; /* Originally: track containing boot record. (Usually 0)
For WNT: bit 0: dirty: chkdsk must be run
bit 1: also run surface scan */
uchar extd_signature; /* 2: extended signature (0x29) */
/* WNT requires either 0x28 or 0x29 */
uchar serial_nr[4]; /* 3: serial number of partition */
uchar volume_name[11];/* 7: volume name of partition */
/* WNT stores the volume label as a special file
in the root directory */
uchar fs_name[8]; /* 18: filesystem name (FAT12, FAT16, FAT32) */
};
struct fat16_boot_sector {
struct fat_boot_sector_start s; /* 0-35 */
struct fat_boot_sector_middle m; /* 36-61 */
uchar boot_code[448]; /* 62-509 */
uchar signature[2]; /* 510-511: aa55 */
};
struct fat32_boot_sector {
struct fat_boot_sector_start s; /* 0-35 */
uint32 fat32_length; /* 36: sectors/FAT */
uint16 flags; /* 40: bit 7: fat mirroring, low 4: active fat */
/* If mirroring is disabled (bit8 set) the FAT
info is only written to the active FAT copy. */
uchar version[2]; /* 42: major, minor filesystem version */
uint32 root_cluster; /* 44: first cluster in root directory */
uint16 info_sector; /* 48: filesystem info sector # relative
to partition start (usually 1) */
uint16 backup_boot; /* 50: backup boot sector # relat. to part. start */
uint16 reserved2[6]; /* 52-63: Unused */
struct fat_boot_sector_middle m; /* 64-89 */
uchar boot_code[420]; /* 90-509 */
uchar signature[2]; /* 510-511: aa55 */
};
/*
* The boot code contains message strings ("Invalid system disk")
* but these are often localized ("Ongeldige diskette ").
* After these messages one finds two or three filenames.
* (MSDOS 6.2: "\r\nNon-System disk or disk error\r\n"
* "Replace and press any key when ready\r\n", "IO SYS", "MSDOS SYS")
* (W95: "IO SYS", "MSDOS SYS", "WINBOOT SYS")
* In all cases the sector seems to end with 0, 0, 55, aa.
*
* Random collection of messages (closed by \0377 or 0):
* "\r\nInvalid system disk"
* "\r\nOngeldige diskette "
* "\r\nDisk I/O error"
* "\r\nI/O-fout "
* "\r\nReplace the disk, and then press any key\r\n"
* "\r\nVervang de diskette en druk op een toets\r\n"
* This seems to suggest that the localized strings have the same length.
*
* "Non-System disk or disk error"
* "Replace and press any key when ready"
* "Disk Boot failure"
*
* "BOOT: Couldn't find NTLDR"
* "I/O error reading disk"
* "Please insert another disk"
*/
struct fat32_boot_fsinfo {
uint32 signature1; /* 41 61 52 52 */
uchar unknown1[480];
uint32 signature2; /* 61 41 72 72 0x61417272L */
uint32 free_clusters; /* Free cluster count. -1 if unknown */
uint32 next_cluster; /* Most recently allocated cluster.
* Unused under Linux. */
uchar unknown2[14];
uchar signature[2]; /* 510-511: aa55 */
};
struct msdos_dir_entry {
uchar name[8],ext[3]; /* name and extension */
uchar attr; /* attribute bits */
uchar lcase; /* Case for base and extension */
uchar ctime_ms; /* Creation time, milliseconds */
uint16 ctime; /* Creation time */
uint16 cdate; /* Creation date */
uint16 adate; /* Last access date */
uint16 starthi; /* High 16 bits of cluster in FAT32 */
uint16 time,date,start;/* time, date and first cluster */
uint32 size; /* file size (in bytes) */
};
/* New swap space */
struct swap_header_v1 {
char bootbits[1024]; /* Space for disklabel etc. */
unsigned int version;
unsigned int last_page;
unsigned int nr_badpages;
unsigned int padding[125];
unsigned int badpages[1];
};
struct unixware_slice {
unsigned short slice_type;
unsigned short slice_flags;
unsigned int start;
unsigned int size;
};
struct bsd_disklabel {
uchar d_magic[4];
uchar d_stuff1[4];
uchar d_typename[16]; /* type name, e.g. "eagle" */
uchar d_packname[16]; /* pack identifier */
uint32 d_secsize; /* # of bytes per sector */
uint32 d_nsectors; /* # of data sectors per track */
uint32 d_ntracks; /* # of tracks per cylinder */
uint32 d_ncylinders; /* # of data cylinders per unit */
uint32 d_secpercyl; /* # of data sectors per cylinder */
uint32 d_secperunit; /* # of data sectors per unit */
uchar d_stuff2[68];
uchar d_magic2[4]; /* the magic number (again) */
uint16 d_checksum; /* xor of data incl. partitions */
/* filesystem and partition information: */
uint16 d_npartitions; /* number of partitions in following */
uint32 d_bbsize; /* size of boot area at sn0, bytes */
uint32 d_sbsize; /* max size of fs superblock, bytes */
struct bsd_partition { /* the partition table */
uint32 p_size; /* number of sectors in partition */
uint32 p_offset; /* starting sector */
uchar p_stuff[8];
} d_partitions[16]; /* 16 is for openbsd */
};
int
main(int argc, char **argv){
int i,j,fd;
long size;
int pagesize, pagesecs;
unsigned char *bp;
struct ext2_super_block *e2bp;
struct fat16_boot_sector *fat16bs;
struct fat32_boot_sector *fat32bs;
progname = argv[0];
if (argc != 2) {
fprintf(stderr, "call: %s device\n", progname);
exit(1);
}
device = argv[1];
fd = open(device, O_RDONLY);
if (fd < 0) {
perror(device);
fprintf(stderr, "%s: could not open %s\n", progname, device);
exit(1);
}
if (ioctl(fd, BLKGETSIZE, &size)) {
struct stat s;
perror("BLKGETSIZE");
fprintf(stderr, "%s: could not get device size\n", progname);
if (stat(device, &s)) {
fprintf(stderr, "and also stat fails. Aborting.\n");
exit(1);
}
size = s.st_size / 512;
}
pagesize = getpagesize();
if (pagesize <= 0)
pagesize = 4096;
else if (pagesize > MAXPAGESZ) {
fprintf(stderr, "%s: ridiculous pagesize %d\n", progname, pagesize);
exit(1);
}
pagesecs = pagesize/512;
printf("# partition table of %s\n", device);
printf("# total size %d sectors\n", size);
printf("unit: sectors\n");
for(i=0; i<size; i++) {
if (i/BUFSECS != bufstart) {
int len, secno;
bufstart = i/BUFSECS;
secno = bufstart*BUFSECS;
len = BUFSECS;
if (size - secno < len)
len = size - secno;
len = (len / 2)*2; /* avoid reading the last (odd) sector */
read_sectors(fd, buf, secno, len);
}
j = i % BUFSECS;
bp = buf + 512 * j;
if (bp[510] == 0x55 && bp[511] == 0xAA) {
char *cp = bp+512-2-64;
int j;
if (i==0)
continue; /* the MBR is supposed to be broken */
/* Unfortunately one finds extended partition table sectors
that look just like a fat boot sector, except that the
partition table bytes have been overwritten */
/* typical FAT32 end: "nd then press ...", followed by
IO.SYS and MSDOS.SYS and WINBOOT.SYS directory entries.
typical extd part tab end: 2 entries, 32 nul bytes */
for(j=0; j<32; j++)
if (cp[32+j])
goto nonzero;
addepts(i, bp);
if (i > 0) {
j = create_extended_partition(fd, i, size);
if (j && j > i)
i = j; /* skip */
}
continue;
nonzero:
fat16bs = (struct fat16_boot_sector *) bp;
if (fat16bs->s.media == 0xf8 &&
fat16bs->m.extd_signature == 0x29 &&
!strncmp(fat16bs->m.fs_name, "FAT", 3)) {
int lth;
lth = fat16bs->s.sectors[0] +
fat16bs->s.sectors[1]*256;
if (lth) {
outmsg("small fat partition", i, i+lth, 0x1);
addpart(i, lth, 0x1);
} else {
lth = fat16bs->s.total_sect;
outmsg("fat partition", i, i+lth, 0x6);
addpart(i, lth, 0x6);
}
i = i+lth-1; /* skip */
continue;
}
fat32bs = (struct fat32_boot_sector *) bp;
if (fat32bs->s.media == 0xf8 &&
fat32bs->m.extd_signature == 0x29 &&
!strncmp(fat32bs->m.fs_name, "FAT32 ", 8)) {
int lth = fat32bs->s.total_sect;
outmsg("fat32 partition", i, i+lth, 0xb); /* or 0xc */
addpart(i, lth, 0xb);
i = i+lth-1; /* skip */
continue;
}
}
if (!strncmp(bp+502, "SWAP-SPACE", 10)) {
char *last;
int ct;
int ss = i-pagesecs+1;
int es;
char buf2[MAXPAGESZ];
read_sectors(fd, buf2, ss, pagesecs);
for (last = buf2+pagesize-10-1; last > buf2; last--)
if (*last)
break;
for (ct = 7; ct >= 0; ct--)
if (*last & (1<<ct))
break;
es = ((last - buf2)*8 + ct + 1)*pagesecs + ss;
if (es <= size) {
outmsg("old swap space", ss, es, 0x82);
addpart(ss, es-ss, 0x82);
i = es-1; /* skip */
continue;
}
}
if (!strncmp(bp+502, "SWAPSPACE2", 10)) {
int ss = i-pagesecs+1;
int es, lth;
char buf2[MAXPAGESZ];
struct swap_header_v1 *p;
read_sectors(fd, buf2, ss, pagesecs);
p = (struct swap_header_v1 *) buf2;
lth = (p->last_page + 1)* pagesecs;
es = ss + lth;
if (es <= size) {
outmsg("new swap space", ss, es, 0x82);
addpart(ss, lth, 0x82);
i = es-1; /* skip */
continue;
}
}
e2bp = (struct ext2_super_block *) bp;
if (e2bp->s_magic == EXT2_SUPER_MAGIC && is_time(e2bp->s_mtime)
&& is_time(e2bp->s_wtime) && is_ztime(e2bp->s_lastcheck)
&& e2bp->s_log_block_size <= 10 /* at most 1 MB blocks */) {
char buf[512];
struct ext2_super_block *bp2;
int ss, sz, es, gsz, j;
ss = i-2;
sz = (e2bp->s_blocks_count << (e2bp->s_log_block_size + 1));
gsz = (e2bp->s_blocks_per_group << (e2bp->s_log_block_size + 1));
if (e2bp->s_block_group_nr > 0)
ss -= gsz * e2bp->s_block_group_nr;
es = ss + sz;
if (ss > 0 && es > i && es <= size) {
if (e2bp->s_block_group_nr == 0) {
outmsg("ext2 partition", ss, es, 0x83);
addpart(ss, es-ss, 0x83);
i = es-1; /* skip */
continue;
}
/* maybe we jumped into the middle of a partially
obliterated ext2 partition? */
printf("# sector %d looks like an ext2 superblock copy #%d;\n"
"# in a partition covering sectors %d-%d\n",
i, e2bp->s_block_group_nr, ss, es-1);
for (j=1; j<=e2bp->s_block_group_nr; j++) {
read_sectors(fd, buf, i-j*gsz, 1);
bp2 = (struct ext2_super_block *) buf;
if (bp2->s_magic != EXT2_SUPER_MAGIC ||
bp2->s_block_group_nr !=
e2bp->s_block_group_nr - j)
break;
}
if (j == 1)
printf("# however, sector %d doesnt look like a sb.\n",
i-gsz);
else if (j <= e2bp->s_block_group_nr)
printf("# also the preceding %d block groups seem OK\n"
"# but before that things seem to be wrong.\n",
j-1);
else {
printf("# found all preceding superblocks OK\n"
"# Warning: overlapping partitions?\n");
outmsg("ext2 partition", ss, es, 0x83);
addpart(ss, es-ss, 0x83);
i = es-1; /* skip */
continue;
}
}
}
if (bp[4] == 0x0d && bp[5] == 0x60 &&
bp[6] == 0x5e && bp[7] == 0xca && /* CA5E600D */
bp[156] == 0xee && bp[157] == 0xde &&
bp[158] == 0x0d && bp[159] == 0x60) /* 600DDEEE */ {
int ss, es;
struct unixware_slice *u;
printf("# Unixware partition seen\n");
u = (struct unixware_slice *)(bp + 216);
if (u->slice_type == 5 /* entire disk */
&& (u->slice_flags & 0x200)) /* valid */ {
ss = u->start;
es = u->start + u->size;
outmsg("Unixware ptn", ss, es, 0x63);
addpart(ss, es-ss, 0x63);
i = es-1;
continue;
} else
printf("# Unrecognized details\n");
}
/* bsd disk magic 0x82564557UL */
if (bp[0] == 0x57 && bp[1] == 0x45 && bp[2] == 0x56 && bp[3] == 0x82) {
int ss, es, npts, j;
struct bsd_disklabel *l;
struct bsd_partition *p;
printf("# BSD magic seen in sector %d\n", i);
l = (struct bsd_disklabel *) bp;
if (l->d_magic2[0] != 0x57 || l->d_magic2[1] != 0x45 ||
l->d_magic2[2] != 0x56 || l->d_magic2[3] != 0x82)
printf("# 2nd magic bad - ignored this sector\n");
else if ((npts = l->d_npartitions) > 16)
printf("# strange number (%d) of subpartitions - "
"ignored this sector\n", npts);
else {
for (j=0; j<npts; j++) {
p = &(l->d_partitions[j]);
if (p->p_size)
printf("# part %c: size %9d, start %9d\n",
'a'+j, p->p_size, p->p_offset);
}
ss = l->d_partitions[2].p_offset;
es = ss + l->d_partitions[2].p_size;
if (ss != i-1)
printf("# strange start of whole disk - "
"ignored this sector\n");
else {
/* FreeBSD 0xa5, OpenBSD 0xa6, NetBSD 0xa9, BSDI 0xb7 */
/* How to distinguish? */
outmsg("BSD partition", ss, es, 0xa5);
addpart(ss, es-ss, 0xa5);
i = es-1;
continue;
}
}
}
}
outparts();
exit(0);
}
syntax highlighted by Code2HTML, v. 0.9.1