* Copyright 1997 Piermont Information Systems Inc.

/* $NetBSD: mbr.c,v 1.48 2024/04/11 06:42:18 andvar 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 [email protected]
* 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 <sys/param.h>
#include <sys/types.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <util.h>
#include <paths.h>
#include <sys/ioctl.h>
#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/alignment 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_format_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_format_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