/*
* Protective (legacy) MBR.
*
* This MBR contains standard DOS partition table with a single partition, type
* of 0xEE. The partition usually encompassing the entire GPT drive - or 2TiB
* for large disks.
*
* Note that Apple uses GPT/MBR hybrid disks, where the DOS partition table is
* synchronized with GPT. This synchronization has many restriction of course
* (due DOS PT limitations).
*
* Note that the PMBR detection is optional (enabled by default) and could be
* disabled by BLKID_PARTS_FOPCE_GPT flag (see also blkid_partitions_set_flags()).
*/
static int is_pmbr_valid(blkid_probe pr, int *has)
{
int flags = blkid_partitions_get_flags(pr);
unsigned char *data;
struct dos_partition *p;
int i;
if (has)
*has = 0;
if (flags & BLKID_PARTS_FORCE_GPT)
goto ok; /* skip PMBR check */
data = blkid_probe_get_sector(pr, 0);
if (!data) {
if (errno)
return -errno;
goto failed;
}
if (!mbr_is_valid_magic(data))
goto failed;
for (i = 0, p = mbr_get_partition(data, 0); i < 4; i++, p++) {
if (p->sys_ind == MBR_GPT_PARTITION)
goto ok;
}
failed:
return 0;
ok:
if (has)
*has = 1;
return 1;
}
static int fat_valid_superblock(blkid_probe pr,
const struct blkid_idmag *mag,
struct msdos_super_block *ms,
struct vfat_super_block *vs,
uint32_t *cluster_count, uint32_t *fat_size)
{
uint16_t sector_size, dir_entries, reserved;
uint32_t sect_count, __fat_size, dir_size, __cluster_count, fat_length;
uint32_t max_count;
/* extra check for FATs without magic strings */
if (mag->len <= 2) {
/* Old floppies have a valid MBR signature */
if (ms->ms_pmagic[0] != 0x55 || ms->ms_pmagic[1] != 0xAA)
return 0;
/*
* OS/2 and apparently DFSee will place a FAT12/16-like
* pseudo-superblock in the first 512 bytes of non-FAT
* filesystems --- at least JFS and HPFS, and possibly others.
* So we explicitly check for those filesystems at the
* FAT12/16 filesystem magic field identifier, and if they are
* present, we rule this out as a FAT filesystem, despite the
* FAT-like pseudo-header.
*/
if ((memcmp(ms->ms_magic, "JFS ", 8) == 0) ||
(memcmp(ms->ms_magic, "HPFS ", 8) == 0))
return 0;
}
/* fat counts(Linux kernel expects at least 1 FAT table) */
if (!ms->ms_fats)
return 0;
if (!ms->ms_reserved)
return 0;
if (!(0xf8 <= ms->ms_media || ms->ms_media == 0xf0))
return 0;
if (!is_power_of_2(ms->ms_cluster_size))
return 0;
sector_size = unaligned_le16(&ms->ms_sector_size);
if (!is_power_of_2(sector_size) ||
sector_size < 512 || sector_size > 4096)
return 0;
dir_entries = unaligned_le16(&ms->ms_dir_entries);
reserved = le16_to_cpu(ms->ms_reserved);
sect_count = unaligned_le16(&ms->ms_sectors);
if (sect_count == 0)
sect_count = le32_to_cpu(ms->ms_total_sect);
fat_length = le16_to_cpu(ms->ms_fat_length);
if (fat_length == 0)
fat_length = le32_to_cpu(vs->vs_fat32_length);
__fat_size = fat_length * ms->ms_fats;
dir_size = ((dir_entries * sizeof(struct vfat_dir_entry)) +
(sector_size-1)) / sector_size;
__cluster_count = (sect_count - (reserved + __fat_size + dir_size)) /
ms->ms_cluster_size;
if (!ms->ms_fat_length && vs->vs_fat32_length)
max_count = FAT32_MAX;
else
max_count = __cluster_count > FAT12_MAX ? FAT16_MAX : FAT12_MAX;
if (__cluster_count > max_count)
return 0;
if (fat_size)
*fat_size = __fat_size;
if (cluster_count)
*cluster_count = __cluster_count;
#if 0
if (blkid_probe_is_wholedisk(pr)) {
/* OK, seems like FAT, but it's possible that we found boot
* sector with crazy FAT-like stuff (magic strings, media,
* etc..) before MBR. Let's make sure that there is no MBR with
* usable partition. */
unsigned char *buf = (unsigned char *) ms;
if (mbr_is_valid_magic(buf)) {
struct dos_partition *p0 = mbr_get_partition(buf, 0);
if (dos_partition_get_size(p0) != 0 &&
(p0->boot_ind == 0 || p0->boot_ind == 0x80))
return 0;
}
}
#endif
return 1; /* valid */
}
static int parse_dos_extended(blkid_probe pr, blkid_parttable tab,
uint32_t ex_start, uint32_t ex_size, int ssf)
{
blkid_partlist ls = blkid_probe_get_partlist(pr);
uint32_t cur_start = ex_start, cur_size = ex_size;
unsigned char *data;
int ct_nodata = 0; /* count ext.partitions without data partitions */
int i;
DBG(LOWPROBE, ul_debug("parse EBR [start=%d, size=%d]", ex_start/ssf, ex_size/ssf));
if (ex_start == 0) {
DBG(LOWPROBE, ul_debug("Bad offset in primary extended partition -- ignore"));
return 0;
}
while (1) {
struct dos_partition *p, *p0;
uint32_t start, size;
if (++ct_nodata > 100)
return BLKID_PROBE_OK;
data = blkid_probe_get_sector(pr, cur_start);
if (!data) {
if (errno)
return -errno;
goto leave; /* malformed partition? */
}
if (!mbr_is_valid_magic(data))
goto leave;
p0 = mbr_get_partition(data, 0);
/* Usually, the first entry is the real data partition,
* the 2nd entry is the next extended partition, or empty,
* and the 3rd and 4th entries are unused.
* However, DRDOS sometimes has the extended partition as
* the first entry (when the data partition is empty),
* and OS/2 seems to use all four entries.
* -- Linux kernel fs/partitions/dos.c
*
* See also http://en.wikipedia.org/wiki/Extended_boot_record
*/
/* Parse data partition */
for (p = p0, i = 0; i < 4; i++, p++) {
uint32_t abs_start;
blkid_partition par;
/* the start is relative to the parental ext.partition */
start = dos_partition_get_start(p) * ssf;
size = dos_partition_get_size(p) * ssf;
abs_start = cur_start + start; /* absolute start */
if (!size || is_extended(p))
continue;
if (i >= 2) {
/* extra checks to detect real data on
* 3rd and 4th entries */
if (start + size > cur_size)
continue;
if (abs_start < ex_start)
continue;
if (abs_start + size > ex_start + ex_size)
continue;
}
/* Avoid recursive non-empty links, see ct_nodata counter */
if (blkid_partlist_get_partition_by_start(ls, abs_start)) {
DBG(LOWPROBE, ul_debug("#%d: EBR duplicate data partition [abs start=%u] -- ignore",
i + 1, abs_start));
continue;
}
par = blkid_partlist_add_partition(ls, tab, abs_start, size);
if (!par)
return -ENOMEM;
blkid_partition_set_type(par, p->sys_ind);
blkid_partition_set_flags(par, p->boot_ind);
blkid_partition_gen_uuid(par);
ct_nodata = 0;
}
/* The first nested ext.partition should be a link to the next
* logical partition. Everything other (recursive ext.partitions)
* is junk.
*/
for (p = p0, i = 0; i < 4; i++, p++) {
start = dos_partition_get_start(p) * ssf;
size = dos_partition_get_size(p) * ssf;
if (size && is_extended(p)) {
if (start == 0)
DBG(LOWPROBE, ul_debug("#%d: EBR link offset is zero -- ignore", i + 1));
else
break;
}
}
if (i == 4)
goto leave;
cur_start = ex_start + start;
cur_size = size;
}
leave:
return BLKID_PROBE_OK;
}
static int sgi_create_disklabel(struct fdisk_context *cxt)
{
struct hd_geometry geometry;
struct {
unsigned int start;
unsigned int nsect;
int sysid;
} old[4];
int i=0;
sector_t llsectors;
int res; /* the result from the ioctl */
int sec_fac; /* the sector factor */
sec_fac = cxt->sector_size / 512; /* determine the sector factor */
fprintf(stderr,
_("Building a new SGI disklabel.\n"));
other_endian = (BYTE_ORDER == LITTLE_ENDIAN);
res = blkdev_get_sectors(cxt->dev_fd, &llsectors);
#ifdef HDIO_GETGEO
if (ioctl(cxt->dev_fd, HDIO_GETGEO, &geometry) < 0)
err(EXIT_FAILURE, _("HDIO_GETGEO ioctl failed on %s"), cxt->dev_path);
cxt->geom.heads = geometry.heads;
cxt->geom.sectors = geometry.sectors;
if (res == 0) {
/* the get device size ioctl was successful */
sector_t llcyls;
llcyls = llsectors / (cxt->geom.heads * cxt->geom.sectors * sec_fac);
cxt->geom.cylinders = llcyls;
if (cxt->geom.cylinders != llcyls) /* truncated? */
cxt->geom.cylinders = ~0;
} else {
/* otherwise print error and use truncated version */
cxt->geom.cylinders = geometry.cylinders;
fprintf(stderr,
_("Warning: BLKGETSIZE ioctl failed on %s. "
"Using geometry cylinder value of %llu.\n"
"This value may be truncated for devices"
" > 33.8 GB.\n"), cxt->dev_path, cxt->geom.cylinders);
}
#endif
/*
* Convert old MBR to SGI label, make it DEPRECATED, this feature
* has to be handled in by any top-level fdisk command.
*/
for (i = 0; i < 4; i++) {
old[i].sysid = 0;
if (mbr_is_valid_magic(cxt->firstsector)) {
if (get_part_table(i)->sys_ind) {
old[i].sysid = get_part_table(i)->sys_ind;
old[i].start = get_start_sect(get_part_table(i));
old[i].nsect = get_nr_sects(get_part_table(i));
if (debug)
printf(_("ID=%02x\tSTART=%d\tLENGTH=%d\n"),
old[i].sysid, old[i].start, old[i].nsect);
}
}
}
for (i = 0; i < 4; i++)
if (old[i].sysid) {
printf(_("Trying to keep parameters of partitions already set.\n"));
break;
}
fdisk_zeroize_firstsector(cxt);
sgilabel->magic = SSWAP32(SGI_LABEL_MAGIC);
sgilabel->boot_part = SSWAP16(0);
sgilabel->swap_part = SSWAP16(1);
/* sizeof(sgilabel->boot_file) = 16 > 6 */
memset(sgilabel->boot_file, 0, 16);
strcpy((char *) sgilabel->boot_file, "/unix");
sgilabel->devparam.skew = (0);
sgilabel->devparam.gap1 = (0);
sgilabel->devparam.gap2 = (0);
sgilabel->devparam.sparecyl = (0);
sgilabel->devparam.pcylcount = SSWAP16(geometry.cylinders);
sgilabel->devparam.head_vol0 = SSWAP16(0);
sgilabel->devparam.ntrks = SSWAP16(geometry.heads);
/* tracks/cylinder (heads) */
sgilabel->devparam.cmd_tag_queue_depth = (0);
sgilabel->devparam.unused0 = (0);
sgilabel->devparam.unused1 = SSWAP16(0);
sgilabel->devparam.nsect = SSWAP16(geometry.sectors);
/* sectors/track */
sgilabel->devparam.bytes = SSWAP16(cxt->sector_size);
sgilabel->devparam.ilfact = SSWAP16(1);
sgilabel->devparam.flags = SSWAP32(TRACK_FWD|\
IGNORE_ERRORS|RESEEK);
sgilabel->devparam.datarate = SSWAP32(0);
sgilabel->devparam.retries_on_error = SSWAP32(1);
sgilabel->devparam.ms_per_word = SSWAP32(0);
sgilabel->devparam.xylogics_gap1 = SSWAP16(0);
sgilabel->devparam.xylogics_syncdelay = SSWAP16(0);
sgilabel->devparam.xylogics_readdelay = SSWAP16(0);
sgilabel->devparam.xylogics_gap2 = SSWAP16(0);
sgilabel->devparam.xylogics_readgate = SSWAP16(0);
sgilabel->devparam.xylogics_writecont = SSWAP16(0);
memset(&(sgilabel->directory), 0, sizeof(struct volume_directory)*15);
memset(&(sgilabel->partitions), 0, sizeof(struct sgi_partition)*16);
cxt->disklabel = FDISK_DISKLABEL_SGI;
partitions = 16;
volumes = 15;
sgi_set_entire(cxt);
sgi_set_volhdr(cxt);
for (i = 0; i < 4; i++) {
if (old[i].sysid) {
sgi_set_partition(cxt, i, old[i].start, old[i].nsect, old[i].sysid);
}
}
return 0;
}
