/* $NetBSD: mbr.c,v 1.46 2022/07/10 12:49:05 martin Exp $ */ /* * Copyright 1997 Piermont Information Systems Inc. * All rights reserved. * * Written by Philip A. Nelson for Piermont Information Systems Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of Piermont Information Systems Inc. may not be used to endorse * or promote products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * */ /* * Following applies to the geometry guessing code */ /* * Mach Operating System * Copyright (c) 1992 Carnegie Mellon University * All Rights Reserved. * * Permission to use, copy, modify and distribute this software and its * documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie Mellon * the rights to redistribute these changes. */ /* mbr.c -- DOS Master Boot Record editing code */ #ifdef HAVE_MBR #include #include #include #include #include #include #include #include #include #include #include "defs.h" #include "mbr.h" #include "md.h" #include "msg_defs.h" #include "menu_defs.h" #include "defsizes.h" #include "endian.h" #define NO_BOOTMENU (-0x100) #define MAXCYL 1023 /* Possibly 1024 */ #define MAXHEAD 255 /* Possibly 256 */ #define MAXSECTOR 63 #define MBR_UNKNOWN_PTYPE 94 /* arbitrary not widely used value */ /* A list of predefined partition types */ const struct { unsigned int ptype; const char *desc; } mbr_part_types_src[] = { { .ptype=MBR_PTYPE_NETBSD, .desc="NetBSD" }, { .ptype=MBR_PTYPE_FAT32L, .desc="Windows FAT32, LBA" }, { .ptype=MBR_PTYPE_EXT_LBA, .desc="Extended partition, LBA" }, { .ptype=MBR_PTYPE_386BSD, .desc="FreeBSD/386BSD" }, { .ptype=MBR_PTYPE_OPENBSD, .desc="OpenBSD" }, { .ptype=MBR_PTYPE_LNXEXT2, .desc="Linux native" }, { .ptype=MBR_PTYPE_LNXSWAP, .desc="Linux swap" }, { .ptype=MBR_PTYPE_NTFSVOL, .desc="NTFS volume set" }, { .ptype=MBR_PTYPE_NTFS, .desc="NTFS" }, { .ptype=MBR_PTYPE_PREP, .desc="PReP Boot" }, #ifdef MBR_PTYPE_SOLARIS { .ptype=MBR_PTYPE_SOLARIS, .desc="Solaris" }, #endif { .ptype=MBR_PTYPE_FAT12, .desc="DOS FAT12" }, { .ptype=MBR_PTYPE_FAT16S, .desc="DOS FAT16, <32M" }, { .ptype=MBR_PTYPE_FAT16B, .desc="DOS FAT16, >32M" }, { .ptype=MBR_PTYPE_FAT16L, .desc="Windows FAT16, LBA" }, { .ptype=MBR_PTYPE_FAT32, .desc="Windows FAT32" }, { .ptype=MBR_PTYPE_EFI, .desc="(U)EFI system partition" }, }; /* bookeeping of available partition types (including custom ones) */ struct mbr_part_type_info { struct part_type_desc gen; /* generic description */ char desc_buf[40], short_buf[10]; size_t next_ptype; /* user interface order */ }; const struct disk_partitioning_scheme mbr_parts; struct mbr_disk_partitions { struct disk_partitions dp, *dlabel; mbr_info_t mbr; uint ptn_alignment, ptn_0_offset, ext_ptn_alignment, geo_sec, geo_head, geo_cyl, target; }; const struct disk_partitioning_scheme mbr_parts; static size_t known_part_types = 0, last_added_part_type = 0; static const size_t first_part_type = MBR_PTYPE_NETBSD; /* all partition types (we are lucky, only a fixed number is possible) */ struct mbr_part_type_info mbr_gen_type_desc[256]; extern const struct disk_partitioning_scheme disklabel_parts; static void convert_mbr_chs(int, int, int, uint8_t *, uint8_t *, uint8_t *, uint32_t); static part_id mbr_add_part(struct disk_partitions *arg, const struct disk_part_info *info, const char **errmsg); static size_t mbr_get_free_spaces(const struct disk_partitions *arg, struct disk_part_free_space *result, size_t max_num_result, daddr_t min_size, daddr_t align, daddr_t lower_bound, daddr_t ignore); static size_t mbr_type_from_gen_desc(const struct part_type_desc *desc); /* * Notes on the extended partition editor. * * The extended partition structure is actually a singly linked list. * Each of the 'mbr' sectors can only contain 2 items, the first describes * a user partition (relative to that mbr sector), the second describes * the following partition (relative to the start of the extended partition). * * The 'start' sector for the user partition is always the size of one * track - very often 63. The extended partitions themselves should * always start on a cylinder boundary using the BIOS geometry - often * 16065 sectors per cylinder. * * The disk is also always described in increasing sector order. * * During editing we keep the mbr sectors accurate (it might have been * easier to use absolute sector numbers though), and keep a copy of the * entire sector - to preserve any information any other OS has tried * to squirrel away in the (apparently) unused space. * * Typical disk (with some small numbers): * * 0 -> a 63 37 dos * b 100 1000 extended LBA (type 15) * * 100 -> a 63 37 user * b 100 200 extended partition (type 5) * * 200 -> a 63 37 user * b 200 300 extended partition (type 5) * * 300 -> a 63 37 user * b 0 0 0 (end of chain) * */ #ifndef debug_extended #define dump_mbr(mbr, msg) #else static void dump_mbr(mbr_info_t *m, const char *label) { int i; uint ext_base = 0; fprintf(stderr, "\n%s: bsec %d\n", label, bsec); do { fprintf(stderr, "%p: %12u %p\n", m, m->sector, m->extended); for (i = 0; i < MBR_PART_COUNT; i++) { fprintf(stderr, " %*d %12u %12u %12" PRIu64, 10, m->mbr.mbr_parts[i].mbrp_type, m->mbr.mbr_parts[i].mbrp_start, m->mbr.mbr_parts[i].mbrp_size, (uint64_t)m->mbr.mbr_parts[i].mbrp_start + (uint64_t)m->mbr.mbr_parts[i].mbrp_size); if (m->sector == 0 && MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) ext_base = m->mbr.mbr_parts[i].mbrp_start; if (m->sector > 0 && m->mbr.mbr_parts[i].mbrp_size > 0) { uint off = MBR_IS_EXTENDED( m->mbr.mbr_parts[i].mbrp_type) ? ext_base : m->sector; fprintf(stderr, " -> [%u .. %u]", m->mbr.mbr_parts[i].mbrp_start + off, m->mbr.mbr_parts[i].mbrp_size + m->mbr.mbr_parts[i].mbrp_start + off); } fprintf(stderr, ",\n"); if (m->sector > 0 && i >= 1) break; } } while ((m = m->extended)); } #endif /* * Like pread, but handles re-blocking for non 512 byte sector disks */ static ssize_t blockread(int fd, size_t secsize, void *buf, size_t nbytes, off_t offset) { ssize_t nr; off_t sector = offset / 512; off_t offs = sector * (off_t)secsize; off_t mod = offs & (secsize - 1); off_t rnd = offs & ~(secsize - 1); char *iobuf; assert(nbytes <= 512); if (secsize == 512) return pread(fd, buf, nbytes, offset); iobuf = malloc(secsize); if (iobuf == NULL) return -1; nr = pread(fd, iobuf, secsize, rnd); if (nr == (off_t)secsize) memcpy(buf, &iobuf[mod], nbytes); free(iobuf); return nr == (off_t)secsize ? (off_t)nbytes : -1; } /* * Same for pwrite */ static ssize_t blockwrite(int fd, size_t secsize, const void *buf, size_t nbytes, off_t offset) { ssize_t nr; off_t sector = offset / secsize; off_t offs = sector * (off_t)secsize; off_t mod = offs & (secsize - 1); off_t rnd = offs & ~(secsize - 1); char *iobuf; assert(nbytes <= 512); if (secsize == 512) return pwrite(fd, buf, nbytes, offset); iobuf = malloc(secsize); if (iobuf == NULL) return -1; nr = pread(fd, iobuf, secsize, rnd); if (nr == (off_t)secsize) { memcpy(&iobuf[mod], buf, nbytes); nr = pwrite(fd, iobuf, secsize, rnd); } free(iobuf); return nr == (off_t)secsize ? (off_t)nbytes : -1; } static void free_last_mounted(mbr_info_t *m) { size_t i; for (i = 0; i < MBR_PART_COUNT; i++) free(__UNCONST(m->last_mounted[i])); } static void free_mbr_info(mbr_info_t *m) { if (m == NULL) return; free_last_mounted(m); free(m); } /* * To be used only on ports which cannot provide any bios geometry */ int set_bios_geom_with_mbr_guess(struct disk_partitions *parts) { int cyl, head, sec; msg_fmt_display(MSG_nobiosgeom, "%d%d%d", pm->dlcyl, pm->dlsec, pm->dlhead); if (guess_biosgeom_from_parts(parts, &cyl, &head, &sec) >= 0) msg_fmt_display_add(MSG_biosguess, "%d%d%d", cyl, head, sec); set_bios_geom(parts, &cyl, &head, &sec); if (parts->pscheme->change_disk_geom) parts->pscheme->change_disk_geom(parts, cyl, head, sec); return edit_outer_parts(parts); } static void mbr_init_chs(struct mbr_disk_partitions *parts, int ncyl, int nhead, int nsec) { if (ncyl > MAXCYL) ncyl = MAXCYL; pm->current_cylsize = nhead*nsec; pm->max_chs = (unsigned long)ncyl*nhead*nsec; parts->geo_sec = nsec; parts->geo_head = nhead; parts->geo_cyl = ncyl; } /* * get C/H/S geometry from user via menu interface and * store in globals. */ void set_bios_geom(struct disk_partitions *parts, int *cyl, int *head, int *sec) { char res[80]; int bsec, bhead, bcyl; daddr_t s; if (parts->pscheme->change_disk_geom == NULL) return; msg_display_add(MSG_setbiosgeom); do { snprintf(res, 80, "%d", *sec); msg_prompt_add(MSG_sectors, res, res, 80); bsec = atoi(res); } while (bsec <= 0 || bsec > MAXSECTOR); do { snprintf(res, 80, "%d", *head); msg_prompt_add(MSG_heads, res, res, 80); bhead = atoi(res); } while (bhead <= 0 || bhead > MAXHEAD); s = min(pm->dlsize, mbr_parts.size_limit); bcyl = s / bsec / bhead; if (s != bcyl * bsec * bhead) bcyl++; if (bcyl > MAXCYL) bcyl = MAXCYL; pm->max_chs = (unsigned long)bcyl * bhead * bsec; pm->current_cylsize = bhead * bsec; parts->pscheme->change_disk_geom(parts, bcyl, bhead, bsec); *cyl = bcyl; *head = bhead; *sec = bsec; } static int find_mbr_space(const struct mbr_info_t *mbrs, uint *start, uint *size, uint from, uint end_of_disk, uint ignore_at, bool primary_only) { uint sz; int i, j; uint s, e; const mbr_info_t *m, *me; bool is_extended; check_again: m = mbrs; sz = end_of_disk-from; if (from >= end_of_disk) return -1; for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; is_extended = MBR_IS_EXTENDED( m->mbr.mbr_parts[i].mbrp_type); s = m->mbr.mbr_parts[i].mbrp_start + m->sector; if (s == ignore_at) continue; e = s + m->mbr.mbr_parts[i].mbrp_size; if (s <= from && e > from && (!is_extended || primary_only)) { if (e - 1 >= end_of_disk) break; if (e >= UINT_MAX) { sz = 0; break; } from = e + 1; goto check_again; } if (s <= from && e > from && is_extended) { /* * if we start in the extended partition, * we must end before its end */ sz = e - from; } if (s > from && s - from < sz) sz = s - from; if (is_extended) { for (me = m->extended; me != NULL; me = me->extended) { for (j = 0; j < MBR_PART_COUNT; j++) { if (me->mbr.mbr_parts[j].mbrp_type == MBR_PTYPE_UNUSED) continue; is_extended = MBR_IS_EXTENDED( me->mbr.mbr_parts[j].mbrp_type); if (is_extended && i > 0) break; s = me->mbr.mbr_parts[j].mbrp_start + me->sector; if (s == ignore_at) continue; e = s + me->mbr.mbr_parts[j].mbrp_size; if (me->sector != 0 && me->sector< s) /* * can not allow to overwrite * the ext mbr */ s = me->sector; if (s <= from && e > from) { if (e - 1 >= end_of_disk) break; from = e + 1; goto check_again; } if (s > from && s - from < sz) sz = s - from; } } } } if (sz == 0) return -1; if (start != NULL) *start = from; if (size != NULL) *size = sz; return 0; } #ifdef BOOTSEL static int validate_and_set_names(mbr_info_t *mbri, const struct mbr_bootsel *src, uint32_t ext_base) { size_t i, l; const unsigned char *p; /* * The 16 bit magic used to detect whether mbr_bootsel is valid * or not is pretty week - collisions have been seen in the wild; * but maybe it is just foreign tools corruption reminiscents * of NetBSD MBRs. Anyway, before accepting a boot menu definition, * make sure it is kinda "sane". */ for (i = 0; i < MBR_PART_COUNT; i++) { /* * Make sure the name does not contain control chars * (not using iscntrl due to minimalistic locale support * in miniroot environments) and is properly 0-terminated. */ for (l = 0, p = (const unsigned char *)&src->mbrbs_nametab[i]; *p != 0; l++, p++) { if (l > MBR_BS_PARTNAMESIZE) return 0; if (*p < ' ') /* hacky 'iscntrl' */ return 0; } } memcpy(&mbri->mbrb, src, sizeof(*src)); if (ext_base == 0) return mbri->mbrb.mbrbs_defkey - SCAN_1; return 0; } #endif static int valid_mbr(struct mbr_sector *mbrs) { return (le16toh(mbrs->mbr_magic) == MBR_MAGIC); } static int read_mbr(const char *disk, size_t secsize, mbr_info_t *mbri, struct mbr_disk_partitions *parts) { struct mbr_partition *mbrp; struct mbr_sector *mbrs = &mbri->mbr; mbr_info_t *ext = NULL; char diskpath[MAXPATHLEN]; int fd, i; uint32_t ext_base = 0, next_ext = 0; int rval = -1; #ifdef BOOTSEL mbr_info_t *ombri = mbri; int bootkey = 0; #endif memset(mbri, 0, sizeof *mbri); /* Open the disk. */ fd = opendisk(disk, O_RDONLY, diskpath, sizeof(diskpath), 0); if (fd < 0) goto bad_mbr; for (;;) { if (blockread(fd, secsize, mbrs, sizeof *mbrs, (ext_base + next_ext) * (off_t)MBR_SECSIZE) - sizeof *mbrs != 0) break; if (!valid_mbr(mbrs)) break; mbrp = &mbrs->mbr_parts[0]; if (ext_base != 0) { /* sanity check extended chain */ if (MBR_IS_EXTENDED(mbrp[0].mbrp_type)) break; if (mbrp[1].mbrp_type != MBR_PTYPE_UNUSED && !MBR_IS_EXTENDED(mbrp[1].mbrp_type)) break; if (mbrp[2].mbrp_type != MBR_PTYPE_UNUSED || mbrp[3].mbrp_type != MBR_PTYPE_UNUSED) break; /* Looks ok, link into extended chain */ mbri->extended = ext; ext->extended = NULL; mbri = ext; ext = NULL; } #if BOOTSEL if (mbrs->mbr_bootsel_magic == htole16(MBR_MAGIC)) { /* old bootsel, grab bootsel info */ bootkey = validate_and_set_names(mbri, (struct mbr_bootsel *) ((uint8_t *)mbrs + MBR_BS_OLD_OFFSET), ext_base); } else if (mbrs->mbr_bootsel_magic == htole16(MBR_BS_MAGIC)) { /* new location */ bootkey = validate_and_set_names(mbri, &mbrs->mbr_bootsel, ext_base); } /* Save original flags for mbr code update tests */ mbri->oflags = mbri->mbrb.mbrbs_flags; #endif mbri->sector = next_ext + ext_base; next_ext = 0; rval = 0; for (i = 0; i < MBR_PART_COUNT; mbrp++, i++) { if (mbrp->mbrp_type == MBR_PTYPE_UNUSED) { /* type is unused, discard scum */ memset(mbrp, 0, sizeof *mbrp); continue; } mbrp->mbrp_start = le32toh(mbrp->mbrp_start); mbrp->mbrp_size = le32toh(mbrp->mbrp_size); if (MBR_IS_EXTENDED(mbrp->mbrp_type)) { next_ext = mbrp->mbrp_start; } else { uint flags = 0; if (mbrp->mbrp_type == MBR_PTYPE_NETBSD) { flags |= GLM_LIKELY_FFS; if (parts->target == ~0U) parts->target = mbri->sector + mbrp->mbrp_start; } else if (mbrp->mbrp_type == MBR_PTYPE_FAT12 || mbrp->mbrp_type == MBR_PTYPE_FAT16S || mbrp->mbrp_type == MBR_PTYPE_FAT16B || mbrp->mbrp_type == MBR_PTYPE_FAT32 || mbrp->mbrp_type == MBR_PTYPE_FAT32L || mbrp->mbrp_type == MBR_PTYPE_FAT16L || mbrp->mbrp_type == MBR_PTYPE_EFI) flags |= GLM_MAYBE_FAT32; else if (mbrp->mbrp_type == MBR_PTYPE_NTFS) flags |= GLM_MAYBE_NTFS; if (flags != 0) { const char *mount = get_last_mounted( fd, mbri->sector + mbrp->mbrp_start, &mbri->fs_type[i], &mbri->fs_sub_type[i], flags); char *p = strdup(mount); canonicalize_last_mounted(p); mbri->last_mounted[i] = p; } } #if BOOTSEL if (mbri->mbrb.mbrbs_nametab[i][0] != 0 && bootkey-- == 0) ombri->bootsec = mbri->sector + mbrp->mbrp_start; #endif } if (next_ext == 0 || ext_base + next_ext <= mbri->sector) break; if (ext_base == 0) { ext_base = next_ext; next_ext = 0; } ext = calloc(1, sizeof *ext); if (!ext) break; mbrs = &ext->mbr; } bad_mbr: free_mbr_info(ext); if (fd >= 0) close(fd); if (rval == -1) { memset(&mbrs->mbr_parts, 0, sizeof mbrs->mbr_parts); mbrs->mbr_magic = htole16(MBR_MAGIC); } dump_mbr(ombri, "read"); return rval; } static int write_mbr(const char *disk, size_t secsize, mbr_info_t *mbri, int bsec, int bhead, int bcyl) { char diskpath[MAXPATHLEN]; int fd, i, ret = 0, bits = 0; struct mbr_partition *mbrp; u_int32_t pstart, psize; #ifdef BOOTSEL struct mbr_sector *mbrs; #endif struct mbr_sector mbrsec; mbr_info_t *ext; uint sector; dump_mbr(mbri, "write"); /* Open the disk. */ fd = opendisk(disk, secsize == 512 ? O_WRONLY : O_RDWR, diskpath, sizeof(diskpath), 0); if (fd < 0) return -1; /* Remove all wedges */ if (ioctl(fd, DIOCRMWEDGES, &bits) == -1) return -1; #ifdef BOOTSEL /* * If the main boot code (appears to) contain the netbsd bootcode, * copy in all the menu strings and set the default keycode * to be that for the default partition. * Unfortunately we can't rely on the user having actually updated * to the new mbr code :-( */ if (mbri->mbr.mbr_bootsel_magic == htole16(MBR_BS_MAGIC) || mbri->mbr.mbr_bootsel_magic == htole16(MBR_MAGIC)) { int8_t key = SCAN_1; uint offset = MBR_BS_OFFSET; if (mbri->mbr.mbr_bootsel_magic == htole16(MBR_MAGIC)) offset = MBR_BS_OLD_OFFSET; mbri->mbrb.mbrbs_defkey = SCAN_ENTER; if (mbri->mbrb.mbrbs_timeo == 0) mbri->mbrb.mbrbs_timeo = 182; /* 10 seconds */ for (ext = mbri; ext != NULL; ext = ext->extended) { mbrs = &ext->mbr; mbrp = &mbrs->mbr_parts[0]; /* Ensure marker is set in each sector */ mbrs->mbr_bootsel_magic = mbri->mbr.mbr_bootsel_magic; /* and copy in bootsel parameters */ *(struct mbr_bootsel *)((uint8_t *)mbrs + offset) = ext->mbrb; for (i = 0; i < MBR_PART_COUNT; i++) { if (ext->mbrb.mbrbs_nametab[i][0] == 0) continue; if (ext->sector + mbrp->mbrp_start == mbri->bootsec) mbri->mbrb.mbrbs_defkey = key; key++; } } /* copy main data (again) since we've put the 'key' in */ *(struct mbr_bootsel *)((uint8_t *)&mbri->mbr + offset) = mbri->mbrb; } #endif for (ext = mbri; ext != NULL; ext = ext->extended) { memset(mbri->wedge, 0, sizeof mbri->wedge); sector = ext->sector; mbrsec = ext->mbr; /* copy sector */ mbrp = &mbrsec.mbr_parts[0]; if (sector != 0 && ext->extended != NULL && ext->extended->mbr.mbr_parts[0].mbrp_type == MBR_PTYPE_UNUSED) { /* * This should never happen nowadays, old code * inserted empty ext sectors in the chain to * help the gui out - we do not do that anymore. */ assert(false); /* We are followed by an empty slot, collapse out */ ext = ext->extended; /* Make us describe the next non-empty partition */ mbrp[1] = ext->mbr.mbr_parts[1]; } for (i = 0; i < MBR_PART_COUNT; i++) { if (mbrp[i].mbrp_start == 0 && mbrp[i].mbrp_size == 0) { mbrp[i].mbrp_scyl = 0; mbrp[i].mbrp_shd = 0; mbrp[i].mbrp_ssect = 0; mbrp[i].mbrp_ecyl = 0; mbrp[i].mbrp_ehd = 0; mbrp[i].mbrp_esect = 0; continue; } pstart = mbrp[i].mbrp_start; psize = mbrp[i].mbrp_size; mbrp[i].mbrp_start = htole32(pstart); mbrp[i].mbrp_size = htole32(psize); if (bsec && bcyl && bhead) { convert_mbr_chs(bcyl, bhead, bsec, &mbrp[i].mbrp_scyl, &mbrp[i].mbrp_shd, &mbrp[i].mbrp_ssect, pstart); convert_mbr_chs(bcyl, bhead, bsec, &mbrp[i].mbrp_ecyl, &mbrp[i].mbrp_ehd, &mbrp[i].mbrp_esect, pstart + psize - 1); } } mbrsec.mbr_magic = htole16(MBR_MAGIC); if (blockwrite(fd, secsize, &mbrsec, sizeof mbrsec, sector * (off_t)MBR_SECSIZE) < 0) { ret = -1; break; } } (void)close(fd); return ret; } static void convert_mbr_chs(int cyl, int head, int sec, uint8_t *cylp, uint8_t *headp, uint8_t *secp, uint32_t relsecs) { unsigned int tcyl, temp, thead, tsec; temp = head * sec; tcyl = relsecs / temp; relsecs -= tcyl * temp; thead = relsecs / sec; tsec = relsecs - thead * sec + 1; if (tcyl > MAXCYL) tcyl = MAXCYL; *cylp = MBR_PUT_LSCYL(tcyl); *headp = thead; *secp = MBR_PUT_MSCYLANDSEC(tcyl, tsec); } /* * This function is ONLY to be used as a last resort to provide a * hint for the user. Ports should provide a more reliable way * of getting the BIOS geometry. The i386 code, for example, * uses the BIOS geometry as passed on from the bootblocks, * and only uses this as a hint to the user when that information * is not present, or a match could not be made with a NetBSD * device. */ int guess_biosgeom_from_parts(struct disk_partitions *parts, int *cyl, int *head, int *sec) { /* * The physical parameters may be invalid as bios geometry. * If we cannot determine the actual bios geometry, we are * better off picking a likely 'faked' geometry than leaving * the invalid physical one. */ int xcylinders = pm->dlcyl; int xheads = pm->dlhead; daddr_t xsectors = pm->dlsec; daddr_t xsize = min(pm->dlsize, mbr_parts.size_limit); if (xcylinders > MAXCYL || xheads > MAXHEAD || xsectors > MAXSECTOR) { xsectors = MAXSECTOR; xheads = MAXHEAD; xcylinders = xsize / (MAXSECTOR * MAXHEAD); if (xcylinders > MAXCYL) xcylinders = MAXCYL; } *cyl = xcylinders; *head = xheads; *sec = xsectors; if (parts->pscheme->guess_disk_geom == NULL) return -1; return parts->pscheme->guess_disk_geom(parts, cyl, head, sec); } static int mbr_comp_part_entry(const void *a, const void *b) { const struct mbr_partition *part_a = a, *part_b = b; if (part_a->mbrp_type == MBR_PTYPE_UNUSED && part_b->mbrp_type != MBR_PTYPE_UNUSED) return 1; if (part_b->mbrp_type == MBR_PTYPE_UNUSED && part_a->mbrp_type != MBR_PTYPE_UNUSED) return -1; return part_a->mbrp_start < part_b->mbrp_start ? -1 : 1; } static void mbr_sort_main_mbr(struct mbr_sector *m) { qsort(&m->mbr_parts[0], MBR_PART_COUNT, sizeof(m->mbr_parts[0]), mbr_comp_part_entry); } static void mbr_init_default_alignments(struct mbr_disk_partitions *parts, uint track) { if (track == 0) track = 16065; assert(parts->dp.disk_size > 0); if (parts->dp.disk_size < 0) return; parts->ptn_0_offset = parts->geo_sec; /* Use 1MB offset/alignemnt for large (>128GB) disks */ if (parts->dp.disk_size > HUGE_DISK_SIZE) { parts->ptn_alignment = 2048; } else if (parts->dp.disk_size > TINY_DISK_SIZE) { parts->ptn_alignment = 64; } else { parts->ptn_alignment = 1; } parts->ext_ptn_alignment = track; } static struct disk_partitions * mbr_create_new(const char *disk, daddr_t start, daddr_t len, bool is_boot_drive, struct disk_partitions *parent) { struct mbr_disk_partitions *parts; struct disk_geom geo; assert(start == 0); if (start != 0) return NULL; parts = calloc(1, sizeof(*parts)); if (!parts) return NULL; parts->dp.pscheme = &mbr_parts; parts->dp.disk = strdup(disk); if (len > mbr_parts.size_limit) len = mbr_parts.size_limit; parts->dp.disk_start = start; parts->dp.disk_size = len; parts->dp.free_space = len-1; parts->dp.bytes_per_sector = 512; parts->geo_sec = MAXSECTOR; parts->geo_head = MAXHEAD; parts->geo_cyl = len/MAXHEAD/MAXSECTOR+1; parts->target = ~0U; if (get_disk_geom(disk, &geo)) { parts->geo_sec = geo.dg_nsectors; parts->geo_head = geo.dg_ntracks; parts->geo_cyl = geo.dg_ncylinders; parts->dp.bytes_per_sector = geo.dg_secsize; } mbr_init_default_alignments(parts, 0); return &parts->dp; } static void mbr_calc_free_space(struct mbr_disk_partitions *parts) { size_t i; mbr_info_t *m; parts->dp.free_space = parts->dp.disk_size - 1; parts->dp.num_part = 0; m = &parts->mbr; do { for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (m != &parts->mbr && i > 0 && MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) break; parts->dp.num_part++; if (MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) continue; daddr_t psize = m->mbr.mbr_parts[i].mbrp_size; if (m != &parts->mbr) psize += m->mbr.mbr_parts[i].mbrp_start; if (psize > parts->dp.free_space) parts->dp.free_space = 0; else parts->dp.free_space -= psize; } } while ((m = m->extended)); } static struct disk_partitions * mbr_read_from_disk(const char *disk, daddr_t start, daddr_t len, size_t bps, const struct disk_partitioning_scheme *scheme) { struct mbr_disk_partitions *parts; assert(start == 0); if (start != 0) return NULL; parts = calloc(1, sizeof(*parts)); if (!parts) return NULL; parts->dp.pscheme = scheme; parts->dp.disk = strdup(disk); if (len >= mbr_parts.size_limit) len = mbr_parts.size_limit; parts->dp.disk_start = start; parts->dp.disk_size = len; parts->geo_sec = MAXSECTOR; parts->geo_head = MAXHEAD; parts->geo_cyl = len/MAXHEAD/MAXSECTOR+1; parts->dp.bytes_per_sector = bps; parts->target = ~0U; mbr_init_default_alignments(parts, 0); if (read_mbr(disk, parts->dp.bytes_per_sector, &parts->mbr, parts) == -1) { free(parts); return NULL; } mbr_calc_free_space(parts); if (parts->dp.num_part == 1 && parts->dp.free_space < parts->ptn_alignment) { struct disk_part_info info; /* * Check if this is a GPT protective MBR */ if (parts->dp.pscheme->get_part_info(&parts->dp, 0, &info) && info.nat_type != NULL && mbr_type_from_gen_desc(info.nat_type) == 0xEE) { parts->dp.pscheme->free(&parts->dp); return NULL; } } return &parts->dp; } static bool mbr_write_to_disk(struct disk_partitions *new_state) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions *)new_state; unsigned long bsec, bhead, bcyl; daddr_t t; assert(parts->geo_sec != 0); if (parts->geo_sec != 0) { bsec = parts->geo_sec; bhead = parts->ext_ptn_alignment / bsec; } else { bsec = MAXSECTOR; bhead = MAXHEAD; } t = bsec * bhead; assert(t != 0); if ((daddr_t)(1UL<<10) * t <= parts->dp.disk_size) bcyl = (1UL<<10) - 1; else bcyl = (unsigned long)(parts->dp.disk_size / t); return write_mbr(parts->dp.disk, parts->dp.bytes_per_sector, &parts->mbr, bsec, bhead, bcyl) == 0; } static bool mbr_change_disk_geom(struct disk_partitions *arg, int ncyl, int nhead, int nsec) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions *)arg; daddr_t ptn_0_base, ptn_0_limit; struct disk_part_info info; /* Default to using 'traditional' cylinder alignment */ mbr_init_chs(parts, ncyl, nhead, nsec); mbr_init_default_alignments(parts, nhead * nsec); if (parts->dp.disk_size <= TINY_DISK_SIZE) { set_default_sizemult(arg->disk, parts->dp.bytes_per_sector, parts->dp.bytes_per_sector); return true; } if (parts->dp.num_part > 0 && parts->dp.pscheme->get_part_info(arg, 0, &info)) { /* Try to copy offset of first partition */ ptn_0_base = info.start; ptn_0_limit = info.start + info.size; if (!(ptn_0_limit & 2047)) { /* Partition ends on a 1MB boundary, align to 1MB */ parts->ptn_alignment = 2048; if ((ptn_0_base <= 2048 && !(ptn_0_base & (ptn_0_base - 1))) || (ptn_0_base < parts->ptn_0_offset)) { /* * If ptn_base is a power of 2, use it. * Also use it if the first partition * already is close to the beginning * of the disk and we can't enforce * better alignment. */ parts->ptn_0_offset = ptn_0_base; } } } set_default_sizemult(arg->disk, MEG, parts->dp.bytes_per_sector); return true; } static size_t mbr_type_from_gen_desc(const struct part_type_desc *desc) { for (size_t i = 0; i < __arraycount(mbr_gen_type_desc); i++) if (&mbr_gen_type_desc[i].gen == desc) return i; return SIZE_T_MAX; } static enum part_type mbr_map_part_type(unsigned int t) { /* Map some special MBR partition types */ switch (t) { case MBR_PTYPE_FAT32: case MBR_PTYPE_FAT32L: case MBR_PTYPE_FAT16S: case MBR_PTYPE_FAT16B: case MBR_PTYPE_FAT16L: case MBR_PTYPE_FAT12: case MBR_PTYPE_FT_FAT32: case MBR_PTYPE_FT_FAT32_EXT: return PT_FAT; case MBR_PTYPE_EFI: return PT_EFI_SYSTEM; case MBR_PTYPE_LNXEXT2: return PT_EXT2; case MBR_PTYPE_NETBSD: return PT_root; } return PT_unknown; } static void map_mbr_part_types(void) { for (size_t i = 0; i < __arraycount(mbr_part_types_src); i++) { unsigned int v = mbr_part_types_src[i].ptype; snprintf(mbr_gen_type_desc[v].short_buf, sizeof(mbr_gen_type_desc[v].short_buf), "%u", v); mbr_gen_type_desc[v].gen.short_desc = mbr_gen_type_desc[v].short_buf; mbr_gen_type_desc[v].gen.description = mbr_part_types_src[i].desc; mbr_gen_type_desc[v].gen.generic_ptype = mbr_map_part_type(v); mbr_gen_type_desc[v].next_ptype = ~0U; mbr_gen_type_desc[last_added_part_type].next_ptype = v; known_part_types++; last_added_part_type = v; } } static size_t mbr_get_part_type_count(void) { if (known_part_types == 0) map_mbr_part_types(); return known_part_types; } static const struct part_type_desc * mbr_get_fs_part_type(enum part_type pt, unsigned fs_type, unsigned sub_type) { if (known_part_types == 0) map_mbr_part_types(); switch (fs_type) { case FS_BSDFFS: return &mbr_gen_type_desc[MBR_PTYPE_NETBSD].gen; case FS_EX2FS: return &mbr_gen_type_desc[MBR_PTYPE_LNXEXT2].gen; case FS_MSDOS: if (sub_type == 0) sub_type = MBR_PTYPE_FAT32L; switch (sub_type) { case MBR_PTYPE_FAT12: case MBR_PTYPE_FAT16S: case MBR_PTYPE_FAT16B: case MBR_PTYPE_FAT32: case MBR_PTYPE_FAT32L: case MBR_PTYPE_FAT16L: return &mbr_gen_type_desc[sub_type].gen; } break; case FS_EFI_SP: return &mbr_gen_type_desc[MBR_PTYPE_EFI].gen; } return NULL; } static const struct part_type_desc * mbr_get_part_type(size_t index) { size_t i, no; if (known_part_types == 0) map_mbr_part_types(); if (index >= known_part_types) return NULL; for (i = first_part_type, no = 0; i < __arraycount(mbr_gen_type_desc) && no != index; no++) i = mbr_gen_type_desc[i].next_ptype; if (i >= __arraycount(mbr_gen_type_desc)) return NULL; return &mbr_gen_type_desc[i].gen; } static const struct part_type_desc * mbr_new_custom_part_type(unsigned int v) { snprintf(mbr_gen_type_desc[v].short_buf, sizeof(mbr_gen_type_desc[v].short_buf), "%u", v); snprintf(mbr_gen_type_desc[v].desc_buf, sizeof(mbr_gen_type_desc[v].desc_buf), "%s (%u)", msg_string(MSG_custom_type), v); mbr_gen_type_desc[v].gen.short_desc = mbr_gen_type_desc[v].short_buf; mbr_gen_type_desc[v].gen.description = mbr_gen_type_desc[v].desc_buf; mbr_gen_type_desc[v].gen.generic_ptype = mbr_map_part_type(v); mbr_gen_type_desc[v].next_ptype = ~0U; mbr_gen_type_desc[last_added_part_type].next_ptype = v; known_part_types++; last_added_part_type = v; return &mbr_gen_type_desc[v].gen; } static const struct part_type_desc * mbr_custom_part_type(const char *custom, const char **err_msg) { unsigned long v; char *endp; if (known_part_types == 0) map_mbr_part_types(); v = strtoul(custom, &endp, 10); if (v > 255 || (v == 0 && *endp != 0)) { if (err_msg != NULL) *err_msg = msg_string(MSG_mbr_type_invalid); return NULL; } if (mbr_gen_type_desc[v].gen.short_desc != NULL) return &mbr_gen_type_desc[v].gen; return mbr_new_custom_part_type(v); } static const struct part_type_desc * mbr_create_unknown_part_type(void) { if (mbr_gen_type_desc[MBR_UNKNOWN_PTYPE].gen.short_desc != NULL) return &mbr_gen_type_desc[MBR_UNKNOWN_PTYPE].gen; return mbr_new_custom_part_type(MBR_UNKNOWN_PTYPE); } static const struct part_type_desc * mbr_get_gen_type_desc(unsigned int pt) { if (known_part_types == 0) map_mbr_part_types(); if (pt >= __arraycount(mbr_gen_type_desc)) return NULL; if (mbr_gen_type_desc[pt].gen.short_desc != NULL) return &mbr_gen_type_desc[pt].gen; return mbr_new_custom_part_type(pt); } static const struct part_type_desc * mbr_get_generic_part_type(enum part_type pt) { switch (pt) { case PT_root: return mbr_get_gen_type_desc(MBR_PTYPE_NETBSD); case PT_FAT: return mbr_get_gen_type_desc(MBR_PTYPE_FAT32L); case PT_EXT2: return mbr_get_gen_type_desc(MBR_PTYPE_LNXEXT2); case PT_EFI_SYSTEM: return mbr_get_gen_type_desc(MBR_PTYPE_EFI); default: break; } assert(false); return NULL; } static void mbr_partition_to_info(const struct mbr_partition *mp, daddr_t start_off, struct disk_part_info *info) { memset(info, 0, sizeof(*info)); info->start = mp->mbrp_start + start_off; info->size = mp->mbrp_size; info->nat_type = mbr_get_gen_type_desc(mp->mbrp_type); if (mp->mbrp_type == MBR_PTYPE_NETBSD) { info->flags |= PTI_SEC_CONTAINER; } else if (MBR_IS_EXTENDED(mp->mbrp_type)) info->flags |= PTI_PSCHEME_INTERNAL; } static bool mbr_part_apply(const struct disk_partitions *arg, part_id id, bool (*func)(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *), void *cookie) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; part_id i, j, no; const mbr_info_t *m = &parts->mbr, *me; no = 0; for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (no == id) { return func(arg, id, m, i, true, &m->mbr.mbr_parts[i], cookie); } no++; if (MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) { for (me = m->extended; me != NULL; me = me->extended) { for (j = 0; j < MBR_PART_COUNT; j++) { if (me->mbr.mbr_parts[j].mbrp_type == MBR_PTYPE_UNUSED) continue; if (j > 0 && MBR_IS_EXTENDED( me->mbr.mbr_parts[j].mbrp_type)) break; if (no == id) { return func(arg, id, me, j, false, &me->mbr.mbr_parts[j], cookie); } no++; } } } } return false; } static bool mbr_do_get_part_info(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { struct disk_part_info *info = cookie; const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; mbr_partition_to_info(mp, mb->sector, info); if (mp->mbrp_start + mb->sector == parts->target) info->flags |= PTI_INSTALL_TARGET; if (mb->last_mounted[i] != NULL && mb->last_mounted[i][0] != 0) info->last_mounted = mb->last_mounted[i]; if (mb->fs_type[i] != FS_UNUSED) { info->fs_type = mb->fs_type[i]; info->fs_sub_type = mb->fs_sub_type[i]; } else { info->fs_sub_type = 0; switch (mp->mbrp_type) { case MBR_PTYPE_FAT12: case MBR_PTYPE_FAT16S: case MBR_PTYPE_FAT16B: case MBR_PTYPE_FAT32: case MBR_PTYPE_FAT32L: case MBR_PTYPE_FAT16L: case MBR_PTYPE_OS2_DOS12: case MBR_PTYPE_OS2_DOS16S: case MBR_PTYPE_OS2_DOS16B: case MBR_PTYPE_HID_FAT32: case MBR_PTYPE_HID_FAT32_LBA: case MBR_PTYPE_HID_FAT16_LBA: case MBR_PTYPE_MDOS_FAT12: case MBR_PTYPE_MDOS_FAT16S: case MBR_PTYPE_MDOS_EXT: case MBR_PTYPE_MDOS_FAT16B: case MBR_PTYPE_SPEEDSTOR_16S: case MBR_PTYPE_EFI: info->fs_type = FS_MSDOS; info->fs_sub_type = mp->mbrp_type; break; case MBR_PTYPE_LNXEXT2: info->fs_type = FS_EX2FS; break; case MBR_PTYPE_XENIX_ROOT: case MBR_PTYPE_XENIX_USR: info->fs_type = FS_SYSV; break; case MBR_PTYPE_NTFS: info->fs_type = FS_NTFS; break; case MBR_PTYPE_APPLE_HFS: info->fs_type = FS_HFS; break; case MBR_PTYPE_VMWARE: info->fs_type = FS_VMFS; break; case MBR_PTYPE_AST_SWAP: case MBR_PTYPE_DRDOS_LSWAP: case MBR_PTYPE_LNXSWAP: case MBR_PTYPE_BSDI_SWAP: case MBR_PTYPE_HID_LNX_SWAP: case MBR_PTYPE_VMWARE_SWAP: info->fs_type = FS_SWAP; break; } } return true; } static bool get_wedge_devname(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { char **res = cookie; if (!res) return false; *res = __UNCONST(mb->wedge[i]); return true; } static bool mbr_part_get_wedge(const struct disk_partitions *arg, part_id id, char **res) { return mbr_part_apply(arg, id, get_wedge_devname, res); } static bool mbr_get_part_info(const struct disk_partitions *arg, part_id id, struct disk_part_info *info) { return mbr_part_apply(arg, id, mbr_do_get_part_info, info); } static bool type_can_change(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { /* * The extended partition can only change type or be * deleted if it is empty */ if (!MBR_IS_EXTENDED(mp->mbrp_type)) return true; return primary && mb->extended == NULL; } static bool mbr_part_type_can_change(const struct disk_partitions *arg, part_id id) { return mbr_part_apply(arg, id, type_can_change, NULL); } struct part_get_str_data { char *str; size_t avail_space; size_t col; }; static bool mbr_get_part_table_str(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { struct part_get_str_data *data = cookie; char *str = data->str; const struct part_type_desc *ptype; switch (data->col) { case 0: ptype = mbr_get_gen_type_desc(mp->mbrp_type); if (ptype != NULL) strncpy(str, ptype->description, data->avail_space); else snprintf(str, data->avail_space, "%u", mp->mbrp_type); str[data->avail_space-1] = 0; break; case 1: if (mb->last_mounted[i]) strlcpy(str, mb->last_mounted[i], data->avail_space); else *str = 0; break; #ifdef BOOTSEL case 2: if (mb->mbrb.mbrbs_nametab[i][0] != 0) strlcpy(str, mb->mbrb.mbrbs_nametab[i], data->avail_space); else *str = 0; break; #endif } return true; } static bool mbr_table_str(const struct disk_partitions *arg, part_id id, size_t col, char *str, size_t avail_space) { struct part_get_str_data data; data.str = str; data.avail_space = avail_space; data.col = col; return mbr_part_apply(arg, id, mbr_get_part_table_str, &data); } static bool mbr_get_part_attr_str(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { #ifdef BOOTSEL const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; #endif struct part_get_str_data *data = cookie; static const char *flags = NULL; char *str = data->str; if (flags == NULL) flags = msg_string(MSG_mbr_flags); if (mp->mbrp_flag & MBR_PFLAG_ACTIVE) *str++ = flags[0]; #ifdef BOOTSEL if (parts->mbr.bootsec == mb->sector+mp->mbrp_start) *str++ = flags[1]; #endif *str = 0; return true; } static bool mbr_part_attr_str(const struct disk_partitions *arg, part_id id, char *str, size_t avail_space) { struct part_get_str_data data; if (avail_space < 3) return false; data.str = str; data.avail_space = avail_space; return mbr_part_apply(arg, id, mbr_get_part_attr_str, &data); } static bool mbr_info_to_partitition(const struct disk_part_info *info, struct mbr_partition *mp, uint sector, struct mbr_info_t *mb, size_t index, const char **err_msg) { size_t pt = mbr_type_from_gen_desc(info->nat_type); if (info->start + info->size > UINT_MAX || pt > __arraycount(mbr_gen_type_desc)) { if (err_msg) *err_msg = err_outofmem; return false; } mp->mbrp_start = info->start - sector; mp->mbrp_size = info->size; mp->mbrp_type = pt; if (info->flags & PTI_INSTALL_TARGET) { mp->mbrp_flag |= MBR_PFLAG_ACTIVE; #ifdef BOOTSEL strcpy(mb->mbrb.mbrbs_nametab[index], "NetBSD"); #endif } return true; } static bool inside_ext_part(mbr_info_t *m, daddr_t start) { size_t i; struct mbr_partition *mp = NULL; for (i = 0; i < MBR_PART_COUNT; i++) { if (!MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) continue; mp = &m->mbr.mbr_parts[i]; break; } if (mp == NULL) { assert(false); return false; } if (mp->mbrp_start > start) return false; return true; } static void adjust_ext_part(mbr_info_t *m, daddr_t start, daddr_t size) { size_t i; struct mbr_partition *mp = NULL; for (i = 0; i < MBR_PART_COUNT; i++) { if (!MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) continue; mp = &m->mbr.mbr_parts[i]; break; } if (mp == NULL) { assert(false); return; } if (mp->mbrp_start + mp->mbrp_size >= start + size) return; daddr_t new_end = start + size; mp->mbrp_size = new_end - mp->mbrp_start; } static bool ext_part_good(mbr_info_t *m, daddr_t ext_start, daddr_t ext_size) { for (m = m->extended; m != NULL; m = m->extended) { for (size_t i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (i > 0 && MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) break; daddr_t pstart = m->mbr.mbr_parts[i].mbrp_start + m->sector; daddr_t pend = pstart + m->mbr.mbr_parts[i].mbrp_size; if (pstart < ext_start || pend > ext_start+ext_size) return false; } } return true; } static bool mbr_set_part_info(struct disk_partitions *arg, part_id id, const struct disk_part_info *info, const char **err_msg) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; struct disk_part_info data = *info; part_id i, j, no, ext_ndx, t; mbr_info_t *m = &parts->mbr, *me; uint pt = mbr_type_from_gen_desc(info->nat_type); if (MBR_IS_EXTENDED(pt)) { /* check for duplicate ext part */ no = 0; t = ext_ndx = MBR_PART_COUNT; for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) ext_ndx = i; if (no == id) t = i; no++; } if (ext_ndx < MBR_PART_COUNT && t != ext_ndx) { if (err_msg) *err_msg = msg_string(MSG_Only_one_extended_ptn); return false; } /* this partition becomes an extended one, apply alignment */ data.start = max(roundup(data.start, parts->ext_ptn_alignment), parts->ext_ptn_alignment); } no = 0; for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (no == id) goto found; no++; if (MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) { for (me = m->extended; me != NULL; me = me->extended) { for (j = 0; j < MBR_PART_COUNT; j++) { if (me->mbr.mbr_parts[j].mbrp_type == MBR_PTYPE_UNUSED) continue; if (j > 0 && MBR_IS_EXTENDED( me->mbr.mbr_parts[j].mbrp_type)) break; if (no == id) { i = j; m = me; goto found; } no++; } } } } if (err_msg) *err_msg = INTERNAL_ERROR; return false; found: /* * We assume that m is the mbr we want to update and * i is the local partition index into it. */ if (m == &parts->mbr) { if (MBR_IS_EXTENDED( m->mbr.mbr_parts[i].mbrp_type) && !ext_part_good(&parts->mbr, data.start, data.size)) { if (err_msg) *err_msg = MSG_mbr_ext_nofit; return false; } } else if (!inside_ext_part(&parts->mbr, data.start)) { if (err_msg) *err_msg = msg_string(MSG_mbr_inside_ext); return false; } uint start = data.start, size = data.size; uint oldstart = m->mbr.mbr_parts[i].mbrp_start + m->sector; if (parts->ptn_0_offset > 0 && start < parts->ptn_0_offset) start = parts->ptn_0_offset; if (find_mbr_space(m, &start, &size, start, parts->dp.disk_size, oldstart, false) < 0) { if (err_msg != NULL) *err_msg = INTERNAL_ERROR; return false; } data.start = start; if (size < data.size) data.size = size; uint old_start = m->mbr.mbr_parts[i].mbrp_start; if (!mbr_info_to_partitition(&data, &m->mbr.mbr_parts[i], m->sector, m, i, err_msg)) return false; if (data.flags & PTI_INSTALL_TARGET) parts->target = start; else if (old_start == parts->target) parts->target = -1; if (data.last_mounted && m->last_mounted[i] && data.last_mounted != m->last_mounted[i]) { free(__UNCONST(m->last_mounted[i])); m->last_mounted[i] = strdup(data.last_mounted); } if (data.fs_type != 0) m->fs_type[i] = data.fs_type; if (data.fs_sub_type != 0) m->fs_sub_type[i] = data.fs_sub_type; if (m == &parts->mbr) { if (m->mbr.mbr_parts[i].mbrp_start != old_start) mbr_sort_main_mbr(&m->mbr); } else { adjust_ext_part(&parts->mbr, data.start, data.size); } mbr_calc_free_space(parts); return true; } static bool mbr_find_netbsd(const struct mbr_info_t *m, uint start, struct disk_part_info *info) { size_t i; bool prim = true; do { for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (!prim && i > 0 && MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) break; const struct mbr_partition *mp = &m->mbr.mbr_parts[i]; if (mp->mbrp_type != MBR_PTYPE_NETBSD) continue; mbr_partition_to_info(mp, m->sector, info); if (m->last_mounted[i] && *m->last_mounted[i] != 0) info->last_mounted = m->last_mounted[i]; info->fs_type = m->fs_type[i]; info->fs_sub_type = m->fs_sub_type[i]; if (start > 0 && start != info->start) continue; return true; } prim = false; } while ((m = m->extended)); return false; } static struct disk_partitions * mbr_read_disklabel(struct disk_partitions *arg, daddr_t start, bool force_empty) { struct mbr_disk_partitions *myparts = (struct mbr_disk_partitions*)arg; struct disk_part_info part; struct disk_part_free_space space; if (force_empty && myparts->dlabel) myparts->dlabel->pscheme->delete_all_partitions( myparts->dlabel); if (myparts->dlabel == NULL) { /* * Find the NetBSD MBR partition */ if (!mbr_find_netbsd(&myparts->mbr, start, &part)) { if (!force_empty) return NULL; /* add a "whole disk" NetBSD partition */ memset(&part, 0, sizeof part); part.start = min(myparts->ptn_0_offset,start); if (!mbr_get_free_spaces(arg, &space, 1, part.start, myparts->ptn_alignment, -1, -1)) return NULL; part.start = space.start; part.size = space.size; part.nat_type = &mbr_gen_type_desc[MBR_PTYPE_NETBSD].gen; mbr_add_part(arg, &part, NULL); if (!mbr_find_netbsd(&myparts->mbr, start, &part)) return NULL; } if (!force_empty) { myparts->dlabel = disklabel_parts.read_from_disk( myparts->dp.disk, part.start, part.size, myparts->dp.bytes_per_sector, &disklabel_parts); if (myparts->dlabel != NULL) myparts->dlabel->parent = &myparts->dp; } if (myparts->dlabel == NULL && part.size > 0) { /* we just created the outer partitions? */ myparts->dlabel = disklabel_parts.create_new_for_disk( myparts->dp.disk, part.start, part.size, false, &myparts->dp); } if (myparts->dlabel != NULL) myparts->dlabel->pscheme->change_disk_geom( myparts->dlabel, myparts->geo_cyl, myparts->geo_head, myparts->geo_sec); } return myparts->dlabel; } static int get_mapping(struct mbr_partition *parts, int i, int *cylinder, int *head, int *sector, daddr_t *absolute) { struct mbr_partition *apart = &parts[i / 2]; if (apart->mbrp_type == MBR_PTYPE_UNUSED) return -1; if (i % 2 == 0) { *cylinder = MBR_PCYL(apart->mbrp_scyl, apart->mbrp_ssect); *head = apart->mbrp_shd; *sector = MBR_PSECT(apart->mbrp_ssect) - 1; *absolute = le32toh(apart->mbrp_start); } else { *cylinder = MBR_PCYL(apart->mbrp_ecyl, apart->mbrp_esect); *head = apart->mbrp_ehd; *sector = MBR_PSECT(apart->mbrp_esect) - 1; *absolute = le32toh(apart->mbrp_start) + le32toh(apart->mbrp_size) - 1; } /* Sanity check the data against max values */ if ((((*cylinder * MAXHEAD) + *head) * (uint32_t)MAXSECTOR + *sector) < *absolute) /* cannot be a CHS mapping */ return -1; return 0; } static bool mbr_delete_all(struct disk_partitions *arg) { struct mbr_disk_partitions *myparts = (struct mbr_disk_partitions*)arg; struct mbr_sector *mbrs = &myparts->mbr.mbr; struct mbr_info_t *mbri = &myparts->mbr; mbr_info_t *ext; struct mbr_partition *part; part = &mbrs->mbr_parts[0]; /* Set the partition information for full disk usage. */ while ((ext = mbri->extended)) { mbri->extended = ext->extended; free_mbr_info(ext); } memset(part, 0, MBR_PART_COUNT * sizeof *part); #ifdef BOOTSEL memset(&mbri->mbrb, 0, sizeof mbri->mbrb); #endif /* * We may have changed alignment settings due to partitions * ending on an MB boundary - undo that, now that the partitions * are gone. */ mbr_change_disk_geom(arg, myparts->geo_cyl, myparts->geo_head, myparts->geo_sec); return true; } /* * helper function to fix up mbrp_start and mbrp_size for the * extended MBRs "partition b" entries after addition/deletion * of some partition. */ static void mbr_fixup_ext_chain(mbr_info_t *primary, uint ext_start, uint ext_end) { for (mbr_info_t *m = primary->extended; m != NULL; m = m->extended) { if (m->extended == NULL) { m->mbr.mbr_parts[1].mbrp_type = MBR_PTYPE_UNUSED; m->mbr.mbr_parts[1].mbrp_start = 0; m->mbr.mbr_parts[1].mbrp_size = 0; } else { uint n_end, n_start = m->extended->sector; if (m->extended->extended) n_end = m->extended->extended->sector; else n_end = ext_end; m->mbr.mbr_parts[1].mbrp_type = MBR_PTYPE_EXT; m->mbr.mbr_parts[1].mbrp_start = n_start - ext_start; m->mbr.mbr_parts[1].mbrp_size = n_end - n_start; } } } struct delete_part_args { struct mbr_disk_partitions *parts; daddr_t start, size; const char **err_msg; }; static bool mbr_do_delete_part(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { struct delete_part_args *marg = cookie; bool is_ext_part = MBR_IS_EXTENDED(mp->mbrp_type); /* can not delete non-empty extended partitions */ if (MBR_IS_EXTENDED(mp->mbrp_type) && marg->parts->mbr.extended != NULL) { if (marg->err_msg) *marg->err_msg = msg_string(MSG_mbr_ext_not_empty); return false; } /* return position/size to caller */ marg->start = mb->sector + mp->mbrp_start; marg->size = mp->mbrp_size; if (primary) { /* if deleting the primary extended partition, just kill it */ struct mbr_partition *md = &marg->parts->mbr.mbr.mbr_parts[i]; md->mbrp_size = 0; md->mbrp_start = 0; md->mbrp_type = MBR_PTYPE_UNUSED; if (marg->parts->mbr.last_mounted[i]) { free(__UNCONST(marg->parts->mbr.last_mounted[i])); marg->parts->mbr.last_mounted[i] = NULL; } if (is_ext_part) { for (mbr_info_t *m = marg->parts->mbr.extended; m != NULL; ) { mbr_info_t *n = m->extended; free_mbr_info(m); m = n; } marg->parts->mbr.extended = NULL; } } else { /* find the size of the primary extended partition */ uint ext_start = 0, ext_size = 0; for (i = 0; i < MBR_PART_COUNT; i++) { if (!MBR_IS_EXTENDED(marg->parts->mbr.mbr.mbr_parts[i] .mbrp_type)) continue; ext_start = marg->parts->mbr.mbr.mbr_parts[i] .mbrp_start; ext_size = marg->parts->mbr.mbr.mbr_parts[i] .mbrp_size; break; } /* * If we are in an extended partition chain, unlink this MBR, * unless it is the very first one at the start of the extended * partition (we would have no previous ext mbr to fix up * the chain in that case) */ if (marg->parts->mbr.extended == mb) { struct mbr_partition *part = &marg->parts->mbr.extended->mbr.mbr_parts[0]; part->mbrp_type = MBR_PTYPE_UNUSED; part->mbrp_start = 0; part->mbrp_size = 0; } else { mbr_info_t *p, *last; for (last = NULL, p = &marg->parts->mbr; p != NULL; last = p, p = p->extended) if (p == mb) break; if (last == NULL) { if (marg->err_msg != NULL) *marg->err_msg= INTERNAL_ERROR; return false; } last->extended = p->extended; free_mbr_info(p); if (last == &marg->parts->mbr && last->extended && last->extended->extended == NULL && last->extended->mbr.mbr_parts[0].mbrp_type == MBR_PTYPE_UNUSED) { /* * we deleted the last extended sector, * remove the whole chain */ free_mbr_info(last->extended); last->extended = NULL; } } mbr_fixup_ext_chain(&marg->parts->mbr, ext_start, ext_start+ext_size); } mbr_calc_free_space(marg->parts); return true; } static bool mbr_delete_part(struct disk_partitions *arg, part_id pno, const char **err_msg) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; struct delete_part_args data = { .parts = parts, .err_msg = err_msg }; if (!mbr_part_apply(arg, pno, mbr_do_delete_part, &data)) { if (err_msg) *err_msg = INTERNAL_ERROR; return false; } if (parts->target == data.start) parts->target = ~0U; if (parts->dlabel) { /* * If we change the mbr partitioning, the we must * remove any references in the netbsd disklabel * to the part we changed. */ parts->dlabel->pscheme->delete_partitions_in_range( parts->dlabel, data.start, data.size); } if (err_msg) *err_msg = NULL; dump_mbr(&parts->mbr, "after delete"); return true; } static struct mbr_partition * mbr_ptr_from_start(mbr_info_t *m, daddr_t start) { bool primary = true; do { for (uint i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (!primary && MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) break; daddr_t pstart = m->sector + m->mbr.mbr_parts[i].mbrp_start; if (pstart == start) return &m->mbr.mbr_parts[i]; } primary = false; } while ((m = m->extended)); return NULL; } static uint8_t mbr_type_from_start(const mbr_info_t *m, daddr_t start) { bool primary = true; do { for (uint i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (!primary && MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) break; daddr_t pstart = m->sector + m->mbr.mbr_parts[i].mbrp_start; if (pstart == start) return m->mbr.mbr_parts[i].mbrp_type; } primary = false; } while ((m = m->extended)); return MBR_PTYPE_UNUSED; } static part_id mbr_add_part(struct disk_partitions *arg, const struct disk_part_info *info, const char **errmsg) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; part_id i, j, no, free_primary = UINT_MAX; mbr_info_t *m = &parts->mbr, *me, *last, *t; daddr_t ext_start = 0, ext_size = 0; uint start, size; struct disk_part_info data = *info; struct mbr_partition *newp; if (errmsg != NULL) *errmsg = NULL; assert(info->nat_type != NULL); if (info->nat_type == NULL) { if (errmsg != NULL) *errmsg = INTERNAL_ERROR; return NO_PART; } if (mbr_type_from_gen_desc(info->nat_type) == MBR_PTYPE_UNUSED) { if (errmsg != NULL) *errmsg = INTERNAL_ERROR; return NO_PART; } /* do we have free primary slots and/or an extended partition? */ for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED && free_primary > MBR_PART_COUNT) free_primary = i; if (MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) { ext_start = m->mbr.mbr_parts[i].mbrp_start+m->sector; ext_size = m->mbr.mbr_parts[i].mbrp_size; continue; } if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED && m->mbr.mbr_parts[i].mbrp_size == 0) continue; } if (ext_start > 0 && ext_size > 0 && MBR_IS_EXTENDED(mbr_type_from_gen_desc(info->nat_type))) { /* * Do not allow a second extended partition */ if (errmsg) *errmsg = MSG_Only_one_extended_ptn; return NO_PART; } /* should this go into the extended partition? */ if (ext_size > 0 && info->start >= ext_start && info->start < ext_start + ext_size) { /* must fit into the extended partition */ if (info->start + info->size > ext_start + ext_size) { if (errmsg != NULL) *errmsg = MSG_mbr_ext_nofit; return NO_PART; } /* walk the chain untill we find a proper insert position */ daddr_t e_end, e_start; for (last = m, m = m->extended; m != NULL; last = m, m = m->extended) { e_start = m->mbr.mbr_parts[1].mbrp_start + ext_start; e_end = e_start + m->mbr.mbr_parts[1].mbrp_size; if (data.start <= e_start) break; } if (m == NULL) { /* add new tail record */ e_end = ext_start + ext_size; /* new part needs to fit inside primary extended one */ if (data.start + data.size > e_end) { if (errmsg) *errmsg = MSG_No_free_space; return NO_PART; } } else if (data.start + data.size > e_start) { /* new part needs to fit before next extended */ if (errmsg) *errmsg = MSG_No_free_space; return NO_PART; } /* * now last points to previous mbr (maybe primary), m * points to the one that should take the new partition * or we have to insert a new mbr between the two, or * m needs to be split and we go into the one after it. */ if (m && m->mbr.mbr_parts[0].mbrp_type == MBR_PTYPE_UNUSED) { /* empty slot, we can just use it */ newp = &m->mbr.mbr_parts[0]; mbr_info_to_partitition(&data, &m->mbr.mbr_parts[0], m->sector, m, 0, errmsg); if (data.last_mounted && m->last_mounted[0] && data.last_mounted != m->last_mounted[0]) { free(__UNCONST(m->last_mounted[0])); m->last_mounted[0] = strdup(data.last_mounted); } } else { mbr_info_t *new_mbr; if (m == NULL) m = last; daddr_t p_start = m->mbr.mbr_parts[0].mbrp_start + m->sector; daddr_t p_end = p_start + m->mbr.mbr_parts[0].mbrp_size; bool before; if (m == last || data.start > p_end) before = false; else if (data.start + data.size < p_start) before = true; else { if (errmsg) *errmsg = MSG_No_free_space; return NO_PART; } new_mbr = calloc(1, sizeof *new_mbr); if (!new_mbr) { if (errmsg) *errmsg = err_outofmem; return NO_PART; } new_mbr->mbr.mbr_magic = htole16(MBR_MAGIC); new_mbr->mbr.mbr_parts[1].mbrp_type = MBR_PTYPE_EXT; if (before) { /* * This is a hypthetical case where * an extended MBR uses an unusual high * offset (m->sector to parts[0].mbrp_start) * and we want to go into that space. * Should not happen in the real world (tm) * and is untested.... */ /* make sure the aligned new mbr fits */ uint mbrsec = rounddown(p_start, parts->ext_ptn_alignment); if (mbrsec <= data.start + data.size) data.size = mbrsec-1-data.start; /* now the new partition data is ready, * write out to old position */ new_mbr->sector = m->sector; newp = &new_mbr->mbr.mbr_parts[0]; mbr_info_to_partitition(&data, &new_mbr->mbr.mbr_parts[0], new_mbr->sector, new_mbr, 0, errmsg); if (data.last_mounted && m->last_mounted[0] && data.last_mounted != m->last_mounted[0]) { free(__UNCONST(m->last_mounted[0])); m->last_mounted[0] = strdup(data.last_mounted); } new_mbr->extended = m; } else { new_mbr->sector = max(roundup(data.start, parts->ext_ptn_alignment), parts->ext_ptn_alignment); uint off = new_mbr->sector - data.start; data.start += parts->ptn_0_offset+off; if (data.start + data.size > e_end) data.size = e_end - data.start; newp = &new_mbr->mbr.mbr_parts[0]; mbr_info_to_partitition(&data, &new_mbr->mbr.mbr_parts[0], new_mbr->sector, new_mbr, 0, errmsg); if (data.last_mounted && m->last_mounted[0] && data.last_mounted != m->last_mounted[0]) { free(__UNCONST(m->last_mounted[0])); m->last_mounted[0] = strdup(data.last_mounted); } /* * Special case: if we are creating the * first extended mbr, but do not start * at the beginning of the primary * extended partition, we need to insert * another extended mbr at the start. */ if (m == &parts->mbr && m->extended == NULL && new_mbr->sector > ext_start) { t = calloc(1, sizeof *new_mbr); if (!t) { free_mbr_info(new_mbr); if (errmsg) *errmsg = err_outofmem; return NO_PART; } t->sector = ext_start; t->mbr.mbr_magic = htole16(MBR_MAGIC); t->mbr.mbr_parts[1].mbrp_type = MBR_PTYPE_EXT; m->extended = t; m = t; } new_mbr->extended = m->extended; m->extended = new_mbr; } } mbr_fixup_ext_chain(&parts->mbr, ext_start, ext_start+ext_size); dump_mbr(&parts->mbr, "after adding in extended"); goto find_rval; } /* this one is for the primary boot block */ if (free_primary > MBR_PART_COUNT) { if (errmsg != NULL) *errmsg = ext_size > 0 ? MSG_mbr_no_free_primary_have_ext : MSG_mbr_no_free_primary_no_ext; return NO_PART; } start = max(info->start, parts->ptn_0_offset); size = info->size; if (find_mbr_space(m, &start, &size, start, parts->dp.disk_size, start, true) < 0 || size < info->size) { if (errmsg != NULL) *errmsg = MSG_No_free_space; return NO_PART; } data.start = start; if (MBR_IS_EXTENDED(mbr_type_from_gen_desc(info->nat_type))) { data.start = max(roundup(data.start, parts->ext_ptn_alignment), parts->ext_ptn_alignment); } if (data.start + data.size > start + size) data.size = start + size - data.start; mbr_info_to_partitition(&data, &m->mbr.mbr_parts[free_primary], m->sector, m, free_primary, errmsg); if (data.last_mounted && m->last_mounted[free_primary] && data.last_mounted != m->last_mounted[free_primary]) { free(__UNCONST(m->last_mounted[free_primary])); m->last_mounted[free_primary] = strdup(data.last_mounted); } start = m->mbr.mbr_parts[free_primary].mbrp_start; mbr_sort_main_mbr(&m->mbr); /* find the partition again after sorting */ newp = NULL; for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (m->mbr.mbr_parts[i].mbrp_start != start) continue; newp = &m->mbr.mbr_parts[i]; break; } dump_mbr(&parts->mbr, "after adding in primary"); find_rval: mbr_calc_free_space(parts); if (newp == NULL) return 0; /* * Now newp points to the modified partition entry but we do not know * a good part_id for it. * Iterate from start and find it. */ no = 0; for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (newp == &m->mbr.mbr_parts[i]) return no; no++; if (MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) { for (me = m->extended; me != NULL; me = me->extended) { for (j = 0; j < MBR_PART_COUNT; j++) { if (me->mbr.mbr_parts[j].mbrp_type == MBR_PTYPE_UNUSED) continue; if (j > 0 && MBR_IS_EXTENDED( me->mbr.mbr_parts[j].mbrp_type)) break; if (newp == &me->mbr.mbr_parts[j]) return no; no++; } } } } return 0; } static int mbr_guess_geom(struct disk_partitions *arg, int *cyl, int *head, int *sec) { struct mbr_disk_partitions *myparts = (struct mbr_disk_partitions*)arg; struct mbr_sector *mbrs = &myparts->mbr.mbr; struct mbr_partition *parts = &mbrs->mbr_parts[0]; int xcylinders, xheads, i, j; daddr_t xsectors, xsize; int c1, h1, s1, c2, h2, s2; daddr_t a1, a2; uint64_t num, denom; xheads = -1; /* Try to deduce the number of heads from two different mappings. */ for (i = 0; i < MBR_PART_COUNT * 2 - 1; i++) { if (get_mapping(parts, i, &c1, &h1, &s1, &a1) < 0) continue; a1 -= s1; for (j = i + 1; j < MBR_PART_COUNT * 2; j++) { if (get_mapping(parts, j, &c2, &h2, &s2, &a2) < 0) continue; a2 -= s2; num = (uint64_t)h1 * a2 - (quad_t)h2 * a1; denom = (uint64_t)c2 * a1 - (quad_t)c1 * a2; if (num != 0 && denom != 0 && num % denom == 0) { xheads = (int)(num / denom); xsectors = a1 / (c1 * xheads + h1); break; } } if (xheads != -1) break; } if (xheads == -1) return -1; /* * Estimate the number of cylinders. * XXX relies on get_disks having been called. */ xsize = min(pm->dlsize, mbr_parts.size_limit); xcylinders = xsize / xheads / xsectors; if (xsize != xcylinders * xheads * xsectors) xcylinders++; /* * Now verify consistency with each of the partition table entries. * Be willing to shove cylinders up a little bit to make things work, * but translation mismatches are fatal. */ for (i = 0; i < MBR_PART_COUNT * 2; i++) { if (get_mapping(parts, i, &c1, &h1, &s1, &a1) < 0) continue; if (c1 >= MAXCYL - 1) /* Ignore anything that is near the CHS limit */ continue; if (xsectors * (c1 * xheads + h1) + s1 != a1) return -1; } /* * Everything checks out. Reset the geometry to use for further * calculations. */ *cyl = MIN(xcylinders, MAXCYL); *head = xheads; *sec = xsectors; return 0; } static size_t mbr_get_cylinder(const struct disk_partitions *arg) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; return parts->geo_cyl; } static daddr_t mbr_max_part_size(const struct disk_partitions *arg, daddr_t fp_start) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; uint start = fp_start, size = 0; uint8_t pt; start = fp_start; pt = mbr_type_from_start(&parts->mbr, start); if (find_mbr_space(&parts->mbr, &start, &size, start, parts->dp.disk_size, start, MBR_IS_EXTENDED(pt)) < 0) return 0; return size; } static size_t mbr_get_free_spaces(const struct disk_partitions *arg, struct disk_part_free_space *result, size_t max_num_result, daddr_t min_size, daddr_t align, daddr_t lower_bound, daddr_t ignore) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; uint start = 0, size = 0, from, next; size_t spaces = 0; if (min_size < 1) min_size = 1; from = parts->ptn_0_offset; if (lower_bound > from) from = lower_bound; for ( ; from < parts->dp.disk_size && spaces < max_num_result; ) { if (find_mbr_space(&parts->mbr, &start, &size, from, parts->dp.disk_size, ignore > 0 ? (uint)ignore : UINT_MAX, false) < 0) break; next = start + size + 1; if (align > 0) { uint nv = max(roundup(start, align), align); uint off = nv - start; start = nv; if (size > off) size -= off; else size = 0; } if (size > min_size) { result[spaces].start = start; result[spaces].size = size; spaces++; } if ((daddr_t)start + (daddr_t)size + 1 >= mbr_parts.size_limit) break; from = next; } return spaces; } static bool mbr_can_add_partition(const struct disk_partitions *arg) { const struct mbr_disk_partitions *myparts = (const struct mbr_disk_partitions*)arg; struct disk_part_free_space space; bool free_primary, have_extended; if (arg->free_space < myparts->ptn_alignment) return false; if (mbr_get_free_spaces(arg, &space, 1, myparts->ptn_alignment, myparts->ptn_alignment, 0, -1) < 1) return false; for (int i = 0; i < MBR_PART_COUNT; i++) { uint8_t t = myparts->mbr.mbr.mbr_parts[i].mbrp_type; if (t == MBR_PTYPE_UNUSED && myparts->mbr.mbr.mbr_parts[i].mbrp_size == 0) free_primary = true; if (MBR_IS_EXTENDED(t)) have_extended = true; } if (have_extended) return true; return free_primary; } static void mbr_free_wedge(int *fd, const char *disk, const char *wedge) { struct dkwedge_info dkw; char diskpath[MAXPATHLEN]; if (*fd == -1) *fd = opendisk(disk, O_RDWR, diskpath, sizeof(diskpath), 0); if (*fd != -1) { memset(&dkw, 0, sizeof(dkw)); strlcpy(dkw.dkw_devname, wedge, sizeof(dkw.dkw_devname)); ioctl(*fd, DIOCDWEDGE, &dkw); } } static void mbr_free(struct disk_partitions *arg) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; mbr_info_t *m; int i, fd; assert(parts != NULL); fd = -1; m = &parts->mbr; do { for (i = 0; i < MBR_PART_COUNT; i++) { if (m->wedge[i][0] != 0) mbr_free_wedge(&fd, arg->disk, m->wedge[i]); } } while ((m = m->extended)); if (fd != -1) close(fd); if (parts->dlabel) parts->dlabel->pscheme->free(parts->dlabel); free_mbr_info(parts->mbr.extended); free_last_mounted(&parts->mbr); free(__UNCONST(parts->dp.disk)); free(parts); } static void mbr_destroy_part_scheme(struct disk_partitions *arg) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; char diskpath[MAXPATHLEN]; int fd; if (parts->dlabel != NULL) parts->dlabel->pscheme->destroy_part_scheme(parts->dlabel); fd = opendisk(arg->disk, O_RDWR, diskpath, sizeof(diskpath), 0); if (fd != -1) { char *buf; buf = calloc(arg->bytes_per_sector, 1); if (buf != NULL) { write(fd, buf, arg->bytes_per_sector); free(buf); } close(fd); } mbr_free(arg); } static bool mbr_verify_for_update(struct disk_partitions *arg) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; return md_mbr_update_check(arg, &parts->mbr); } static int mbr_verify(struct disk_partitions *arg, bool quiet) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; mbr_info_t *m = &parts->mbr; int i; bool active_found = false; for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_flag & MBR_PFLAG_ACTIVE) { active_found = true; break; } } if (!active_found && pm->ptstart > 0) { struct mbr_partition *mp = mbr_ptr_from_start(m, pm->ptstart); if (mp) { if (!quiet) msg_display(MSG_noactivepart); if (quiet || ask_yesno(MSG_fixactivepart)) { mp->mbrp_flag |= MBR_PFLAG_ACTIVE; active_found = true; } } } if (!active_found && !quiet) { msg_display(MSG_noactivepart); i = ask_reedit(arg); if (i <= 1) return i; } for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type != MBR_PTYPE_NETBSD) continue; m->mbr.mbr_parts[i].mbrp_flag |= MBR_PFLAG_ACTIVE; break; } return md_check_mbr(arg, &parts->mbr, quiet); } static bool mbr_guess_root(const struct disk_partitions *arg, daddr_t *start, daddr_t *size) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; const mbr_info_t *m = &parts->mbr; size_t i, num_found; bool prim = true; daddr_t pstart, psize; num_found = 0; do { for (i = 0; i < MBR_PART_COUNT; i++) { if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED) continue; if (!prim && i > 0 && MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type)) break; const struct mbr_partition *mp = &m->mbr.mbr_parts[i]; if (mp->mbrp_type != MBR_PTYPE_NETBSD) continue; if (num_found == 0) { pstart = m->sector + mp->mbrp_start; psize = mp->mbrp_size; } num_found++; if (m->last_mounted[i] != NULL && strcmp(m->last_mounted[i], "/") == 0) { *start = pstart; *size = psize; return true; } } prim = false; } while ((m = m->extended)); if (num_found == 1) { *start = pstart; *size = psize; return true; } return false; } struct part_attr_fmt_data { char *str; size_t avail_space, attr_no; const struct mbr_disk_partitions *parts; const struct disk_part_info *info; }; struct part_attr_set_data { size_t attr_no; const struct mbr_disk_partitions *parts; const char *str; mbr_info_t *mbr; }; static bool part_attr_fornat_str(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; struct part_attr_fmt_data *data = cookie; const char *attrtype = parts->dp.pscheme ->custom_attributes[data->attr_no].label; if (attrtype == MSG_ptn_active) { strlcpy(data->str, msg_string(primary && (mp->mbrp_flag & MBR_PFLAG_ACTIVE) ? MSG_Yes : MSG_No), data->avail_space); return true; #if BOOTSEL } else if (attrtype == MSG_boot_dflt) { strlcpy(data->str, msg_string( (parts->mbr.bootsec == mb->sector+mp->mbrp_start) ? MSG_Yes : MSG_No), data->avail_space); return true; } else if (attrtype == MSG_bootmenu) { strlcpy(data->str, mb->mbrb.mbrbs_nametab[i], data->avail_space); #endif } return false; } static bool part_attr_set_str(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { struct part_attr_set_data *data = cookie; const char *str = data->str; #ifdef BOOTSEL const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; const char *attrtype = parts->dp.pscheme ->custom_attributes[data->attr_no].label; mbr_info_t *m; #endif while (*str == ' ') str++; #if BOOTSEL if (attrtype == MSG_bootmenu) { for (m = data->mbr; m != mb; m = m->extended) ; strncpy(m->mbrb.mbrbs_nametab[i], str, sizeof(m->mbrb.mbrbs_nametab[i])); } #endif return false; } static bool part_attr_toggle(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; struct part_attr_set_data *data = cookie; const char *attrtype = parts->dp.pscheme ->custom_attributes[data->attr_no].label; int j; if (attrtype == MSG_ptn_active) { if (!primary) return false; data->mbr->mbr.mbr_parts[i].mbrp_flag ^= MBR_PFLAG_ACTIVE; for (j = 0; j < MBR_PART_COUNT; j++) { if (j == i) continue; data->mbr->mbr.mbr_parts[j].mbrp_flag &= ~MBR_PFLAG_ACTIVE; } return true; #ifdef BOOTSEL } else if (attrtype == MSG_boot_dflt) { if (data->mbr->bootsec == mb->sector+mp->mbrp_start) data->mbr->bootsec = 0; else data->mbr->bootsec = mb->sector+mp->mbrp_start; return true; #endif } return false; } static bool mbr_custom_attribute_format(const struct disk_partitions *arg, part_id id, size_t attr_no, const struct disk_part_info *info, char *res, size_t space) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; struct part_attr_fmt_data data; data.str = res; data.avail_space = space; data.attr_no = attr_no; data.parts = parts; data.info = info; return mbr_part_apply(arg, id, part_attr_fornat_str, &data); } static bool mbr_custom_attribute_toggle(struct disk_partitions *arg, part_id id, size_t attr_no) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; struct part_attr_set_data data; data.attr_no = attr_no; data.parts = parts; data.str = NULL; #ifdef BOOTSEL data.mbr = &parts->mbr; #endif return mbr_part_apply(arg, id, part_attr_toggle, &data); } static bool mbr_custom_attribute_set_str(struct disk_partitions *arg, part_id id, size_t attr_no, const char *new_val) { struct mbr_disk_partitions *parts = (struct mbr_disk_partitions*)arg; struct part_attr_set_data data; data.attr_no = attr_no; data.parts = parts; data.str = new_val; #ifdef BOOTSEL data.mbr = &parts->mbr; #endif return mbr_part_apply(arg, id, part_attr_set_str, &data); } static daddr_t mbr_part_alignment(const struct disk_partitions *arg) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; return parts->ptn_alignment; } static bool add_wedge(const char *disk, daddr_t start, daddr_t size, char *wname, size_t max_len) { struct dkwedge_info dkw; char diskpath[MAXPATHLEN]; int fd; memset(&dkw, 0, sizeof(dkw)); dkw.dkw_offset = start; dkw.dkw_size = size; snprintf((char*)dkw.dkw_wname, sizeof dkw.dkw_wname, "%s_%" PRIi64 "@%" PRIi64, disk, size, start); *wname = 0; fd = opendisk(disk, O_RDWR, diskpath, sizeof(diskpath), 0); if (fd < 0) return false; if (ioctl(fd, DIOCAWEDGE, &dkw) == -1) { close(fd); return false; } close(fd); strlcpy(wname, dkw.dkw_devname, max_len); return true; } static bool mbr_get_part_device(const struct disk_partitions *arg, part_id ptn, char *devname, size_t max_devname_len, int *part, enum dev_name_usage usage, bool with_path, bool life) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; struct disk_part_info info, tmp; part_id dptn; char *wedge_dev; if (!mbr_get_part_info(arg, ptn, &info)) return false; if (!mbr_part_get_wedge(arg, ptn, &wedge_dev) || wedge_dev == NULL) return false; if (wedge_dev[0] == 0) { /* * If we have secondary partitions, try to find a match there * and use that... */ if (parts->dlabel != NULL) { for (dptn = 0; dptn < parts->dlabel->num_part; dptn++) { if (!parts->dlabel->pscheme->get_part_info( parts->dlabel, dptn, &tmp)) continue; if (tmp.start != info.start || tmp.size != info.size) continue; return parts->dlabel->pscheme->get_part_device( parts->dlabel, dptn, devname, max_devname_len, part, usage, with_path, life); } } /* * Configure a new wedge and remember the name */ if (!add_wedge(arg->disk, info.start, info.size, wedge_dev, MBR_DEV_LEN)) return false; } assert(wedge_dev[0] != 0); switch (usage) { case logical_name: case plain_name: if (with_path) snprintf(devname, max_devname_len, _PATH_DEV "%s", wedge_dev); else strlcpy(devname, wedge_dev, max_devname_len); return true; case raw_dev_name: if (with_path) snprintf(devname, max_devname_len, _PATH_DEV "r%s", wedge_dev); else snprintf(devname, max_devname_len, "r%s", wedge_dev); return true; default: return false; } } static bool is_custom_attribute_writable(const struct disk_partitions *arg, part_id id, const mbr_info_t *mb, int i, bool primary, const struct mbr_partition *mp, void *cookie) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; struct part_attr_set_data *data = cookie; const char *attrtype = parts->dp.pscheme ->custom_attributes[data->attr_no].label; if (attrtype == MSG_ptn_active) /* Only 'normal' partitions can be 'Active' */ return primary && !MBR_IS_EXTENDED(mp->mbrp_type); #ifdef BOOTSEL else if (attrtype == MSG_boot_dflt) /* Only partitions with bootmenu names can be default */ return mb->mbrb.mbrbs_nametab[i][0] != 0; else if (attrtype == MSG_bootmenu) /* The extended partition isn't bootable */ return !MBR_IS_EXTENDED(mp->mbrp_type); #endif return false; } static bool mbr_custom_attribute_writable(const struct disk_partitions *arg, part_id id, size_t attr_no) { const struct mbr_disk_partitions *parts = (const struct mbr_disk_partitions*)arg; struct part_attr_set_data data; data.attr_no = attr_no; data.parts = parts; data.str = NULL; #ifdef BOOTSEL data.mbr = NULL; #endif return mbr_part_apply(arg, id, is_custom_attribute_writable, &data); } const struct disk_part_edit_column_desc mbr_edit_columns[] = { { .title = MSG_mbr_part_header_1, #if BOOTSEL .width = 16U #else .width = 26U #endif }, { .title = MSG_mbr_part_header_2, .width = 8U }, #if BOOTSEL { .title = MSG_mbr_part_header_3, .width = 9U }, #endif }; const struct disk_part_custom_attribute mbr_custom_attrs[] = { { .label = MSG_ptn_active, .type = pet_bool }, #if BOOTSEL { .label = MSG_boot_dflt, .type = pet_bool }, { .label = MSG_bootmenu, .type = pet_str, .strlen = MBR_BS_PARTNAMESIZE }, #endif }; const struct disk_partitioning_scheme mbr_parts = { .name = MSG_parttype_mbr, .short_name = MSG_parttype_mbr_short, .new_type_prompt = MSG_mbr_get_ptn_id, .part_flag_desc = MSG_mbr_flag_desc, .size_limit = (daddr_t)UINT32_MAX, .secondary_scheme = &disklabel_parts, .edit_columns_count = __arraycount(mbr_edit_columns), .edit_columns = mbr_edit_columns, .custom_attribute_count = __arraycount(mbr_custom_attrs), .custom_attributes = mbr_custom_attrs, .get_part_alignment = mbr_part_alignment, .get_part_info = mbr_get_part_info, .get_part_attr_str = mbr_part_attr_str, .format_partition_table_str = mbr_table_str, .part_type_can_change = mbr_part_type_can_change, .can_add_partition = mbr_can_add_partition, .custom_attribute_writable = mbr_custom_attribute_writable, .format_custom_attribute = mbr_custom_attribute_format, .custom_attribute_toggle = mbr_custom_attribute_toggle, .custom_attribute_set_str = mbr_custom_attribute_set_str, .get_part_types_count = mbr_get_part_type_count, .adapt_foreign_part_info = generic_adapt_foreign_part_info, .get_part_type = mbr_get_part_type, .get_fs_part_type = mbr_get_fs_part_type, .get_generic_part_type = mbr_get_generic_part_type, .create_custom_part_type = mbr_custom_part_type, .create_unknown_part_type = mbr_create_unknown_part_type, .secondary_partitions = mbr_read_disklabel, .write_to_disk = mbr_write_to_disk, .read_from_disk = mbr_read_from_disk, .create_new_for_disk = mbr_create_new, .guess_disk_geom = mbr_guess_geom, .get_cylinder_size = mbr_get_cylinder, .change_disk_geom = mbr_change_disk_geom, .get_part_device = mbr_get_part_device, .max_free_space_at = mbr_max_part_size, .get_free_spaces = mbr_get_free_spaces, .set_part_info = mbr_set_part_info, .delete_all_partitions = mbr_delete_all, .delete_partition = mbr_delete_part, .add_partition = mbr_add_part, .guess_install_target = mbr_guess_root, .post_edit_verify = mbr_verify, .pre_update_verify = mbr_verify_for_update, .free = mbr_free, .destroy_part_scheme = mbr_destroy_part_scheme, }; #endif