/*      $NetBSD: md.c,v 1.15 2025/04/26 03:49:33 tsutsui Exp $  */

/*
 * Copyright 1997 Piermont Information Systems Inc.
 * All rights reserved.
 *
 * Based on code 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.
 */

/* md.c -- ofppc machine specific routines */

#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/disklabel_rdb.h>
#include <stdio.h>
#include <util.h>
#include <machine/cpu.h>

#include "defs.h"
#include "md.h"
#include "msg_defs.h"
#include "menu_defs.h"
#include "endian.h"

static int check_rdb(void);
static uint32_t rdbchksum(void *);

/* We use MBR_PTYPE_PREP like port-prep does. */
static int nonewfsmsdos = 0, nobootfix = 0, noprepfix=0;
static part_id bootpart_fat12 = NO_PART, bootpart_binfo = NO_PART,
    bootpart_prep = NO_PART;
static int bootinfo_mbr = 1;
static int rdb_found = 0;

/* bootstart/bootsize are for the fat */
int binfostart, binfosize, bprepstart, bprepsize;

void
md_init(void)
{
}

void
md_init_set_status(int flags)
{

        (void)flags;
}

bool
md_get_info(struct install_partition_desc *install)
{
        int res;

        if (check_rdb())
                return true;


        if (pm->no_mbr || pm->no_part)
                return true;

again:
        if (pm->parts == NULL) {

                const struct disk_partitioning_scheme *ps =
                    select_part_scheme(pm, NULL, true, NULL);

                if (!ps)
                        return false;

                struct disk_partitions *parts =
                   (*ps->create_new_for_disk)(pm->diskdev,
                   0, pm->dlsize, true, NULL);
                if (!parts)
                        return false;

                pm->parts = parts;
                if (ps->size_limit > 0 && pm->dlsize > ps->size_limit)
                        pm->dlsize = ps->size_limit;
        }

        res = set_bios_geom_with_mbr_guess(pm->parts);
        if (res == 0)
                return false;
        else if (res == 1)
                return true;

        pm->parts->pscheme->destroy_part_scheme(pm->parts);
        pm->parts = NULL;
        goto again;
}

/*
 * md back-end code for menu-driven BSD disklabel editor.
 */
