/* This utility makes a bootblock suitable for the SRM console/miniloader */

/* Usage:
 *	mkbb -b bootblock -f bootstrap -o offset device
 *
 * Where <device> is the name of the device to install the bootblock on,
 * and <lxboot> is the name of a bootblock to merge in.  This bootblock
 * contains the offset and size of the bootloader.  It must be exactly
 * 512 bytes long.
 */

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/stat.h>

/* for getopt */
extern char *optarg;
extern int optind;
extern int opterr;
extern int optopt;

/* Minimal definition of disklabel, so we don't have to include
 * asm/disklabel.h (confuses make)
 */
#ifndef MAXPARTITIONS
#define MAXPARTITIONS   8                       /* max. # of partitions */
#endif

#ifndef u8
#define u8 unsigned char
#endif

#ifndef u16
#define u16 unsigned short
#endif

#ifndef u32
#define u32 unsigned int
#endif

struct disklabel {
    u32	d_magic;				/* must be DISKLABELMAGIC */
    u16	d_type, d_subtype;
    u8	d_typename[16];
    u8	d_packname[16];
    u32	d_secsize;
    u32	d_nsectors;
    u32	d_ntracks;
    u32	d_ncylinders;
    u32	d_secpercyl;
    u32	d_secprtunit;
    u16	d_sparespertrack;
    u16	d_sparespercyl;
    u32	d_acylinders;
    u16	d_rpm, d_interleave, d_trackskew, d_cylskew;
    u32	d_headswitch, d_trkseek, d_flags;
    u32	d_drivedata[5];
    u32	d_spare[5];
    u32	d_magic2;				/* must be DISKLABELMAGIC */
    u16	d_checksum;
    u16	d_npartitions;
    u32	d_bbsize, d_sbsize;
    struct d_partition {
	u32	p_size;
	u32	p_offset;
	u32	p_fsize;
	u8	p_fstype;
	u8	p_frag;
	u16	p_cpg;
    } d_partitions[MAXPARTITIONS];
};


typedef union __bootblock {
    struct {
        char			__pad1[64];
        struct disklabel	__label;
    } __u1;
    struct {
	unsigned long		__pad2[60];
	unsigned long		__block_count;
	unsigned long		__start_block;
	unsigned long		__boot_flags;
	unsigned long		__checksum;
    } __u2;
    char		bootblock_bytes[512];
    unsigned long	bootblock_quadwords[64];
} bootblock;

#define	bootblock_label		__u1.__label
#define bootblock_checksum	__u2.__checksum
#define bootblock_bootstart	__u2.__start_block
#define bootblock_bootsize	__u2.__block_count
#define bootblock_bootflags	__u2.__boot_flags

static char *	bootblock_name = 0;
static char *	bootstrap_name = 0;
static int	bootstrap_size = 0;
static int	bootstrap_offset = 0;
static char *	device_name = 0;

static char	ioblock[1024];

int local_atoi(char * s)
{
    int		value = 0;

    while(*s) {
	if((*s >= '0') && (*s <= '9')) {
	    value *= 10;
	    value += (*s - '0');
	}
	else if(*s == 'K' || *s == 'k') {
	    value *= 1024;
	    return(value);
	}
	else if(*s == 'M' || *s == 'm') {
	    value *= (1024*1024);
	    return(value);
	}
	else {
	    return(0);
	}

	s++;
    }
    return(value);
}

main(int argc, char ** argv)
{
    bootblock		bootblock_from_disk;
    bootblock		bootloader_image;
    int			dev, fd;
    int			i;
    char		c;
    int			nread;
    struct stat		st;
    int			remaining;


    /* Parse args */
    while((c = getopt(argc, argv, "b:f:o:")) != -1) {
	switch (c) {
	    case 'b':
		bootblock_name = optarg;
		break;
	    case 'f':
		bootstrap_name = optarg;
		break;
	    case 'o':
		bootstrap_offset = local_atoi(optarg);
		break;
	    default:
		fprintf(stderr, "Unrecognized option '%c'\n", optopt);
		fprintf(stderr, "Usage: %s  -b bootblock -f bootstrap -o offset device\n", argv[0]);
		exit(0);
	}
    }

    if((optind+1) == argc) {
	device_name = argv[optind];
    }
    else {
	fprintf(stderr, "Usage: %s  -b bootblock -f bootstrap -o offset device\n", argv[0]);
	exit(0);
    }

    if(!bootblock_name || !bootstrap_name) {
	fprintf(stderr, "Usage: %s  -b bootblock -f bootstrap -o offset device\n", argv[0]);
	exit(0);
    }
	

    /* Stat the bootblock file to get the size */
    if(stat(bootstrap_name, &st) < 0) {
	perror(bootstrap_name);
	exit(0);
    }
    else {
	bootstrap_size = st.st_size;
    }

    /* open the device and make sure it's accessible */
    dev = open(device_name, O_RDWR);
    if(dev < 0) {
	perror(device_name);
	exit(0);
    }

    /* Now open the bootblock and make sure it's reasonable */
    fd = open(bootblock_name, O_RDONLY);
    if(fd < 0) {
	perror(bootblock_name);
	close(dev);
	exit(0);
    }

    /* Read in the bootblock */
    nread = read(fd, &bootloader_image, sizeof(bootblock));
    if(nread != sizeof(bootblock)) {
	perror("bootblock read");
	fprintf(stderr, "expected %d, got %d\n", sizeof(bootblock), nread);
	exit(0);
    }

    /* Read in the bootblock from device. */
    nread = read(dev, &bootblock_from_disk, sizeof(bootblock));
    if(nread != sizeof(bootblock)) {
	perror("bootblock read");
	fprintf(stderr, "expected %d, got %d\n", sizeof(bootblock), nread);
	exit(0);
    }

    /* Swap the bootblock's disklabel into the bootloader */
    bootloader_image.bootblock_label = bootblock_from_disk.bootblock_label;

    /* Set up the bootstrap fields of the bootblock */
    bootloader_image.bootblock_bootstart = bootstrap_offset / 512;
    bootloader_image.bootblock_bootsize = (bootstrap_size + 511)/512;
    bootloader_image.bootblock_bootflags = 0;

    /* Calculate the bootblock checksum */
    bootloader_image.bootblock_checksum = 0;
    for(i = 0; i < 63; i++) {
	bootloader_image.bootblock_checksum += 
			bootloader_image.bootblock_quadwords[i];
    }

    /* Write the bootblock out! */
    lseek(dev, 0L, SEEK_SET);
    if(write(dev, &bootloader_image, sizeof(bootblock)) != sizeof(bootblock)) {
	perror("bootblock write");
	exit(0);
    }

    close(fd);

    /* Write the bootstrap out */
    fd = open(bootstrap_name, O_RDONLY);
    lseek(dev, bootstrap_offset, SEEK_SET);


    remaining = bootstrap_size;
    while(remaining > 0) {
	int	iocount;

	iocount = (remaining > 1024) ? 1024 : remaining;
	read(fd, ioblock, iocount);
	write(dev, ioblock, iocount);
	remaining -= iocount;
    }

    close(dev);
    exit(0);
}


