/*      $NetBSD: installboot.c,v 1.19 2014/09/21 16:33:48 christos Exp $ */

/*-
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Paul Kranenburg.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``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 THE FOUNDATION OR CONTRIBUTORS
 * 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.
 */

#include <sys/param.h>
#include <sys/cdefs.h>
#include <sys/mount.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <ufs/ufs/dinode.h>
#include <ufs/ufs/dir.h>
#include <ufs/ffs/fs.h>
#include <err.h>
#include <fcntl.h>
#include <nlist.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/disklabel.h>

#include "loadfile.h"

int     verbose, nowrite, hflag;
char    *boot, *proto, *dev;

struct nlist nl[] = {
#define X_BLOCK_SIZE    0
#define X_BLOCK_COUNT   1
#define X_BLOCK_TABLE   2
#ifdef __ELF__
        { "block_size" },
        { "block_count" },
        { "block_table" },
#else
        { "_block_size" },
        { "_block_count" },
        { "_block_table" },
#endif
        { NULL }
};

int *block_size_p;              /* block size var. in prototype image */
int *block_count_p;             /* block count var. in prototype image */
/* XXX ondisk32 */
int32_t *block_table;           /* block number array in prototype image */
int     maxblocknum;            /* size of this array */


char            *loadprotoblocks(char *, size_t *);
int             loadblocknums(char *, int);
static void     devread(int, void *, daddr_t, size_t, char *);
static void     usage(void);
int             main(int, char *[]);


static void
usage(void)
{

        fprintf(stderr,
            "usage: installboot [-n] [-v] [-h] <boot> <proto> <device>\n");
        exit(1);
}

int
main(int argc, char *argv[])
{
        int     c;
        int     devfd;
        char    *protostore;
        size_t  protosize;

        while ((c = getopt(argc, argv, "vnh")) != -1) {
                switch (c) {
                case 'h':
                        /* Don't strip a.out header */
                        hflag = 1;
                        break;
                case 'n':
                        /* Do not actually write the bootblock to disk */
                        nowrite = 1;
                        break;
                case 'v':
                        /* Chat */
                        verbose = 1;
                        break;
                default:
                        usage();
                }
        }

        if (argc - optind < 3) {
                usage();
        }

        boot = argv[optind];
        proto = argv[optind + 1];
        dev = argv[optind + 2];

        if (verbose) {
                printf("boot: %s\n", boot);
                printf("proto: %s\n", proto);
                printf("device: %s\n", dev);
        }

        /* Load proto blocks into core */
        if ((protostore = loadprotoblocks(proto, &protosize)) == NULL)
                exit(1);

        /* XXX - Paranoia: Make sure size is aligned! */
        if (protosize & (DEV_BSIZE - 1))
                err(1, "proto bootblock bad size=%d", protosize);

        /* Open and check raw disk device */
        if ((devfd = open(dev, O_RDONLY, 0)) < 0)
                err(1, "open: %s", dev);

        /* Extract and load block numbers */
        if (loadblocknums(boot, devfd) != 0)
                exit(1);

        (void)close(devfd);

        if (nowrite)
                return 0;

        /* Write patched proto bootblocks into the superblock */
        if (protosize > SBLOCKSIZE - DEV_BSIZE)
                errx(1, "proto bootblocks too big");

        /* The primary bootblock needs to be written to the raw partition */
        dev[strlen(dev) - 1] = 'a' + RAW_PART;

        if ((devfd = open(dev, O_RDWR, 0)) < 0)
                err(1, "open: %s", dev);

        if (lseek(devfd, DEV_BSIZE, SEEK_SET) != DEV_BSIZE)
                err(1, "lseek bootstrap");

        /* Sync filesystems (to clean in-memory superblock?) */
        sync();

        if (write(devfd, protostore, protosize) != protosize)
                err(1, "write bootstrap");
        (void)close(devfd);
        return 0;
}

char *
loadprotoblocks(char *fname, size_t *size)
{
        int     fd;
        u_long  marks[MARK_MAX], bp, offs;

        fd = -1;

        /* Locate block number array in proto file */
        if (nlist(fname, nl) != 0) {
                warnx("nlist: %s: symbols not found", fname);
                return NULL;
        }

        marks[MARK_START] = 0;
        if ((fd = loadfile(fname, marks, COUNT_TEXT|COUNT_DATA)) == -1)
                return NULL;
        (void)close(fd);

        *size = roundup(marks[MARK_END] - marks[MARK_START], DEV_BSIZE);
        bp = (u_long)malloc(*size);

        offs = marks[MARK_START];
        marks[MARK_START] = bp - offs;

        if ((fd = loadfile(fname, marks, LOAD_TEXT|LOAD_DATA)) == -1)
                return NULL;
        (void)close(fd);

        /* Calculate the symbols' locations within the proto file */
        block_size_p  =   (int *)(bp + (nl[X_BLOCK_SIZE ].n_value - offs));
        block_count_p =   (int *)(bp + (nl[X_BLOCK_COUNT].n_value - offs));
        /* XXX ondisk32 */
        block_table = (int32_t *)(bp + (nl[X_BLOCK_TABLE].n_value - offs));
        maxblocknum = *block_count_p;

        if (verbose) {
                printf("%s: entry point %#lx\n", fname, marks[MARK_ENTRY]);
                printf("proto bootblock size %d\n", *size);
                printf("room for %d filesystem blocks at %#lx\n",
                        maxblocknum, nl[X_BLOCK_TABLE].n_value);
        }

        return (char *)bp;
}