int
md_make_bsd_partitions(struct install_partition_desc *install)
{
#if 0
        int i;
        int part;
        int maxpart = getmaxpartitions();
        int partstart;
        int part_raw, part_bsd;
        int ptend;
        int no_swap = 0;
#endif

        if (rdb_found) {
#if 0
        /*
         * XXX - need to test on real machine if the disklabel code
         * deals with RDB partitions properly, otherwise write
         * a read-only RDB backend
         */
                /*
                 * We found RDB partitions on the disk, which cannot be
                 * modified by rewriting the disklabel.
                 * So just use what we have got.
                 */
                for (part = 0; part < maxpart; part++) {
                        if (PI_ISBSDFS(&pm->bsdlabel[part])) {
                                pm->bsdlabel[part].pi_flags |=
                                    PIF_NEWFS | PIF_MOUNT;

                                if (part == PART_A)
                                        strcpy(pm->bsdlabel[part].pi_mount, "/");
                        }
                }

                part_bsd = part_raw = getrawpartition();
                if (part_raw == -1)
                        part_raw = PART_C;      /* for sanity... */
                pm->bsdlabel[part_raw].pi_offset = 0;
                pm->bsdlabel[part_raw].pi_size = pm->dlsize;

                set_sizemultname_meg();
rdb_edit_check:
                if (edit_and_check_label(pm->bsdlabel, maxpart, part_raw,
                    part_bsd) == 0) {
                        msg_display(MSG_abort);
                        return 0;
                }
                if (md_check_partitions() == 0)
                        goto rdb_edit_check;
#endif
                return 1;
        }

        /*
         * Initialize global variables that track space used on this disk.
         * Standard 4.4BSD 8-partition labels always cover whole disk.
         */
        if (pm->ptsize == 0)
                pm->ptsize = pm->dlsize - pm->ptstart;
        if (pm->dlsize == 0)
                pm->dlsize = pm->ptstart + pm->ptsize;

#if 0
        partstart = pm->ptstart;
        ptend = pm->ptstart + pm->ptsize;

        /* Ask for layout type -- standard or special */
        msg_fmt_display(MSG_layout, "%d%d%d",
                    pm->ptsize / (MEG / pm->sectorsize),
                    DEFROOTSIZE + DEFSWAPSIZE + DEFUSRSIZE,
                    DEFROOTSIZE + DEFSWAPSIZE + DEFUSRSIZE + XNEEDMB);

        process_menu(MENU_layout, NULL);

        /* Set so we use the 'real' geometry for rounding, input in MB */
        pm->current_cylsize = pm->dlcylsize;
        set_sizemultname_meg();

        /* Build standard partitions */
        memset(&pm->bsdlabel, 0, sizeof pm->bsdlabel);

        /* Set initial partition types to unused */
        for (part = 0 ; part < maxpart ; ++part)
                pm->bsdlabel[part].pi_fstype = FS_UNUSED;

        /* Whole disk partition */
        part_raw = getrawpartition();
        if (part_raw == -1)
                part_raw = PART_C;      /* for sanity... */
        pm->bsdlabel[part_raw].pi_offset = 0;
        pm->bsdlabel[part_raw].pi_size = pm->dlsize;

        if (part_raw == PART_D) {
                /* Probably a system that expects an i386 style mbr */
                part_bsd = PART_C;
                pm->bsdlabel[PART_C].pi_offset = pm->ptstart;
                pm->bsdlabel[PART_C].pi_size = pm->ptsize;
        } else {
                part_bsd = part_raw;
        }

        if (pm->bootsize != 0) {
                pm->bsdlabel[PART_BOOT_FAT12].pi_fstype = FS_MSDOS;
                pm->bsdlabel[PART_BOOT_FAT12].pi_size = pm->bootsize;
                pm->bsdlabel[PART_BOOT_FAT12].pi_offset = pm->bootstart;
                pm->bsdlabel[PART_BOOT_FAT12].pi_flags |= PART_BOOT_FAT12_PI_FLAGS;
                strlcpy(pm->bsdlabel[PART_BOOT_FAT12].pi_mount,
                    PART_BOOT_FAT12_PI_MOUNT,
                    sizeof pm->bsdlabel[PART_BOOT_FAT12].pi_mount);
        }
        if (binfosize != 0) {
                pm->bsdlabel[PART_BOOT_BINFO].pi_fstype = FS_OTHER;
                pm->bsdlabel[PART_BOOT_BINFO].pi_size = binfosize;
                pm->bsdlabel[PART_BOOT_BINFO].pi_offset = binfostart;
        }
        if (bprepsize != 0) {
                pm->bsdlabel[PART_BOOT_PREP].pi_fstype = FS_BOOT;
                pm->bsdlabel[PART_BOOT_PREP].pi_size = bprepsize;
                pm->bsdlabel[PART_BOOT_PREP].pi_offset = bprepstart;
        }

        /*
         * Save any partitions that are outside the area we are
         * going to use.
         * In particular this saves details of the other MBR
         * partitions on a multiboot i386 system.
         */
         for (i = maxpart; i--;) {
                if (pm->bsdlabel[i].pi_size != 0)
                        /* Don't overwrite special partitions */
                        continue;
                p = &pm->oldlabel[i];
                if (p->pi_fstype == FS_UNUSED || p->pi_size == 0)
                        continue;
                if (layoutkind == LY_USEEXIST) {
                        if (PI_ISBSDFS(p))
                                p->pi_flags |= PIF_MOUNT;
                } else {
                        if (p->pi_offset < pm->ptstart + pm->ptsize &&
                            p->pi_offset + p->pi_size > pm->ptstart)
                                /* Not outside area we are allocating */
                                continue;
                        if (p->pi_fstype == FS_SWAP)
                                no_swap = 1;
                }
                pm->bsdlabel[i] = pm->oldlabel[i];
         }

        if (layoutkind == LY_USEEXIST) {
                /* XXX Check we have a sensible layout */
                ;
        } else
                get_ptn_sizes(partstart, ptend - partstart, no_swap);

        /*
         * OK, we have a partition table. Give the user the chance to
         * edit it and verify it's OK, or abort altogether.
         */
 edit_check:
        if (edit_and_check_label(pm->bsdlabel, maxpart, part_raw, part_bsd) == 0) {
                msg_display(MSG_abort);
                return 0;
        }
        if (md_check_partitions() == 0)
                goto edit_check;

        /* Disk name */
        msg_prompt(MSG_packname, pm->bsddiskname, pm->bsddiskname, sizeof pm->bsddiskname);

        /* save label to disk for MI code to update. */
        (void) savenewlabel(pm->bsdlabel, maxpart);

        /* Everything looks OK. */
        return 1;
#endif

        return make_bsd_partitions(install);
}

