/* $NetBSD: mkbootimage.c,v 1.21 2024/11/03 03:11:24 gutteridge Exp $ */ /*- * Copyright (c) 2007 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Tim Rightnour and NONAKA Kimihiro * * 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. */ #if HAVE_NBTOOL_CONFIG_H #include "nbtool_config.h" #include "../../sys/sys/bootblock.h" #else #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #undef USE_SYSCTL #if defined(__NetBSD__) && !defined(HAVE_NBTOOL_CONFIG_H) #define USE_SYSCTL 1 #include #include #include #endif /* BFD ELF headers */ #include #include #include "bebox_bootrec.h" #include "byteorder.h" #include "magic.h" #include "pef.h" #include "rs6000_bootrec.h" /* Globals */ int inkernflag = 1; int saloneflag = 0; int verboseflag = 0; int lfloppyflag = 0; Elf32_External_Ehdr hdr, khdr; struct stat elf_stat; unsigned char mbr[512]; /* the boot and config records for rs6000 */ rs6000_boot_record_t bootrec; rs6000_config_record_t confrec; /* supported platforms */ char *sup_plats[] = { "bebox", "prep", "rs6000", NULL, }; /* * Macros to get values from multi-byte ELF header fields. These assume * a big-endian image. */ #define ELFGET16(x) (((x)[0] << 8) | (x)[1]) #define ELFGET32(x) (((x)[0] << 24) | ((x)[1] << 16) | \ ((x)[2] << 8) | (x)[3]) #define ULALIGN(x) ((x + 0x0f) & 0xfffffff0) static void usage(int); static int open_file(const char *, char *, Elf32_External_Ehdr *, struct stat *); static void check_mbr(int, char *); static void rs6000_build_records(int); int main(int, char **); static void usage(int extended) { int i; if (extended) { fprintf(stderr, "You are not running this program on" " the target machine. You must supply the\n" "machine architecture with the -m flag\n"); fprintf(stderr, "Supported architectures: "); for (i=0; sup_plats[i] != NULL; i++) fprintf(stderr, " %s", sup_plats[i]); fprintf(stderr, "\n\n"); } #ifdef USE_SYSCTL fprintf(stderr, "usage: %s [-Ilsv] [-m machine] [-b bootfile] " "[-k kernel] [-r rawdev] [-t epoch] bootimage\n", getprogname()); #else fprintf(stderr, "usage: %s [-Ilsv] -m machine [-b bootfile] " "[-k kernel] [-r rawdev] [-t epoch] bootimage\n", getprogname()); #endif exit(1); } /* verify the file is ELF and ppc, and open it up */ static int open_file(const char *ftype, char *file, Elf32_External_Ehdr *hdr, struct stat *f_stat) { int fd; if ((fd = open(file, 0)) < 0) errx(2, "Can't open %s '%s': %s", ftype, file, strerror(errno)); fstat(fd, f_stat); if (read(fd, hdr, sizeof(Elf32_External_Ehdr)) != sizeof(Elf32_External_Ehdr)) errx(3, "Can't read input '%s': %s", file, strerror(errno)); if (hdr->e_ident[EI_MAG0] != ELFMAG0 || hdr->e_ident[EI_MAG1] != ELFMAG1 || hdr->e_ident[EI_MAG2] != ELFMAG2 || hdr->e_ident[EI_MAG3] != ELFMAG3 || hdr->e_ident[EI_CLASS] != ELFCLASS32) errx(3, "input '%s' is not ELF32 format", file); if (hdr->e_ident[EI_DATA] != ELFDATA2MSB) errx(3, "input '%s' is not big-endian", file); if (ELFGET16(hdr->e_machine) != EM_PPC) errx(3, "input '%s' is not PowerPC exec binary", file); return fd; } static void prep_check_mbr(int prep_fd, char *rawdev) { int raw_fd; unsigned long entry, length; struct mbr_partition *mbrp; struct stat raw_stat; /* If we are building a standalone image, do not write an MBR, just * set entry point and boot image size skipping over elf header */ if (saloneflag) { entry = sa_htole32(0x400); length = sa_htole32(elf_stat.st_size - sizeof(hdr) + 0x400); lseek(prep_fd, sizeof(mbr), SEEK_SET); write(prep_fd, &entry, sizeof(entry)); write(prep_fd, &length, sizeof(length)); return; } /* * if we have a raw device, we need to check to see if it already * has a partition table, and if so, read it in and check for * suitability. */ if (rawdev != NULL) { raw_fd = open(rawdev, O_RDONLY, 0); if (raw_fd == -1) errx(3, "couldn't open raw device %s: %s", rawdev, strerror(errno)); fstat(raw_fd, &raw_stat); if (!S_ISCHR(raw_stat.st_mode)) errx(3, "%s is not a raw device", rawdev); if (read(raw_fd, mbr, 512) != 512) errx(3, "MBR Read Failed: %s", strerror(errno)); mbrp = (struct mbr_partition *)&mbr[MBR_PART_OFFSET]; if (mbrp->mbrp_type != MBR_PTYPE_PREP) errx(3, "First partition is not of type 0x%x.", MBR_PTYPE_PREP); if (mbrp->mbrp_start != 0) errx(3, "Use of the raw device is intended for" " upgrading of legacy installations. Your" " install does not have a PReP boot partition" " starting at sector 0. Use the -s option" " to build an image instead."); /* if we got this far, we are fine, write back the partition * and write the entry points and get outta here */ /* Set entry point and boot image size skipping over elf header */ lseek(prep_fd, 0, SEEK_SET); entry = sa_htole32(0x400); length = sa_htole32(elf_stat.st_size - sizeof(hdr) + 0x400); write(prep_fd, mbr, sizeof(mbr)); write(prep_fd, &entry, sizeof(entry)); write(prep_fd, &length, sizeof(length)); close(raw_fd); return; } /* if we get to here, we want to build a standard floppy or netboot * image to file, so just build it */ memset(mbr, 0, sizeof(mbr)); mbrp = (struct mbr_partition *)&mbr[MBR_PART_OFFSET]; /* Set entry point and boot image size skipping over elf header */ entry = sa_htole32(0x400); length = sa_htole32(elf_stat.st_size - sizeof(hdr) + 0x400); /* * Set magic number for msdos partition */ *(unsigned short *)&mbr[MBR_MAGIC_OFFSET] = sa_htole16(MBR_MAGIC); /* * Build a "PReP" partition table entry in the boot record * - "PReP" may only look at the system_indicator */ mbrp->mbrp_flag = MBR_PFLAG_ACTIVE; mbrp->mbrp_type = MBR_PTYPE_PREP; /* * The first block of the diskette is used by this "boot record" which * actually contains the partition table. (The first block of the * partition contains the boot image, but I digress...) We'll set up * one partition on the diskette and it shall contain the rest of the * diskette. */ mbrp->mbrp_shd = 0; /* zero-based */ mbrp->mbrp_ssect = 2; /* one-based */ mbrp->mbrp_scyl = 0; /* zero-based */ mbrp->mbrp_ehd = 1; /* assumes two heads */ if (lfloppyflag) mbrp->mbrp_esect = 36; /* 2.88MB floppy */ else mbrp->mbrp_esect = 18; /* assumes 18 sectors/track */ mbrp->mbrp_ecyl = 79; /* assumes 80 cylinders/diskette */ /* * The "PReP" software ignores the above fields and just looks at * the next two. * - size of the diskette is (assumed to be) * (2 tracks/cylinder)(18 sectors/tracks)(80 cylinders/diskette) * - unlike the above sector numbers, * the beginning sector is zero-based! */ /* This has to be 0 on the PowerStack? */ mbrp->mbrp_start = sa_htole32(0); mbrp->mbrp_size = sa_htole32(2 * 18 * 80 - 1); write(prep_fd, mbr, sizeof(mbr)); write(prep_fd, &entry, sizeof(entry)); write(prep_fd, &length, sizeof(length)); } static int prep_build_image(char *kernel, char *boot, char *rawdev, char *outname) { unsigned char *elf_img = NULL, *kern_img = NULL; int i, ch, tmp, kgzlen, err; int elf_fd, prep_fd, kern_fd, elf_img_len = 0; off_t lenpos, kstart, kend; unsigned long length; long flength; gzFile gzf; struct stat kern_stat; Elf32_External_Phdr phdr; elf_fd = open_file("bootloader", boot, &hdr, &elf_stat); if (inkernflag) { kern_fd = open_file("kernel", kernel, &khdr, &kern_stat); kern_len = kern_stat.st_size + PREP_MAGICSIZE + KERNLENSIZE; } else kern_len = PREP_MAGICSIZE + KERNLENSIZE; for (i = 0; i < ELFGET16(hdr.e_phnum); i++) { lseek(elf_fd, ELFGET32(hdr.e_phoff) + sizeof(phdr) * i, SEEK_SET); if (read(elf_fd, &phdr, sizeof(phdr)) != sizeof(phdr)) errx(3, "Can't read input '%s' phdr : %s", boot, strerror(errno)); if ((ELFGET32(phdr.p_type) != PT_LOAD) || !(ELFGET32(phdr.p_flags) & PF_X)) continue; fstat(elf_fd, &elf_stat); elf_img_len = elf_stat.st_size - ELFGET32(phdr.p_offset); lseek(elf_fd, ELFGET32(phdr.p_offset), SEEK_SET); break; } if ((prep_fd = open(outname, O_RDWR|O_TRUNC, 0)) < 0) { /* we couldn't open it, it must be new */ prep_fd = creat(outname, 0644); if (prep_fd < 0) errx(2, "Can't open output '%s': %s", outname, strerror(errno)); } prep_check_mbr(prep_fd, rawdev); /* Set file pos. to 2nd sector where image will be written */ lseek(prep_fd, 0x400, SEEK_SET); /* Copy boot image */ elf_img = malloc(elf_img_len); if (!elf_img) errx(3, "Can't malloc: %s", strerror(errno)); if (read(elf_fd, elf_img, elf_img_len) != elf_img_len) errx(3, "Can't read file '%s' : %s", boot, strerror(errno)); write(prep_fd, elf_img, elf_img_len); free(elf_img); if (inkernflag) { /* Copy kernel */ kern_img = malloc(kern_stat.st_size); if (kern_img == NULL) errx(3, "Can't malloc: %s", strerror(errno)); /* we need to jump back after having read the headers */ lseek(kern_fd, 0, SEEK_SET); if (read(kern_fd, (void *)kern_img, kern_stat.st_size) != kern_stat.st_size) errx(3, "Can't read kernel '%s' : %s", kernel, strerror(errno)); } gzf = gzdopen(dup(prep_fd), "a"); if (gzf == NULL) errx(3, "Can't init compression: %s", strerror(errno)); if (gzsetparams(gzf, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY) != Z_OK) errx(3, "%s", gzerror(gzf, &err)); /* write a magic number and size before the kernel */ write(prep_fd, (void *)prep_magic, PREP_MAGICSIZE); lenpos = lseek(prep_fd, 0, SEEK_CUR); tmp = sa_htobe32(0); write(prep_fd, (void *)&tmp, KERNLENSIZE); /* write in the compressed kernel */ kstart = lseek(prep_fd, 0, SEEK_CUR); if (inkernflag) { kgzlen = gzwrite(gzf, kern_img, kern_stat.st_size); gzclose(gzf); } kend = lseek(prep_fd, 0, SEEK_CUR); /* jump back to the length position now that we know the length */ lseek(prep_fd, lenpos, SEEK_SET); kgzlen = kend - kstart; tmp = sa_htobe32(kgzlen); write(prep_fd, (void *)&tmp, KERNLENSIZE); length = sa_htole32(0x400 + elf_img_len + 8 + kgzlen); lseek(prep_fd, sizeof(mbr) + 4, SEEK_SET); write(prep_fd, &length, sizeof(length)); flength = 0x400 + elf_img_len + 8 + kgzlen; if (lfloppyflag) flength -= (5760 * 512); else flength -= (2880 * 512); if (flength > 0 && !saloneflag) fprintf(stderr, "%s: Image %s is %ld bytes larger than single" " floppy. Can only be used for netboot.\n", getprogname(), outname, flength); if (inkernflag) { free(kern_img); close(kern_fd); } close(prep_fd); close(elf_fd); return 0; } /* Fill in the needed information on the boot and config records. Most of * this is just AIX garbage that we don't really need to boot. */ static void rs6000_build_records(int img_len) { int bcl; /* zero out all the fields, so we only have to set the ones * we care about, which are rather few. */ memset(&bootrec, 0, sizeof(rs6000_boot_record_t)); memset(&confrec, 0, sizeof(rs6000_config_record_t)); bootrec.ipl_record = IPLRECID; bcl = img_len/512; if (img_len%512 != 0) bcl++; bootrec.bootcode_len = bcl; bootrec.bootcode_off = 0; /* XXX */ bootrec.bootpart_start = 2; /* skip bootrec and confrec */ bootrec.bootprg_start = 2; bootrec.bootpart_len = bcl; bootrec.boot_load_addr = 0x800000; /* XXX? */ bootrec.boot_frag = 1; bootrec.boot_emul = 0x02; /* ?? */ /* service mode is a repeat of normal mode */ bootrec.servcode_len = bootrec.bootcode_len; bootrec.servcode_off = bootrec.bootcode_off; bootrec.servpart_start = bootrec.bootpart_start; bootrec.servprg_start = bootrec.bootprg_start; bootrec.servpart_len = bootrec.bootpart_len; bootrec.serv_load_addr = bootrec.boot_load_addr; bootrec.serv_frag = bootrec.boot_frag; bootrec.serv_emul = bootrec.boot_emul; /* now the config record */ confrec.conf_rec = CONFRECID; confrec.sector_size = 0x02; /* 512 bytes */ confrec.last_cyl = 0x4f; /* 79 cyl, emulates floppy */ } static int rs6000_build_image(char *kernel, char *boot, char *rawdev, char *outname) { unsigned char *elf_img = NULL, *kern_img = NULL; int i, ch, tmp, kgzlen, err; int elf_fd, rs6000_fd, kern_fd, elf_img_len = 0, elf_pad; uint32_t swapped[128]; off_t lenpos, kstart, kend; unsigned long length; long flength; gzFile gzf; struct stat kern_stat; Elf32_External_Phdr phdr; elf_fd = open_file("bootloader", boot, &hdr, &elf_stat); kern_fd = open_file("kernel", kernel, &khdr, &kern_stat); kern_len = kern_stat.st_size + RS6000_MAGICSIZE + KERNLENSIZE; for (i = 0; i < ELFGET16(hdr.e_phnum); i++) { lseek(elf_fd, ELFGET32(hdr.e_phoff) + sizeof(phdr) * i, SEEK_SET); if (read(elf_fd, &phdr, sizeof(phdr)) != sizeof(phdr)) errx(3, "Can't read input '%s' phdr : %s", boot, strerror(errno)); if ((ELFGET32(phdr.p_type) != PT_LOAD) || !(ELFGET32(phdr.p_flags) & PF_X)) continue; fstat(elf_fd, &elf_stat); elf_img_len = elf_stat.st_size - ELFGET32(phdr.p_offset); elf_pad = ELFGET32(phdr.p_memsz) - ELFGET32(phdr.p_filesz); if (verboseflag) printf("Padding %d\n", elf_pad); lseek(elf_fd, ELFGET32(phdr.p_offset), SEEK_SET); break; } if ((rs6000_fd = open(outname, O_RDWR|O_TRUNC, 0)) < 0) { /* we couldn't open it, it must be new */ rs6000_fd = creat(outname, 0644); if (rs6000_fd < 0) errx(2, "Can't open output '%s': %s", outname, strerror(errno)); } /* Set file pos. to 2nd sector where image will be written */ lseek(rs6000_fd, 0x400, SEEK_SET); /* Copy boot image */ elf_img = malloc(elf_img_len); if (!elf_img) errx(3, "Can't malloc: %s", strerror(errno)); if (read(elf_fd, elf_img, elf_img_len) != elf_img_len) errx(3, "Can't read file '%s' : %s", boot, strerror(errno)); write(rs6000_fd, elf_img, elf_img_len); free(elf_img); /* now dump in the padding space for the BSS */ elf_pad += 100; /* just a little extra for good luck */ lseek(rs6000_fd, elf_pad, SEEK_CUR); /* Copy kernel */ kern_img = malloc(kern_stat.st_size); if (kern_img == NULL) errx(3, "Can't malloc: %s", strerror(errno)); /* we need to jump back after having read the headers */ lseek(kern_fd, 0, SEEK_SET); if (read(kern_fd, (void *)kern_img, kern_stat.st_size) != kern_stat.st_size) errx(3, "Can't read kernel '%s' : %s", kernel, strerror(errno)); gzf = gzdopen(dup(rs6000_fd), "a"); if (gzf == NULL) errx(3, "Can't init compression: %s", strerror(errno)); if (gzsetparams(gzf, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY) != Z_OK) errx(3, "%s", gzerror(gzf, &err)); /* write a magic number and size before the kernel */ write(rs6000_fd, (void *)rs6000_magic, RS6000_MAGICSIZE); lenpos = lseek(rs6000_fd, 0, SEEK_CUR); if (verboseflag) printf("wrote magic at pos 0x%lx\n", (unsigned long)lenpos); tmp = sa_htobe32(0); write(rs6000_fd, (void *)&tmp, KERNLENSIZE); /* write in the compressed kernel */ kstart = lseek(rs6000_fd, 0, SEEK_CUR); if (verboseflag) printf("kernel start at pos 0x%lx\n", (unsigned long)kstart); kgzlen = gzwrite(gzf, kern_img, kern_stat.st_size); gzclose(gzf); kend = lseek(rs6000_fd, 0, SEEK_CUR); if (verboseflag) printf("kernel end at pos 0x%lx\n", (unsigned long)kend); /* jump back to the length position now that we know the length */ lseek(rs6000_fd, lenpos, SEEK_SET); kgzlen = kend - kstart; tmp = sa_htobe32(kgzlen); if (verboseflag) printf("kernel len = 0x%x tmp = 0x%x\n", kgzlen, tmp); write(rs6000_fd, (void *)&tmp, KERNLENSIZE); #if 0 lseek(rs6000_fd, sizeof(boot_record_t) + sizeof(config_record_t), SEEK_SET); /* set entry and length */ length = sa_htole32(0x400); write(rs6000_fd, &length, sizeof(length)); length = sa_htole32(0x400 + elf_img_len + 8 + kgzlen); write(rs6000_fd, &length, sizeof(length)); #endif /* generate the header now that we know the kernel length */ if (verboseflag) printf("building records\n"); rs6000_build_records(elf_img_len + 8 + kgzlen); lseek(rs6000_fd, 0, SEEK_SET); /* ROM wants it byteswapped in 32bit chunks */ if (verboseflag) printf("writing records\n"); memcpy(swapped, &bootrec, sizeof(rs6000_boot_record_t)); for (i=0; i < 128; i++) swapped[i] = sa_htobe32(swapped[i]); write(rs6000_fd, swapped, sizeof(rs6000_boot_record_t)); memcpy(swapped, &confrec, sizeof(rs6000_config_record_t)); for (i=0; i < 128; i++) swapped[i] = sa_htobe32(swapped[i]); write(rs6000_fd, swapped, sizeof(rs6000_config_record_t)); free(kern_img); close(kern_fd); close(rs6000_fd); close(elf_fd); return 0; } static int bebox_write_header(int bebox_fd, int elf_image_len, int kern_img_len) { int hsize = BEBOX_HEADER_SIZE; unsigned long textOffset, dataOffset, ldrOffset; unsigned long entry_vector[3]; struct FileHeader fileHdr; struct SectionHeader textHdr, dataHdr, ldrHdr; struct LoaderHeader lh; ldrOffset = ULALIGN(sizeof (fileHdr) + sizeof (textHdr) + sizeof (dataHdr) + sizeof (ldrHdr)); dataOffset = ULALIGN(ldrOffset + sizeof (lh)); textOffset = ULALIGN(dataOffset + sizeof (entry_vector) + kern_img_len); /* Create the File Header */ memset(&fileHdr, 0, sizeof (fileHdr)); fileHdr.magic = sa_htobe32(PEF_MAGIC); fileHdr.fileTypeID = sa_htobe32(PEF_FILE); fileHdr.archID = sa_htobe32(PEF_PPC); fileHdr.versionNumber = sa_htobe32(1); fileHdr.numSections = sa_htobe16(3); fileHdr.loadableSections = sa_htobe16(2); write(bebox_fd, &fileHdr, sizeof (fileHdr)); /* Create the Section Header for TEXT */ memset(&textHdr, 0, sizeof (textHdr)); textHdr.sectionName = sa_htobe32(-1); textHdr.sectionAddress = sa_htobe32(0); textHdr.execSize = sa_htobe32(elf_image_len); textHdr.initSize = sa_htobe32(elf_image_len); textHdr.rawSize = sa_htobe32(elf_image_len); textHdr.fileOffset = sa_htobe32(textOffset); textHdr.regionKind = CodeSection; textHdr.shareKind = ContextShare; textHdr.alignment = 4; /* 16 byte alignment */ write(bebox_fd, &textHdr, sizeof (textHdr)); /* Create the Section Header for DATA */ memset(&dataHdr, 0, sizeof (dataHdr)); dataHdr.sectionName = sa_htobe32(-1); dataHdr.sectionAddress = sa_htobe32(0); dataHdr.execSize = sa_htobe32(sizeof (entry_vector) + kern_img_len); dataHdr.initSize = sa_htobe32(sizeof (entry_vector) + kern_img_len); dataHdr.rawSize = sa_htobe32(sizeof (entry_vector) + kern_img_len); dataHdr.fileOffset = sa_htobe32(dataOffset); dataHdr.regionKind = DataSection; dataHdr.shareKind = ContextShare; dataHdr.alignment = 4; /* 16 byte alignment */ write(bebox_fd, &dataHdr, sizeof (dataHdr)); /* Create the Section Header for loader stuff */ memset(&ldrHdr, 0, sizeof (ldrHdr)); ldrHdr.sectionName = sa_htobe32(-1); ldrHdr.sectionAddress = sa_htobe32(0); ldrHdr.execSize = sa_htobe32(sizeof (lh)); ldrHdr.initSize = sa_htobe32(sizeof (lh)); ldrHdr.rawSize = sa_htobe32(sizeof (lh)); ldrHdr.fileOffset = sa_htobe32(ldrOffset); ldrHdr.regionKind = LoaderSection; ldrHdr.shareKind = GlobalShare; ldrHdr.alignment = 4; /* 16 byte alignment */ write(bebox_fd, &ldrHdr, sizeof (ldrHdr)); /* Create the Loader Header */ memset(&lh, 0, sizeof (lh)); lh.entryPointSection = sa_htobe32(1); /* Data */ lh.entryPointOffset = sa_htobe32(0); lh.initPointSection = sa_htobe32(-1); lh.initPointOffset = sa_htobe32(0); lh.termPointSection = sa_htobe32(-1); lh.termPointOffset = sa_htobe32(0); lseek(bebox_fd, ldrOffset + hsize, SEEK_SET); write(bebox_fd, &lh, sizeof (lh)); /* Copy the pseudo-DATA */ memset(entry_vector, 0, sizeof (entry_vector)); entry_vector[0] = sa_htobe32(BEBOX_ENTRY); /* Magic */ lseek(bebox_fd, dataOffset + hsize, SEEK_SET); write(bebox_fd, entry_vector, sizeof (entry_vector)); return textOffset; } static int bebox_build_image(char *kernel, char *boot, char *rawdev, char *outname, char *repro_timestamp) { unsigned char *elf_img = NULL, *kern_img = NULL, *header_img = NULL; int i, ch, tmp, kgzlen, err, hsize = BEBOX_HEADER_SIZE; int elf_fd, bebox_fd, kern_fd, elf_img_len = 0; off_t lenpos, kstart, kend, toff, endoff, flength; uint32_t swapped[128]; int32_t *offset; gzFile gzf; struct stat kern_stat; struct bebox_image_block *p; struct timeval tp; Elf32_External_Phdr phdr; elf_fd = open_file("bootloader", boot, &hdr, &elf_stat); if (inkernflag) { kern_fd = open_file("kernel", kernel, &khdr, &kern_stat); kern_len = kern_stat.st_size + BEBOX_MAGICSIZE + KERNLENSIZE; } else kern_len = BEBOX_MAGICSIZE + KERNLENSIZE; for (i = 0; i < ELFGET16(hdr.e_phnum); i++) { lseek(elf_fd, ELFGET32(hdr.e_phoff) + sizeof(phdr) * i, SEEK_SET); if (read(elf_fd, &phdr, sizeof(phdr)) != sizeof(phdr)) errx(3, "Can't read input '%s' phdr : %s", boot, strerror(errno)); if ((ELFGET32(phdr.p_type) != PT_LOAD) || !(ELFGET32(phdr.p_flags) & PF_X)) continue; fstat(elf_fd, &elf_stat); elf_img_len = ELFGET32(phdr.p_filesz); lseek(elf_fd, ELFGET32(phdr.p_offset), SEEK_SET); break; } if ((bebox_fd = open(outname, O_RDWR|O_TRUNC, 0)) < 0) { /* we couldn't open it, it must be new */ bebox_fd = creat(outname, 0644); if (bebox_fd < 0) errx(2, "Can't open output '%s': %s", outname, strerror(errno)); } lseek(bebox_fd, hsize, SEEK_SET); if (inkernflag) { /* * write the header with the wrong values to get the offset * right */ bebox_write_header(bebox_fd, elf_img_len, kern_stat.st_size); /* Copy kernel */ kern_img = malloc(kern_stat.st_size); if (kern_img == NULL) errx(3, "Can't malloc: %s", strerror(errno)); /* we need to jump back after having read the headers */ lseek(kern_fd, 0, SEEK_SET); if (read(kern_fd, (void *)kern_img, kern_stat.st_size) != kern_stat.st_size) errx(3, "Can't read kernel '%s' : %s", kernel, strerror(errno)); gzf = gzdopen(dup(bebox_fd), "a"); if (gzf == NULL) errx(3, "Can't init compression: %s", strerror(errno)); if (gzsetparams(gzf, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY) != Z_OK) errx(3, "%s", gzerror(gzf, &err)); } else bebox_write_header(bebox_fd, elf_img_len, 0); /* write a magic number and size before the kernel */ write(bebox_fd, (void *)bebox_magic, BEBOX_MAGICSIZE); lenpos = lseek(bebox_fd, 0, SEEK_CUR); tmp = sa_htobe32(0); write(bebox_fd, (void *)&tmp, KERNLENSIZE); if (inkernflag) { /* write in the compressed kernel */ kstart = lseek(bebox_fd, 0, SEEK_CUR); kgzlen = gzwrite(gzf, kern_img, kern_stat.st_size); gzclose(gzf); kend = lseek(bebox_fd, 0, SEEK_CUR); free(kern_img); } else { kstart = kend = lseek(bebox_fd, 0, SEEK_CUR); kgzlen = 0; } /* jump back to the length position now that we know the length */ lseek(bebox_fd, lenpos, SEEK_SET); kgzlen = kend - kstart; tmp = sa_htobe32(kgzlen); write(bebox_fd, (void *)&tmp, KERNLENSIZE); /* now rewrite the header correctly */ lseek(bebox_fd, hsize, SEEK_SET); tmp = kgzlen + BEBOX_MAGICSIZE + KERNLENSIZE; toff = bebox_write_header(bebox_fd, elf_img_len, tmp); /* Copy boot image */ elf_img = malloc(elf_img_len); if (!elf_img) errx(3, "Can't malloc: %s", strerror(errno)); if (read(elf_fd, elf_img, elf_img_len) != elf_img_len) errx(3, "Can't read file '%s' : %s", boot, strerror(errno)); lseek(bebox_fd, toff + hsize, SEEK_SET); write(bebox_fd, elf_img, elf_img_len); free(elf_img); if (inkernflag) close(kern_fd); close(elf_fd); /* Now go back and write in the block header */ endoff = lseek(bebox_fd, 0, SEEK_END); lseek(bebox_fd, 0, SEEK_SET); header_img = malloc(BEBOX_HEADER_SIZE); if (!header_img) errx(3, "Can't malloc: %s", strerror(errno)); memset(header_img, 0, BEBOX_HEADER_SIZE); /* copy the boot image into the buffer */ for (p = bebox_image_block; p->offset != -1; p++) memcpy(header_img + p->offset, p->data, p->size); /* fill used block bitmap */ memset(header_img + BEBOX_FILE_BLOCK_MAP_START, 0xff, BEBOX_FILE_BLOCK_MAP_END - BEBOX_FILE_BLOCK_MAP_START); /* fix the file size in the header */ tmp = endoff - BEBOX_HEADER_SIZE; *(int32_t *)(header_img + BEBOX_FILE_SIZE_OFFSET) = (int32_t)sa_htobe32(tmp); *(int32_t *)(header_img + BEBOX_FILE_SIZE_ALIGN_OFFSET) = (int32_t)sa_htobe32(roundup(tmp, BEBOX_FILE_BLOCK_SIZE)); if (repro_timestamp) { tp.tv_sec = (time_t)atoll(repro_timestamp); tp.tv_usec = 0; } else gettimeofday(&tp, 0); for (offset = bebox_mtime_offset; *offset != -1; offset++) *(int32_t *)(header_img + *offset) = (int32_t)sa_htobe32(tp.tv_sec); write(bebox_fd, header_img, BEBOX_HEADER_SIZE); /* now pad the end */ flength = roundup(endoff, BEBOX_BLOCK_SIZE); /* refill the header_img with zeros */ memset(header_img, 0, BEBOX_BLOCK_SIZE * 2); lseek(bebox_fd, 0, SEEK_END); write(bebox_fd, header_img, flength - endoff); close(bebox_fd); free(header_img); return 0; } int main(int argc, char **argv) { int ch, lfloppyflag=0; char *kernel = NULL, *boot = NULL, *rawdev = NULL, *outname = NULL; char *march = NULL; char *repro_timestamp = NULL; #ifdef USE_SYSCTL char machine[SYS_NMLN]; int mib[2] = { CTL_HW, HW_MACHINE }; #endif setprogname(argv[0]); kern_len = 0; while ((ch = getopt(argc, argv, "b:Ik:lm:r:st:v")) != -1) switch (ch) { case 'b': boot = optarg; break; case 'I': inkernflag = 0; break; case 'k': kernel = optarg; inkernflag = 1; break; case 'l': lfloppyflag = 1; break; case 'm': march = optarg; break; case 'r': rawdev = optarg; break; case 's': saloneflag = 1; break; case 't': repro_timestamp = optarg; break; case 'v': verboseflag = 1; break; case '?': default: usage(0); /* NOTREACHED */ } argc -= optind; argv += optind; if (argc < 1) usage(0); if (kernel == NULL && inkernflag) kernel = "/netbsd"; if (boot == NULL) boot = "/usr/mdec/boot"; if (march != NULL && strcmp(march, "") == 0) march = NULL; if (march == NULL) { int i; #ifdef USE_SYSCTL size_t len = sizeof(machine); if (sysctl(mib, sizeof (mib) / sizeof (mib[0]), machine, &len, NULL, 0) != -1) { for (i=0; sup_plats[i] != NULL; i++) { if (strcmp(sup_plats[i], machine) == 0) { march = strdup(sup_plats[i]); break; } } } if (march == NULL) #endif usage(1); } outname = argv[0]; if (strcmp(march, "prep") == 0) return prep_build_image(kernel, boot, rawdev, outname); if (strcmp(march, "rs6000") == 0) return rs6000_build_image(kernel, boot, rawdev, outname); if (strcmp(march, "bebox") == 0) return bebox_build_image(kernel, boot, rawdev, outname, repro_timestamp); usage(1); return 0; }