static void
devread(int fd, void *buf, daddr_t blk, size_t size, char *msg)
{

        if (lseek(fd, dbtob(blk), SEEK_SET) != dbtob(blk))
                err(1, "%s: devread: lseek", msg);

        if (read(fd, buf, size) != size)
                err(1, "%s: devread: read", msg);
}

static char sblock[SBLOCKSIZE];

int
loadblocknums(char *boot, int devfd)
{
        int             i, fd;
        struct  stat    statbuf;
        struct  statvfs statvfsbuf;
        struct fs       *fs;
        char            *buf;
        daddr_t         blk, *ap;
        struct ufs1_dinode *ip;
        int             ndb;

        /*
         * Open 2nd-level boot program and record the block numbers
         * it occupies on the filesystem represented by `devfd'.
         */

        /* Make sure the (probably new) boot file is on disk. */
        sync(); sleep(1);

        if ((fd = open(boot, O_RDONLY)) < 0)
                err(1, "open: %s", boot);

        if (fstatvfs(fd, &statvfsbuf) != 0)
                err(1, "statfs: %s", boot);

        if (strncmp(statvfsbuf.f_fstypename, "ffs",
            sizeof(statvfsbuf.f_fstypename)) &&
            strncmp(statvfsbuf.f_fstypename, "ufs",
            sizeof(statvfsbuf.f_fstypename))) {
                errx(1, "%s: must be on an FFS filesystem", boot);
        }

        if (fsync(fd) != 0)
                err(1, "fsync: %s", boot);

        if (fstat(fd, &statbuf) != 0)
                err(1, "fstat: %s", boot);

        close(fd);

        /* Read superblock */
        devread(devfd, sblock, (daddr_t)(BBSIZE / DEV_BSIZE),
            SBLOCKSIZE, "superblock");
        fs = (struct fs *)sblock;

        /* Sanity-check super-block. */
        if (fs->fs_magic != FS_UFS1_MAGIC)
                errx(1, "Bad magic number in superblock, must be UFS1");
        if (fs->fs_inopb <= 0)
                err(1, "Bad inopb=%d in superblock", fs->fs_inopb);

        /* Read inode */
        if ((buf = malloc(fs->fs_bsize)) == NULL)
                errx(1, "No memory for filesystem block");

        blk = FFS_FSBTODB(fs, ino_to_fsba(fs, statbuf.st_ino));
        devread(devfd, buf, blk, fs->fs_bsize, "inode");
        ip = (struct ufs1_dinode *)(buf) + ino_to_fsbo(fs, statbuf.st_ino);

        /*
         * Have the inode.  Figure out how many blocks we need.
         */
        ndb = howmany(ip->di_size, fs->fs_bsize);
        if (ndb > maxblocknum)
                errx(1, "Too many blocks");
        *block_count_p = ndb;
        *block_size_p = fs->fs_bsize;
        if (verbose)
                printf("Will load %d blocks of size %d each.\n",
                    ndb, fs->fs_bsize);

        /*
         * Get the block numbers; we don't handle fragments
         */
        ap = ip->di_db;
        for (i = 0; i < UFS_NDADDR && *ap && ndb; i++, ap++, ndb--) {
                blk = FFS_FSBTODB(fs, *ap);
                if (verbose)
                        printf("%d: %d\n", i, blk);
                block_table[i] = blk;
        }
        if (ndb == 0)
                return 0;

        /*
         * Just one level of indirections; there isn't much room
         * for more in the 1st-level bootblocks anyway.
         */
        blk = FFS_FSBTODB(fs, ip->di_ib[0]);
        devread(devfd, buf, blk, fs->fs_bsize, "indirect block");
        /* XXX ondisk32 */
        ap = (int32_t *)buf;
        for (; i < FFS_NINDIR(fs) && *ap && ndb; i++, ap++, ndb--) {
                blk = FFS_FSBTODB(fs, *ap);
                if (verbose)
                        printf("%d: %d\n", i, blk);
                block_table[i] = blk;
        }

        return 0;
}