/*
 * any additional partition validation
 */
bool
md_check_partitions(struct install_partition_desc *install)
{
        struct disk_partitions *parts;
        struct disk_part_info info;
        int fprep=0, ffat=0;
        part_id part;

        if (rdb_found)
                return 1;

        if (install->num < 1)
                return false;
        parts = install->infos[0].parts;        /* disklabel parts */
        if (parts->parent)
                parts = parts->parent;          /* MBR parts */

        /* we need to find a boot partition, otherwise we can't create
         * our msdos fs boot partition.  We make the assumption that
         * the user hasn't done something stupid, like move it away
         * from the MBR partition.
         */
        for (part = 0; part < parts->num_part; part++) {
                if (!parts->pscheme->get_part_info(parts, part, &info))
                        continue;

                if (info.fs_type == FS_MSDOS) {
                        bootpart_fat12 = part;
                        ffat++;
                } else if (info.fs_type == FS_BOOT) {
                        bootpart_prep = part;
                        fprep++;
                } else if (info.fs_type == FS_OTHER) {
                        bootpart_binfo = part;
                        fprep++;
                }
        }
        /* oh, the confusion */
        if (ffat >= 1 && fprep < 2) {
                noprepfix = 1;
                return true;
        }
        if (ffat < 1 && fprep >= 2) {
                nobootfix = 1;
                return true;
        }
        if (ffat >=1 && fprep >= 2) {
                return true;
        }

        msg_display(MSG_nobootpartdisklabel);
        process_menu(MENU_ok, NULL);
        nobootfix = 1;
        return false;
}

/*
 * hook called before writing new disklabel.
 */
bool
md_pre_disklabel(struct install_partition_desc *install,
    struct disk_partitions *parts)
{

        if (rdb_found)
                return true;


        if (parts->parent == NULL)
                return true;    /* no outer partitions */

        parts = parts->parent;

        msg_display_subst(MSG_dofdisk, 3, parts->disk,
            msg_string(parts->pscheme->name),
            msg_string(parts->pscheme->short_name));

        /* write edited "MBR" onto disk. */
        if (!parts->pscheme->write_to_disk(parts)) {
                msg_display(MSG_wmbrfail);
                process_menu(MENU_ok, NULL);
                return false;
        }
        return true;
}

/*
 * hook called after writing disklabel to new target disk.
 */
bool
md_post_disklabel(struct install_partition_desc *install,
    struct disk_partitions *parts)
{
        char bootdev[100];

        if (pm->bootstart == 0 || pm->bootsize == 0 || rdb_found)
                return 0;

        snprintf(bootdev, sizeof bootdev, "/dev/r%s%c", pm->diskdev,
            (char)('a'+bootpart_fat12));
        run_program(RUN_DISPLAY, "/sbin/newfs_msdos %s", bootdev);

        return 0;
}

/*
 * hook called after upgrade() or install() has finished setting
 * up the target disk but immediately before the user is given the
 * ``disks are now set up'' message.
 */
int
md_post_newfs(struct install_partition_desc *install)
{

        /* No bootblock. We use ofwboot from a partition visiable by OFW. */
        return 0;
}

