/* * 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; }