int
md_post_extract(struct install_partition_desc *install, bool upgrade)
{
        char bootdev[100], bootbdev[100], version[64];
        struct disk_partitions *parts;

        /* if we can't make it bootable, just punt */
        if ((nobootfix && noprepfix) || rdb_found)
                return 0;

        snprintf(version, sizeof version, "NetBSD/%s %s", MACH, REL);
        run_program(RUN_DISPLAY, "/usr/mdec/mkbootinfo '%s' %d "
            "/tmp/bootinfo.txt", version, bootinfo_mbr);

        if (!nobootfix) {
                run_program(RUN_DISPLAY, "/bin/mkdir -p /%s/boot/ppc",
                    target_prefix());
                run_program(RUN_DISPLAY, "/bin/mkdir -p /%s/boot/netbsd",
                    target_prefix());
                run_program(RUN_DISPLAY, "/bin/cp /usr/mdec/ofwboot "
                    "/%s/boot/netbsd", target_prefix());
                run_program(RUN_DISPLAY, "/bin/cp /tmp/bootinfo.txt "
                    "/%s/boot/ppc", target_prefix());
                run_program(RUN_DISPLAY, "/bin/cp /usr/mdec/ofwboot "
                    "/%s/boot/ofwboot", target_prefix());
        }

        if (!noprepfix && install != NULL && install->num > 0) {
                parts = install->infos[0].parts;        /* disklabel */
                if (parts->parent != NULL)
                        parts = parts->parent;          /* MBR */

                parts->pscheme->get_part_device(parts, bootpart_prep,
                    bootdev, sizeof bootdev, NULL, raw_dev_name, true, true);
                parts->pscheme->get_part_device(parts, bootpart_prep,
                    bootbdev, sizeof bootbdev, NULL, plain_name, true, true);
                run_program(RUN_DISPLAY, "/bin/dd if=/dev/zero of=%s bs=512",
                    bootdev);
                run_program(RUN_DISPLAY, "/bin/dd if=/usr/mdec/ofwboot "
                    "of=%s bs=512", bootbdev);

                parts->pscheme->get_part_device(parts, bootpart_binfo,
                    bootdev, sizeof bootdev, NULL, raw_dev_name, true, true);
                parts->pscheme->get_part_device(parts, bootpart_binfo,
                    bootbdev, sizeof bootbdev, NULL, plain_name, true, true);
                run_program(RUN_DISPLAY, "/bin/dd if=/dev/zero of=%s bs=512",
                    bootdev);
                run_program(RUN_DISPLAY, "/bin/dd if=/tmp/bootinfo.txt "
                    "of=%s bs=512", bootbdev);
        }

        return 0;
}

void
md_cleanup_install(struct install_partition_desc *install)
{

#ifndef DEBUG
        enable_rc_conf();
#endif
}

int
md_pre_update(struct install_partition_desc *install)
{
#if 0
        struct mbr_partition *part;
        mbr_info_t *ext;
        int i;
#endif

        if (check_rdb())
                return 1;

#if 0
        read_mbr(pm->diskdev, &mbr);
        /* do a sanity check of the partition table */
        for (ext = &mbr; ext; ext = ext->extended) {
                part = ext->mbr.mbr_parts;
                for (i = 0; i < MBR_PART_COUNT; part++, i++) {
                        if (part->mbrp_type == MBR_PTYPE_PREP &&
                            part->mbrp_size > 50)
                                bootinfo_mbr = i+1;
                        if (part->mbrp_type == MBR_PTYPE_RESERVED_x21 &&
                            part->mbrp_size < (MIN_FAT12_BOOT/512)) {
                                msg_display(MSG_boottoosmall);
                                msg_fmt_display_add(MSG_nobootpartdisklabel,
                                    "%d", 0);
                                if (!ask_yesno(NULL))
                                        return 0;
                                nobootfix = 1;
                        }
                }
        }
#endif

        if (!md_check_partitions(install))
                return 0;

        return 1;
}

/* Upgrade support */
int
md_update(struct install_partition_desc *install)
{

        nonewfsmsdos = 1;
        md_post_newfs(install);
        return 1;
}


int
md_check_mbr(struct disk_partitions *parts, mbr_info_t *mbri, bool quiet)
{
        mbr_info_t *ext;
        struct mbr_partition *part;
        int i;

        for (ext = mbri; ext; ext = ext->extended) {
                part = ext->mbr.mbr_parts;
                for (i = 0; i < MBR_PART_COUNT; part++, i++) {
                        if (part->mbrp_type == MBR_PTYPE_FAT12) {
                                pm->bootstart = part->mbrp_start;
                                pm->bootsize = part->mbrp_size;
                        } else if (part->mbrp_type == MBR_PTYPE_PREP &&
                            part->mbrp_size < 50) {
                                /* this is the bootinfo partition */
                                binfostart = part->mbrp_start;
                                binfosize = part->mbrp_size;
                                bootinfo_mbr = i+1;
                        } else if (part->mbrp_type == MBR_PTYPE_PREP &&
                            part->mbrp_size > 50) {
                                bprepstart = part->mbrp_start;
                                bprepsize = part->mbrp_size;
                        }
                        break;
                }
        }

        /* we need to either have a pair of prep partitions, or a single
         * fat.  if neither, things are broken. */
        if (!(pm->bootsize >= (MIN_FAT12_BOOT/512) ||
                (binfosize >= (MIN_BINFO_BOOT/512) &&
                    bprepsize >= (MIN_PREP_BOOT/512)))) {
                if (quiet)
                        return 0;
                msg_display(MSG_bootnotright);
                return ask_reedit(parts);
        }

        /* check the prep partitions */
        if ((binfosize > 0 || bprepsize > 0) &&
            (binfosize < (MIN_BINFO_BOOT/512) ||
                bprepsize < (MIN_PREP_BOOT/512))) {
                if (quiet)
                        return 0;
                msg_display(MSG_preptoosmall);
                return ask_reedit(parts);
        }

        /* check the fat12 partitions */
        if (pm->bootsize > 0 && pm->bootsize < (MIN_FAT12_BOOT/512)) {
                if (quiet)
                        return 0;
                msg_display(MSG_boottoosmall);
                return ask_reedit(parts);
        }

        /* if both sets contain zero, thats bad */
        if ((pm->bootstart == 0 || pm->bootsize == 0) &&
            (binfosize == 0 || binfostart == 0 ||
                bprepsize == 0 || bprepstart == 0)) {
                if (quiet)
                        return 0;
                msg_display(MSG_nobootpart);
                return ask_reedit(parts);
        }
        return 2;
}

/*
 * NOTE, we use a reserved partition type, because some RS/6000 machines hang
 * hard if they find a FAT12, and if we use type prep, that indicates that
 * it should be read raw.
 * One partition for FAT12 booting
 * One partition for NetBSD
 * One partition to hold the bootinfo.txt file
 * One partition to hold ofwboot
 */

bool
md_parts_use_wholedisk(struct disk_partitions *parts)
{
        struct disk_part_info boot_parts[] = 
        {
                { .fs_type = FS_MSDOS, .size = FAT12_BOOT_SIZE/512 },
                { .fs_type = FS_OTHER, .size = BINFO_BOOT_SIZE/512 },
                { .fs_type = FS_BOOT, .size = PREP_BOOT_SIZE/512 }
        };

        return parts_use_wholedisk(parts, __arraycount(boot_parts),
             boot_parts);
}

const char *md_disklabel_cmd(void)
{

        /* we cannot rewrite an RDB disklabel */
        if (rdb_found)
                return "sync No disklabel";

        return "disklabel -w -r";
}

static int
check_rdb(void)
{
        char buf[512], diskpath[MAXPATHLEN];
        struct rdblock *rdb;
        off_t blk;
        int fd;

        /* Find out if this disk has a valid RDB, before continuing. */
        rdb = (struct rdblock *)buf;
        fd = opendisk(pm->diskdev, O_RDONLY, diskpath, sizeof(diskpath), 0);
        if (fd < 0)
                return 0;
        for (blk = 0; blk < RDB_MAXBLOCKS; blk++) {
                if (pread(fd, rdb, 512, blk * 512) != 512)
                        return 0;
                if (rdb->id == RDBLOCK_ID && rdbchksum(rdb) == 0) {
                        rdb_found = 1;  /* do not repartition! */
                        return 1;
                }
        }
        return 0;
}

static uint32_t
rdbchksum(void *bdata)
{
        uint32_t *blp, cnt, val;

        blp = bdata;
        cnt = blp[1];
        val = 0;
        while (cnt--)
                val += *blp++;
        return val;
}

int
md_pre_mount(struct install_partition_desc *install, size_t ndx)
{

        return 0;
}

bool
md_mbr_update_check(struct disk_partitions *parts, mbr_info_t *mbri)
{
        return false;   /* no change, no need to write back */
}

#ifdef HAVE_GPT
bool
md_gpt_post_write(struct disk_partitions *parts, part_id root_id,
    bool root_is_new, part_id efi_id, bool efi_is_new)
{
        /* no GPT boot support, nothing needs to be done here */
        return true;
}
#endif