1*4f26b22aSchristos /* $NetBSD: mkbootimage.c,v 1.19 2016/01/21 17:14:05 christos Exp $ */
267049908Sgarbled
367049908Sgarbled /*-
44849f95dSgarbled * Copyright (c) 2007 The NetBSD Foundation, Inc.
567049908Sgarbled * All rights reserved.
667049908Sgarbled *
74849f95dSgarbled * This code is derived from software contributed to The NetBSD Foundation
84849f95dSgarbled * by Tim Rightnour and NONAKA Kimihiro
94849f95dSgarbled *
1067049908Sgarbled * Redistribution and use in source and binary forms, with or without
1167049908Sgarbled * modification, are permitted provided that the following conditions
1267049908Sgarbled * are met:
1367049908Sgarbled * 1. Redistributions of source code must retain the above copyright
1467049908Sgarbled * notice, this list of conditions and the following disclaimer.
1567049908Sgarbled * 2. Redistributions in binary form must reproduce the above copyright
1667049908Sgarbled * notice, this list of conditions and the following disclaimer in the
1767049908Sgarbled * documentation and/or other materials provided with the distribution.
1867049908Sgarbled *
194849f95dSgarbled * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
204849f95dSgarbled * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
214849f95dSgarbled * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
224849f95dSgarbled * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
234849f95dSgarbled * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
244849f95dSgarbled * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
254849f95dSgarbled * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
264849f95dSgarbled * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
274849f95dSgarbled * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
284849f95dSgarbled * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
294849f95dSgarbled * POSSIBILITY OF SUCH DAMAGE.
3067049908Sgarbled */
3167049908Sgarbled
3267049908Sgarbled #if HAVE_NBTOOL_CONFIG_H
3367049908Sgarbled #include "nbtool_config.h"
3467049908Sgarbled #include "../../sys/sys/bootblock.h"
3567049908Sgarbled #else
3667049908Sgarbled #include <sys/bootblock.h>
3767049908Sgarbled #endif
3867049908Sgarbled
3967049908Sgarbled #include <stdio.h>
4067049908Sgarbled #include <stdlib.h>
4167049908Sgarbled #include <string.h>
4267049908Sgarbled #include <fcntl.h>
4367049908Sgarbled #include <unistd.h>
4467049908Sgarbled #include <errno.h>
4567049908Sgarbled #include <zlib.h>
4667049908Sgarbled #include <err.h>
4767049908Sgarbled #include <sys/stat.h>
4867049908Sgarbled #include <sys/types.h>
4967049908Sgarbled #include <sys/uio.h>
50c3408ed0Sgarbled #include <sys/signal.h>
5167049908Sgarbled
52c3408ed0Sgarbled #undef USE_SYSCTL
53c3408ed0Sgarbled
54c3408ed0Sgarbled #if defined(__NetBSD__) && !defined(HAVE_NBTOOL_CONFIG_H)
55c3408ed0Sgarbled #define USE_SYSCTL 1
56c3408ed0Sgarbled #include <sys/param.h>
574849f95dSgarbled #include <sys/sysctl.h>
584849f95dSgarbled #include <sys/utsname.h>
594849f95dSgarbled #endif
604849f95dSgarbled
6167049908Sgarbled /* BFD ELF headers */
6267049908Sgarbled #include <elf/common.h>
6367049908Sgarbled #include <elf/external.h>
6467049908Sgarbled
65e7da798eSgarbled #include "bebox_bootrec.h"
6667049908Sgarbled #include "byteorder.h"
67ec9be1a8Sgarbled #include "magic.h"
68e7da798eSgarbled #include "pef.h"
69e7da798eSgarbled #include "rs6000_bootrec.h"
7067049908Sgarbled
7167049908Sgarbled /* Globals */
7267049908Sgarbled
7330411c8bSkiyohara int inkernflag = 1;
7467049908Sgarbled int saloneflag = 0;
75690f8887Sgarbled int verboseflag = 0;
76690f8887Sgarbled int lfloppyflag = 0;
7767049908Sgarbled Elf32_External_Ehdr hdr, khdr;
7867049908Sgarbled struct stat elf_stat;
7967049908Sgarbled unsigned char mbr[512];
80690f8887Sgarbled
81690f8887Sgarbled /* the boot and config records for rs6000 */
82690f8887Sgarbled rs6000_boot_record_t bootrec;
83690f8887Sgarbled rs6000_config_record_t confrec;
84690f8887Sgarbled
85690f8887Sgarbled /* supported platforms */
864849f95dSgarbled char *sup_plats[] = {
87e7da798eSgarbled "bebox",
884849f95dSgarbled "prep",
89690f8887Sgarbled "rs6000",
904849f95dSgarbled NULL,
914849f95dSgarbled };
9267049908Sgarbled
9367049908Sgarbled /*
9467049908Sgarbled * Macros to get values from multi-byte ELF header fields. These assume
9567049908Sgarbled * a big-endian image.
9667049908Sgarbled */
9767049908Sgarbled #define ELFGET16(x) (((x)[0] << 8) | (x)[1])
9867049908Sgarbled
9967049908Sgarbled #define ELFGET32(x) (((x)[0] << 24) | ((x)[1] << 16) | \
10067049908Sgarbled ((x)[2] << 8) | (x)[3])
10167049908Sgarbled
102e7da798eSgarbled #define ULALIGN(x) ((x + 0x0f) & 0xfffffff0)
103e7da798eSgarbled
104690f8887Sgarbled static void usage(int);
10567049908Sgarbled static int open_file(const char *, char *, Elf32_External_Ehdr *,
10667049908Sgarbled struct stat *);
107690f8887Sgarbled static void check_mbr(int, char *);
108690f8887Sgarbled static int prep_build_image(char *, char *, char *, char *);
109690f8887Sgarbled static void rs6000_build_records(int);
110690f8887Sgarbled static int rs6000_build_image(char *, char *, char *, char *);
11167049908Sgarbled int main(int, char **);
11267049908Sgarbled
113e7da798eSgarbled
11467049908Sgarbled static void
usage(int extended)115690f8887Sgarbled usage(int extended)
11667049908Sgarbled {
117690f8887Sgarbled int i;
118690f8887Sgarbled
119690f8887Sgarbled if (extended) {
120690f8887Sgarbled fprintf(stderr, "You are not running this program on"
121690f8887Sgarbled " the target machine. You must supply the\n"
122690f8887Sgarbled "machine architecture with the -m flag\n");
123690f8887Sgarbled fprintf(stderr, "Supported architectures: ");
124690f8887Sgarbled for (i=0; sup_plats[i] != NULL; i++)
125690f8887Sgarbled fprintf(stderr, " %s", sup_plats[i]);
126690f8887Sgarbled fprintf(stderr, "\n\n");
127690f8887Sgarbled }
128c3408ed0Sgarbled #ifdef USE_SYSCTL
12930411c8bSkiyohara fprintf(stderr, "usage: %s [-Ilsv] [-m machine] [-b bootfile] "
1304849f95dSgarbled "[-k kernel] [-r rawdev] bootimage\n", getprogname());
1314849f95dSgarbled #else
13230411c8bSkiyohara fprintf(stderr, "usage: %s [-Ilsv] -m machine [-b bootfile] "
1334849f95dSgarbled "[-k kernel] [-r rawdev] bootimage\n", getprogname());
1344849f95dSgarbled #endif
13567049908Sgarbled exit(1);
13667049908Sgarbled }
13767049908Sgarbled
13867049908Sgarbled /* verify the file is ELF and ppc, and open it up */
13967049908Sgarbled static int
open_file(const char * ftype,char * file,Elf32_External_Ehdr * hdr,struct stat * f_stat)14067049908Sgarbled open_file(const char *ftype, char *file, Elf32_External_Ehdr *hdr,
14167049908Sgarbled struct stat *f_stat)
14267049908Sgarbled {
14367049908Sgarbled int fd;
14467049908Sgarbled
14567049908Sgarbled if ((fd = open(file, 0)) < 0)
14667049908Sgarbled errx(2, "Can't open %s '%s': %s", ftype, file, strerror(errno));
14767049908Sgarbled fstat(fd, f_stat);
14867049908Sgarbled
14967049908Sgarbled if (read(fd, hdr, sizeof(Elf32_External_Ehdr)) !=
15067049908Sgarbled sizeof(Elf32_External_Ehdr))
15167049908Sgarbled errx(3, "Can't read input '%s': %s", file, strerror(errno));
15267049908Sgarbled
15367049908Sgarbled if (hdr->e_ident[EI_MAG0] != ELFMAG0 ||
15467049908Sgarbled hdr->e_ident[EI_MAG1] != ELFMAG1 ||
15567049908Sgarbled hdr->e_ident[EI_MAG2] != ELFMAG2 ||
15667049908Sgarbled hdr->e_ident[EI_MAG3] != ELFMAG3 ||
15767049908Sgarbled hdr->e_ident[EI_CLASS] != ELFCLASS32)
15867049908Sgarbled errx(3, "input '%s' is not ELF32 format", file);
15967049908Sgarbled
16067049908Sgarbled if (hdr->e_ident[EI_DATA] != ELFDATA2MSB)
16167049908Sgarbled errx(3, "input '%s' is not big-endian", file);
16267049908Sgarbled
16367049908Sgarbled if (ELFGET16(hdr->e_machine) != EM_PPC)
16467049908Sgarbled errx(3, "input '%s' is not PowerPC exec binary", file);
16567049908Sgarbled
16667049908Sgarbled return(fd);
16767049908Sgarbled }
16867049908Sgarbled
16967049908Sgarbled static void
prep_check_mbr(int prep_fd,char * rawdev)170690f8887Sgarbled prep_check_mbr(int prep_fd, char *rawdev)
17167049908Sgarbled {
17267049908Sgarbled int raw_fd;
17367049908Sgarbled unsigned long entry, length;
17467049908Sgarbled struct mbr_partition *mbrp;
17567049908Sgarbled struct stat raw_stat;
17667049908Sgarbled
17767049908Sgarbled /* If we are building a standalone image, do not write an MBR, just
17867049908Sgarbled * set entry point and boot image size skipping over elf header
17967049908Sgarbled */
18067049908Sgarbled if (saloneflag) {
18167049908Sgarbled entry = sa_htole32(0x400);
18267049908Sgarbled length = sa_htole32(elf_stat.st_size - sizeof(hdr) + 0x400);
18367049908Sgarbled lseek(prep_fd, sizeof(mbr), SEEK_SET);
18467049908Sgarbled write(prep_fd, &entry, sizeof(entry));
18567049908Sgarbled write(prep_fd, &length, sizeof(length));
18667049908Sgarbled return;
18767049908Sgarbled }
18867049908Sgarbled
18967049908Sgarbled /*
19067049908Sgarbled * if we have a raw device, we need to check to see if it already
19167049908Sgarbled * has a partition table, and if so, read it in and check for
19267049908Sgarbled * suitability.
19367049908Sgarbled */
19467049908Sgarbled if (rawdev != NULL) {
19567049908Sgarbled raw_fd = open(rawdev, O_RDONLY, 0);
19667049908Sgarbled if (raw_fd == -1)
19767049908Sgarbled errx(3, "couldn't open raw device %s: %s", rawdev,
19867049908Sgarbled strerror(errno));
19967049908Sgarbled
20067049908Sgarbled fstat(raw_fd, &raw_stat);
20167049908Sgarbled if (!S_ISCHR(raw_stat.st_mode))
20267049908Sgarbled errx(3, "%s is not a raw device", rawdev);
20367049908Sgarbled
20467049908Sgarbled if (read(raw_fd, mbr, 512) != 512)
20567049908Sgarbled errx(3, "MBR Read Failed: %s", strerror(errno));
20667049908Sgarbled
20767049908Sgarbled mbrp = (struct mbr_partition *)&mbr[MBR_PART_OFFSET];
20867049908Sgarbled if (mbrp->mbrp_type != MBR_PTYPE_PREP)
20967049908Sgarbled errx(3, "First partition is not of type 0x%x.",
21067049908Sgarbled MBR_PTYPE_PREP);
21167049908Sgarbled if (mbrp->mbrp_start != 0)
21267049908Sgarbled errx(3, "Use of the raw device is intended for"
21367049908Sgarbled " upgrading of legacy installations. Your"
21467049908Sgarbled " install does not have a PReP boot partition"
21567049908Sgarbled " starting at sector 0. Use the -s option"
21667049908Sgarbled " to build an image instead.");
21767049908Sgarbled
21867049908Sgarbled /* if we got this far, we are fine, write back the partition
21967049908Sgarbled * and write the entry points and get outta here */
22067049908Sgarbled /* Set entry point and boot image size skipping over elf header */
22167049908Sgarbled lseek(prep_fd, 0, SEEK_SET);
22267049908Sgarbled entry = sa_htole32(0x400);
22367049908Sgarbled length = sa_htole32(elf_stat.st_size - sizeof(hdr) + 0x400);
22467049908Sgarbled write(prep_fd, mbr, sizeof(mbr));
22567049908Sgarbled write(prep_fd, &entry, sizeof(entry));
22667049908Sgarbled write(prep_fd, &length, sizeof(length));
22767049908Sgarbled close(raw_fd);
22867049908Sgarbled return;
22967049908Sgarbled }
23067049908Sgarbled
23167049908Sgarbled /* if we get to here, we want to build a standard floppy or netboot
23267049908Sgarbled * image to file, so just build it */
23367049908Sgarbled
23467049908Sgarbled memset(mbr, 0, sizeof(mbr));
23567049908Sgarbled mbrp = (struct mbr_partition *)&mbr[MBR_PART_OFFSET];
23667049908Sgarbled
23767049908Sgarbled /* Set entry point and boot image size skipping over elf header */
23867049908Sgarbled entry = sa_htole32(0x400);
23967049908Sgarbled length = sa_htole32(elf_stat.st_size - sizeof(hdr) + 0x400);
24067049908Sgarbled
24167049908Sgarbled /*
24267049908Sgarbled * Set magic number for msdos partition
24367049908Sgarbled */
24467049908Sgarbled *(unsigned short *)&mbr[MBR_MAGIC_OFFSET] = sa_htole16(MBR_MAGIC);
24567049908Sgarbled
24667049908Sgarbled /*
24767049908Sgarbled * Build a "PReP" partition table entry in the boot record
24867049908Sgarbled * - "PReP" may only look at the system_indicator
24967049908Sgarbled */
25067049908Sgarbled mbrp->mbrp_flag = MBR_PFLAG_ACTIVE;
25167049908Sgarbled mbrp->mbrp_type = MBR_PTYPE_PREP;
25267049908Sgarbled
25367049908Sgarbled /*
25467049908Sgarbled * The first block of the diskette is used by this "boot record" which
25567049908Sgarbled * actually contains the partition table. (The first block of the
25667049908Sgarbled * partition contains the boot image, but I digress...) We'll set up
25767049908Sgarbled * one partition on the diskette and it shall contain the rest of the
25867049908Sgarbled * diskette.
25967049908Sgarbled */
26067049908Sgarbled mbrp->mbrp_shd = 0; /* zero-based */
26167049908Sgarbled mbrp->mbrp_ssect = 2; /* one-based */
26267049908Sgarbled mbrp->mbrp_scyl = 0; /* zero-based */
26367049908Sgarbled mbrp->mbrp_ehd = 1; /* assumes two heads */
26467049908Sgarbled if (lfloppyflag)
26567049908Sgarbled mbrp->mbrp_esect = 36; /* 2.88MB floppy */
26667049908Sgarbled else
26767049908Sgarbled mbrp->mbrp_esect = 18; /* assumes 18 sectors/track */
26867049908Sgarbled mbrp->mbrp_ecyl = 79; /* assumes 80 cylinders/diskette */
26967049908Sgarbled
27067049908Sgarbled /*
27167049908Sgarbled * The "PReP" software ignores the above fields and just looks at
27267049908Sgarbled * the next two.
27367049908Sgarbled * - size of the diskette is (assumed to be)
27467049908Sgarbled * (2 tracks/cylinder)(18 sectors/tracks)(80 cylinders/diskette)
27567049908Sgarbled * - unlike the above sector numbers,
27667049908Sgarbled * the beginning sector is zero-based!
27767049908Sgarbled */
27867049908Sgarbled
27967049908Sgarbled /* This has to be 0 on the PowerStack? */
28067049908Sgarbled mbrp->mbrp_start = sa_htole32(0);
28167049908Sgarbled mbrp->mbrp_size = sa_htole32(2 * 18 * 80 - 1);
28267049908Sgarbled
28367049908Sgarbled write(prep_fd, mbr, sizeof(mbr));
28467049908Sgarbled write(prep_fd, &entry, sizeof(entry));
28567049908Sgarbled write(prep_fd, &length, sizeof(length));
28667049908Sgarbled }
28767049908Sgarbled
2884849f95dSgarbled static int
prep_build_image(char * kernel,char * boot,char * rawdev,char * outname)289690f8887Sgarbled prep_build_image(char *kernel, char *boot, char *rawdev, char *outname)
29067049908Sgarbled {
29167049908Sgarbled unsigned char *elf_img = NULL, *kern_img = NULL;
2924849f95dSgarbled int i, ch, tmp, kgzlen, err;
29367049908Sgarbled int elf_fd, prep_fd, kern_fd, elf_img_len = 0;
29467049908Sgarbled off_t lenpos, kstart, kend;
29567049908Sgarbled unsigned long length;
29667049908Sgarbled long flength;
29767049908Sgarbled gzFile gzf;
29867049908Sgarbled struct stat kern_stat;
29967049908Sgarbled Elf32_External_Phdr phdr;
30067049908Sgarbled
30167049908Sgarbled elf_fd = open_file("bootloader", boot, &hdr, &elf_stat);
3022e10c70eSkiyohara if (inkernflag) {
30367049908Sgarbled kern_fd = open_file("kernel", kernel, &khdr, &kern_stat);
3044849f95dSgarbled kern_len = kern_stat.st_size + PREP_MAGICSIZE + KERNLENSIZE;
3052e10c70eSkiyohara } else
3062e10c70eSkiyohara kern_len = PREP_MAGICSIZE + KERNLENSIZE;
30767049908Sgarbled
30867049908Sgarbled for (i = 0; i < ELFGET16(hdr.e_phnum); i++) {
30967049908Sgarbled lseek(elf_fd, ELFGET32(hdr.e_phoff) + sizeof(phdr) * i,
31067049908Sgarbled SEEK_SET);
31167049908Sgarbled if (read(elf_fd, &phdr, sizeof(phdr)) != sizeof(phdr))
31267049908Sgarbled errx(3, "Can't read input '%s' phdr : %s", boot,
31367049908Sgarbled strerror(errno));
31467049908Sgarbled
31567049908Sgarbled if ((ELFGET32(phdr.p_type) != PT_LOAD) ||
31667049908Sgarbled !(ELFGET32(phdr.p_flags) & PF_X))
31767049908Sgarbled continue;
31867049908Sgarbled
31967049908Sgarbled fstat(elf_fd, &elf_stat);
32067049908Sgarbled elf_img_len = elf_stat.st_size - ELFGET32(phdr.p_offset);
32167049908Sgarbled lseek(elf_fd, ELFGET32(phdr.p_offset), SEEK_SET);
32267049908Sgarbled
32367049908Sgarbled break;
32467049908Sgarbled }
3254849f95dSgarbled if ((prep_fd = open(outname, O_RDWR|O_TRUNC, 0)) < 0) {
32667049908Sgarbled /* we couldn't open it, it must be new */
3274849f95dSgarbled prep_fd = creat(outname, 0644);
32867049908Sgarbled if (prep_fd < 0)
3294849f95dSgarbled errx(2, "Can't open output '%s': %s", outname,
33067049908Sgarbled strerror(errno));
33167049908Sgarbled }
33267049908Sgarbled
333690f8887Sgarbled prep_check_mbr(prep_fd, rawdev);
33467049908Sgarbled
33567049908Sgarbled /* Set file pos. to 2nd sector where image will be written */
33667049908Sgarbled lseek(prep_fd, 0x400, SEEK_SET);
33767049908Sgarbled
33867049908Sgarbled /* Copy boot image */
339*4f26b22aSchristos elf_img = malloc(elf_img_len);
34067049908Sgarbled if (!elf_img)
34167049908Sgarbled errx(3, "Can't malloc: %s", strerror(errno));
34267049908Sgarbled if (read(elf_fd, elf_img, elf_img_len) != elf_img_len)
34367049908Sgarbled errx(3, "Can't read file '%s' : %s", boot, strerror(errno));
34467049908Sgarbled
34567049908Sgarbled write(prep_fd, elf_img, elf_img_len);
34667049908Sgarbled free(elf_img);
34767049908Sgarbled
3482e10c70eSkiyohara if (inkernflag) {
34967049908Sgarbled /* Copy kernel */
350*4f26b22aSchristos kern_img = malloc(kern_stat.st_size);
35167049908Sgarbled
35267049908Sgarbled if (kern_img == NULL)
35367049908Sgarbled errx(3, "Can't malloc: %s", strerror(errno));
35467049908Sgarbled
35567049908Sgarbled /* we need to jump back after having read the headers */
35667049908Sgarbled lseek(kern_fd, 0, SEEK_SET);
35767049908Sgarbled if (read(kern_fd, (void *)kern_img, kern_stat.st_size) !=
35867049908Sgarbled kern_stat.st_size)
3592e10c70eSkiyohara errx(3, "Can't read kernel '%s' : %s",
3602e10c70eSkiyohara kernel, strerror(errno));
3612e10c70eSkiyohara }
36267049908Sgarbled
36367049908Sgarbled gzf = gzdopen(dup(prep_fd), "a");
36467049908Sgarbled if (gzf == NULL)
36567049908Sgarbled errx(3, "Can't init compression: %s", strerror(errno));
36667049908Sgarbled if (gzsetparams(gzf, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY) != Z_OK)
36767049908Sgarbled errx(3, "%s", gzerror(gzf, &err));
36867049908Sgarbled
36967049908Sgarbled /* write a magic number and size before the kernel */
3704849f95dSgarbled write(prep_fd, (void *)prep_magic, PREP_MAGICSIZE);
37167049908Sgarbled lenpos = lseek(prep_fd, 0, SEEK_CUR);
37267049908Sgarbled tmp = sa_htobe32(0);
37367049908Sgarbled write(prep_fd, (void *)&tmp, KERNLENSIZE);
37467049908Sgarbled
37567049908Sgarbled /* write in the compressed kernel */
37667049908Sgarbled kstart = lseek(prep_fd, 0, SEEK_CUR);
3772e10c70eSkiyohara if (inkernflag) {
37867049908Sgarbled kgzlen = gzwrite(gzf, kern_img, kern_stat.st_size);
37967049908Sgarbled gzclose(gzf);
3802e10c70eSkiyohara }
38167049908Sgarbled kend = lseek(prep_fd, 0, SEEK_CUR);
38267049908Sgarbled
38367049908Sgarbled /* jump back to the length position now that we know the length */
38467049908Sgarbled lseek(prep_fd, lenpos, SEEK_SET);
38567049908Sgarbled kgzlen = kend - kstart;
38667049908Sgarbled tmp = sa_htobe32(kgzlen);
38767049908Sgarbled write(prep_fd, (void *)&tmp, KERNLENSIZE);
38867049908Sgarbled
38967049908Sgarbled length = sa_htole32(0x400 + elf_img_len + 8 + kgzlen);
39067049908Sgarbled lseek(prep_fd, sizeof(mbr) + 4, SEEK_SET);
39167049908Sgarbled write(prep_fd, &length, sizeof(length));
39267049908Sgarbled
39367049908Sgarbled flength = 0x400 + elf_img_len + 8 + kgzlen;
394690f8887Sgarbled if (lfloppyflag)
39567049908Sgarbled flength -= (5760 * 512);
39667049908Sgarbled else
39767049908Sgarbled flength -= (2880 * 512);
39867049908Sgarbled if (flength > 0 && !saloneflag)
39919e8f493Sjoerg fprintf(stderr, "%s: Image %s is %ld bytes larger than single"
40067049908Sgarbled " floppy. Can only be used for netboot.\n", getprogname(),
4014849f95dSgarbled outname, flength);
40267049908Sgarbled
4032e10c70eSkiyohara if (inkernflag) {
40467049908Sgarbled free(kern_img);
40567049908Sgarbled close(kern_fd);
4062e10c70eSkiyohara }
40767049908Sgarbled close(prep_fd);
40867049908Sgarbled close(elf_fd);
40967049908Sgarbled
410690f8887Sgarbled return 0;
411690f8887Sgarbled }
412690f8887Sgarbled
413690f8887Sgarbled /* Fill in the needed information on the boot and config records. Most of
414690f8887Sgarbled * this is just AIX garbage that we don't really need to boot.
415690f8887Sgarbled */
416690f8887Sgarbled static void
rs6000_build_records(int img_len)417690f8887Sgarbled rs6000_build_records(int img_len)
418690f8887Sgarbled {
419690f8887Sgarbled int bcl;
420690f8887Sgarbled
421690f8887Sgarbled /* zero out all the fields, so we only have to set the ones
422690f8887Sgarbled * we care about, which are rather few.
423690f8887Sgarbled */
424690f8887Sgarbled memset(&bootrec, 0, sizeof(rs6000_boot_record_t));
425690f8887Sgarbled memset(&confrec, 0, sizeof(rs6000_config_record_t));
426690f8887Sgarbled
427690f8887Sgarbled bootrec.ipl_record = IPLRECID;
428690f8887Sgarbled bcl = img_len/512;
429690f8887Sgarbled if (img_len%512 != 0)
430690f8887Sgarbled bcl++;
431690f8887Sgarbled bootrec.bootcode_len = bcl;
432690f8887Sgarbled bootrec.bootcode_off = 0; /* XXX */
433690f8887Sgarbled bootrec.bootpart_start = 2; /* skip bootrec and confrec */
434690f8887Sgarbled bootrec.bootprg_start = 2;
435690f8887Sgarbled bootrec.bootpart_len = bcl;
436690f8887Sgarbled bootrec.boot_load_addr = 0x800000; /* XXX? */
437690f8887Sgarbled bootrec.boot_frag = 1;
438690f8887Sgarbled bootrec.boot_emul = 0x02; /* ?? */
439690f8887Sgarbled /* service mode is a repeat of normal mode */
440690f8887Sgarbled bootrec.servcode_len = bootrec.bootcode_len;
441690f8887Sgarbled bootrec.servcode_off = bootrec.bootcode_off;
442690f8887Sgarbled bootrec.servpart_start = bootrec.bootpart_start;
443690f8887Sgarbled bootrec.servprg_start = bootrec.bootprg_start;
444690f8887Sgarbled bootrec.servpart_len = bootrec.bootpart_len;
445690f8887Sgarbled bootrec.serv_load_addr = bootrec.boot_load_addr;
446690f8887Sgarbled bootrec.serv_frag = bootrec.boot_frag;
447690f8887Sgarbled bootrec.serv_emul = bootrec.boot_emul;
448690f8887Sgarbled
449690f8887Sgarbled /* now the config record */
450690f8887Sgarbled confrec.conf_rec = CONFRECID;
451690f8887Sgarbled confrec.sector_size = 0x02; /* 512 bytes */
452690f8887Sgarbled confrec.last_cyl = 0x4f; /* 79 cyl, emulates floppy */
453690f8887Sgarbled }
454690f8887Sgarbled
455690f8887Sgarbled static int
rs6000_build_image(char * kernel,char * boot,char * rawdev,char * outname)456690f8887Sgarbled rs6000_build_image(char *kernel, char *boot, char *rawdev, char *outname)
457690f8887Sgarbled {
458690f8887Sgarbled unsigned char *elf_img = NULL, *kern_img = NULL;
459690f8887Sgarbled int i, ch, tmp, kgzlen, err;
460690f8887Sgarbled int elf_fd, rs6000_fd, kern_fd, elf_img_len = 0, elf_pad;
461690f8887Sgarbled uint32_t swapped[128];
462690f8887Sgarbled off_t lenpos, kstart, kend;
463690f8887Sgarbled unsigned long length;
464690f8887Sgarbled long flength;
465690f8887Sgarbled gzFile gzf;
466690f8887Sgarbled struct stat kern_stat;
467690f8887Sgarbled Elf32_External_Phdr phdr;
468690f8887Sgarbled
469690f8887Sgarbled elf_fd = open_file("bootloader", boot, &hdr, &elf_stat);
470690f8887Sgarbled kern_fd = open_file("kernel", kernel, &khdr, &kern_stat);
471690f8887Sgarbled kern_len = kern_stat.st_size + RS6000_MAGICSIZE + KERNLENSIZE;
472690f8887Sgarbled
473690f8887Sgarbled for (i = 0; i < ELFGET16(hdr.e_phnum); i++) {
474690f8887Sgarbled lseek(elf_fd, ELFGET32(hdr.e_phoff) + sizeof(phdr) * i,
475690f8887Sgarbled SEEK_SET);
476690f8887Sgarbled if (read(elf_fd, &phdr, sizeof(phdr)) != sizeof(phdr))
477690f8887Sgarbled errx(3, "Can't read input '%s' phdr : %s", boot,
478690f8887Sgarbled strerror(errno));
479690f8887Sgarbled
480690f8887Sgarbled if ((ELFGET32(phdr.p_type) != PT_LOAD) ||
481690f8887Sgarbled !(ELFGET32(phdr.p_flags) & PF_X))
482690f8887Sgarbled continue;
483690f8887Sgarbled
484690f8887Sgarbled fstat(elf_fd, &elf_stat);
485690f8887Sgarbled elf_img_len = elf_stat.st_size - ELFGET32(phdr.p_offset);
486690f8887Sgarbled elf_pad = ELFGET32(phdr.p_memsz) - ELFGET32(phdr.p_filesz);
487690f8887Sgarbled if (verboseflag)
488690f8887Sgarbled printf("Padding %d\n", elf_pad);
489690f8887Sgarbled lseek(elf_fd, ELFGET32(phdr.p_offset), SEEK_SET);
490690f8887Sgarbled
491690f8887Sgarbled break;
492690f8887Sgarbled }
493690f8887Sgarbled if ((rs6000_fd = open(outname, O_RDWR|O_TRUNC, 0)) < 0) {
494690f8887Sgarbled /* we couldn't open it, it must be new */
495690f8887Sgarbled rs6000_fd = creat(outname, 0644);
496690f8887Sgarbled if (rs6000_fd < 0)
497690f8887Sgarbled errx(2, "Can't open output '%s': %s", outname,
498690f8887Sgarbled strerror(errno));
499690f8887Sgarbled }
500690f8887Sgarbled
501690f8887Sgarbled /* Set file pos. to 2nd sector where image will be written */
502690f8887Sgarbled lseek(rs6000_fd, 0x400, SEEK_SET);
503690f8887Sgarbled
504690f8887Sgarbled /* Copy boot image */
505*4f26b22aSchristos elf_img = malloc(elf_img_len);
506690f8887Sgarbled if (!elf_img)
507690f8887Sgarbled errx(3, "Can't malloc: %s", strerror(errno));
508690f8887Sgarbled if (read(elf_fd, elf_img, elf_img_len) != elf_img_len)
509690f8887Sgarbled errx(3, "Can't read file '%s' : %s", boot, strerror(errno));
510690f8887Sgarbled
511690f8887Sgarbled write(rs6000_fd, elf_img, elf_img_len);
512690f8887Sgarbled free(elf_img);
513690f8887Sgarbled
514690f8887Sgarbled /* now dump in the padding space for the BSS */
515690f8887Sgarbled elf_pad += 100; /* just a little extra for good luck */
516690f8887Sgarbled lseek(rs6000_fd, elf_pad, SEEK_CUR);
517690f8887Sgarbled
518690f8887Sgarbled /* Copy kernel */
519*4f26b22aSchristos kern_img = malloc(kern_stat.st_size);
520690f8887Sgarbled
521690f8887Sgarbled if (kern_img == NULL)
522690f8887Sgarbled errx(3, "Can't malloc: %s", strerror(errno));
523690f8887Sgarbled
524690f8887Sgarbled /* we need to jump back after having read the headers */
525690f8887Sgarbled lseek(kern_fd, 0, SEEK_SET);
526690f8887Sgarbled if (read(kern_fd, (void *)kern_img, kern_stat.st_size) !=
527690f8887Sgarbled kern_stat.st_size)
528690f8887Sgarbled errx(3, "Can't read kernel '%s' : %s", kernel, strerror(errno));
529690f8887Sgarbled
530690f8887Sgarbled gzf = gzdopen(dup(rs6000_fd), "a");
531690f8887Sgarbled if (gzf == NULL)
532690f8887Sgarbled errx(3, "Can't init compression: %s", strerror(errno));
533690f8887Sgarbled if (gzsetparams(gzf, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY) != Z_OK)
534690f8887Sgarbled errx(3, "%s", gzerror(gzf, &err));
535690f8887Sgarbled
536690f8887Sgarbled /* write a magic number and size before the kernel */
537690f8887Sgarbled write(rs6000_fd, (void *)rs6000_magic, RS6000_MAGICSIZE);
538690f8887Sgarbled lenpos = lseek(rs6000_fd, 0, SEEK_CUR);
539690f8887Sgarbled if (verboseflag)
54060c26cf5Sjoerg printf("wrote magic at pos 0x%lx\n", (unsigned long)lenpos);
541690f8887Sgarbled tmp = sa_htobe32(0);
542690f8887Sgarbled write(rs6000_fd, (void *)&tmp, KERNLENSIZE);
543690f8887Sgarbled
544690f8887Sgarbled /* write in the compressed kernel */
545690f8887Sgarbled kstart = lseek(rs6000_fd, 0, SEEK_CUR);
546690f8887Sgarbled if (verboseflag)
54760c26cf5Sjoerg printf("kernel start at pos 0x%lx\n", (unsigned long)kstart);
548690f8887Sgarbled kgzlen = gzwrite(gzf, kern_img, kern_stat.st_size);
549690f8887Sgarbled gzclose(gzf);
550690f8887Sgarbled kend = lseek(rs6000_fd, 0, SEEK_CUR);
551690f8887Sgarbled if (verboseflag)
55260c26cf5Sjoerg printf("kernel end at pos 0x%lx\n", (unsigned long)kend);
553690f8887Sgarbled
554690f8887Sgarbled /* jump back to the length position now that we know the length */
555690f8887Sgarbled lseek(rs6000_fd, lenpos, SEEK_SET);
556690f8887Sgarbled kgzlen = kend - kstart;
557690f8887Sgarbled tmp = sa_htobe32(kgzlen);
558690f8887Sgarbled if (verboseflag)
559690f8887Sgarbled printf("kernel len = 0x%x tmp = 0x%x\n", kgzlen, tmp);
560690f8887Sgarbled write(rs6000_fd, (void *)&tmp, KERNLENSIZE);
561690f8887Sgarbled
562690f8887Sgarbled #if 0
563690f8887Sgarbled lseek(rs6000_fd, sizeof(boot_record_t) + sizeof(config_record_t),
564690f8887Sgarbled SEEK_SET);
565690f8887Sgarbled /* set entry and length */
566690f8887Sgarbled length = sa_htole32(0x400);
567690f8887Sgarbled write(rs6000_fd, &length, sizeof(length));
568690f8887Sgarbled length = sa_htole32(0x400 + elf_img_len + 8 + kgzlen);
569690f8887Sgarbled write(rs6000_fd, &length, sizeof(length));
570690f8887Sgarbled #endif
571690f8887Sgarbled
572690f8887Sgarbled /* generate the header now that we know the kernel length */
573690f8887Sgarbled if (verboseflag)
574690f8887Sgarbled printf("building records\n");
575690f8887Sgarbled rs6000_build_records(elf_img_len + 8 + kgzlen);
576690f8887Sgarbled lseek(rs6000_fd, 0, SEEK_SET);
577690f8887Sgarbled /* ROM wants it byteswapped in 32bit chunks */
578690f8887Sgarbled if (verboseflag)
579690f8887Sgarbled printf("writing records\n");
580690f8887Sgarbled memcpy(swapped, &bootrec, sizeof(rs6000_boot_record_t));
581690f8887Sgarbled for (i=0; i < 128; i++)
582690f8887Sgarbled swapped[i] = htonl(swapped[i]);
583690f8887Sgarbled write(rs6000_fd, swapped, sizeof(rs6000_boot_record_t));
584690f8887Sgarbled memcpy(swapped, &confrec, sizeof(rs6000_config_record_t));
585690f8887Sgarbled for (i=0; i < 128; i++)
586690f8887Sgarbled swapped[i] = htonl(swapped[i]);
587690f8887Sgarbled write(rs6000_fd, swapped, sizeof(rs6000_config_record_t));
588690f8887Sgarbled
589690f8887Sgarbled free(kern_img);
590690f8887Sgarbled close(kern_fd);
591690f8887Sgarbled close(rs6000_fd);
592690f8887Sgarbled close(elf_fd);
593690f8887Sgarbled
594690f8887Sgarbled return 0;
5954849f95dSgarbled }
5964849f95dSgarbled
597e7da798eSgarbled static int
bebox_write_header(int bebox_fd,int elf_image_len,int kern_img_len)598e7da798eSgarbled bebox_write_header(int bebox_fd, int elf_image_len, int kern_img_len)
599e7da798eSgarbled {
600e7da798eSgarbled int hsize = BEBOX_HEADER_SIZE;
601e7da798eSgarbled unsigned long textOffset, dataOffset, ldrOffset;
602e7da798eSgarbled unsigned long entry_vector[3];
603e7da798eSgarbled struct FileHeader fileHdr;
604e7da798eSgarbled struct SectionHeader textHdr, dataHdr, ldrHdr;
605e7da798eSgarbled struct LoaderHeader lh;
606e7da798eSgarbled
607e7da798eSgarbled
608e7da798eSgarbled ldrOffset = ULALIGN(sizeof (fileHdr) + sizeof (textHdr) +
609e7da798eSgarbled sizeof (dataHdr) + sizeof (ldrHdr));
610e7da798eSgarbled dataOffset = ULALIGN(ldrOffset + sizeof (lh));
611e7da798eSgarbled textOffset = ULALIGN(dataOffset + sizeof (entry_vector) + kern_img_len);
612e7da798eSgarbled
613e7da798eSgarbled /* Create the File Header */
614e7da798eSgarbled memset(&fileHdr, 0, sizeof (fileHdr));
615e7da798eSgarbled fileHdr.magic = sa_htobe32(PEF_MAGIC);
616e7da798eSgarbled fileHdr.fileTypeID = sa_htobe32(PEF_FILE);
617e7da798eSgarbled fileHdr.archID = sa_htobe32(PEF_PPC);
618e7da798eSgarbled fileHdr.versionNumber = sa_htobe32(1);
619e7da798eSgarbled fileHdr.numSections = sa_htobe16(3);
620e7da798eSgarbled fileHdr.loadableSections = sa_htobe16(2);
621e7da798eSgarbled write(bebox_fd, &fileHdr, sizeof (fileHdr));
622e7da798eSgarbled
623e7da798eSgarbled /* Create the Section Header for TEXT */
624e7da798eSgarbled memset(&textHdr, 0, sizeof (textHdr));
625e7da798eSgarbled textHdr.sectionName = sa_htobe32(-1);
626e7da798eSgarbled textHdr.sectionAddress = sa_htobe32(0);
627e7da798eSgarbled textHdr.execSize = sa_htobe32(elf_image_len);
628e7da798eSgarbled textHdr.initSize = sa_htobe32(elf_image_len);
629e7da798eSgarbled textHdr.rawSize = sa_htobe32(elf_image_len);
630e7da798eSgarbled textHdr.fileOffset = sa_htobe32(textOffset);
631e7da798eSgarbled textHdr.regionKind = CodeSection;
632e7da798eSgarbled textHdr.shareKind = ContextShare;
633e7da798eSgarbled textHdr.alignment = 4; /* 16 byte alignment */
634e7da798eSgarbled write(bebox_fd, &textHdr, sizeof (textHdr));
635e7da798eSgarbled
636e7da798eSgarbled /* Create the Section Header for DATA */
637e7da798eSgarbled memset(&dataHdr, 0, sizeof (dataHdr));
638e7da798eSgarbled dataHdr.sectionName = sa_htobe32(-1);
639e7da798eSgarbled dataHdr.sectionAddress = sa_htobe32(0);
640e7da798eSgarbled dataHdr.execSize = sa_htobe32(sizeof (entry_vector) + kern_img_len);
641e7da798eSgarbled dataHdr.initSize = sa_htobe32(sizeof (entry_vector) + kern_img_len);
642e7da798eSgarbled dataHdr.rawSize = sa_htobe32(sizeof (entry_vector) + kern_img_len);
643e7da798eSgarbled dataHdr.fileOffset = sa_htobe32(dataOffset);
644e7da798eSgarbled dataHdr.regionKind = DataSection;
645e7da798eSgarbled dataHdr.shareKind = ContextShare;
646e7da798eSgarbled dataHdr.alignment = 4; /* 16 byte alignment */
647e7da798eSgarbled write(bebox_fd, &dataHdr, sizeof (dataHdr));
648e7da798eSgarbled
649e7da798eSgarbled /* Create the Section Header for loader stuff */
650e7da798eSgarbled memset(&ldrHdr, 0, sizeof (ldrHdr));
651e7da798eSgarbled ldrHdr.sectionName = sa_htobe32(-1);
652e7da798eSgarbled ldrHdr.sectionAddress = sa_htobe32(0);
653e7da798eSgarbled ldrHdr.execSize = sa_htobe32(sizeof (lh));
654e7da798eSgarbled ldrHdr.initSize = sa_htobe32(sizeof (lh));
655e7da798eSgarbled ldrHdr.rawSize = sa_htobe32(sizeof (lh));
656e7da798eSgarbled ldrHdr.fileOffset = sa_htobe32(ldrOffset);
657e7da798eSgarbled ldrHdr.regionKind = LoaderSection;
658e7da798eSgarbled ldrHdr.shareKind = GlobalShare;
659e7da798eSgarbled ldrHdr.alignment = 4; /* 16 byte alignment */
660e7da798eSgarbled write(bebox_fd, &ldrHdr, sizeof (ldrHdr));
661e7da798eSgarbled
662e7da798eSgarbled /* Create the Loader Header */
663e7da798eSgarbled memset(&lh, 0, sizeof (lh));
664e7da798eSgarbled lh.entryPointSection = sa_htobe32(1); /* Data */
665e7da798eSgarbled lh.entryPointOffset = sa_htobe32(0);
666e7da798eSgarbled lh.initPointSection = sa_htobe32(-1);
667e7da798eSgarbled lh.initPointOffset = sa_htobe32(0);
668e7da798eSgarbled lh.termPointSection = sa_htobe32(-1);
669e7da798eSgarbled lh.termPointOffset = sa_htobe32(0);
670e7da798eSgarbled lseek(bebox_fd, ldrOffset + hsize, SEEK_SET);
671e7da798eSgarbled write(bebox_fd, &lh, sizeof (lh));
672e7da798eSgarbled
673e7da798eSgarbled /* Copy the pseudo-DATA */
674e7da798eSgarbled memset(entry_vector, 0, sizeof (entry_vector));
675cd228535Skiyohara entry_vector[0] = sa_htobe32(BEBOX_ENTRY); /* Magic */
676e7da798eSgarbled lseek(bebox_fd, dataOffset + hsize, SEEK_SET);
677e7da798eSgarbled write(bebox_fd, entry_vector, sizeof (entry_vector));
678e7da798eSgarbled
679e7da798eSgarbled return textOffset;
680e7da798eSgarbled }
681e7da798eSgarbled
682e7da798eSgarbled static int
bebox_build_image(char * kernel,char * boot,char * rawdev,char * outname)683e7da798eSgarbled bebox_build_image(char *kernel, char *boot, char *rawdev, char *outname)
684e7da798eSgarbled {
685e7da798eSgarbled unsigned char *elf_img = NULL, *kern_img = NULL, *header_img = NULL;
686e7da798eSgarbled int i, ch, tmp, kgzlen, err, hsize = BEBOX_HEADER_SIZE;
687e7da798eSgarbled int elf_fd, bebox_fd, kern_fd, elf_img_len = 0;
688cfdf23c8Sphx off_t lenpos, kstart, kend, toff, endoff, flength;
689e7da798eSgarbled uint32_t swapped[128];
690cfdf23c8Sphx int32_t *offset;
691e7da798eSgarbled gzFile gzf;
692e7da798eSgarbled struct stat kern_stat;
693e7da798eSgarbled struct bebox_image_block *p;
694e7da798eSgarbled struct timeval tp;
695e7da798eSgarbled Elf32_External_Phdr phdr;
696e7da798eSgarbled
697e7da798eSgarbled elf_fd = open_file("bootloader", boot, &hdr, &elf_stat);
69830411c8bSkiyohara if (inkernflag) {
699e7da798eSgarbled kern_fd = open_file("kernel", kernel, &khdr, &kern_stat);
700e7da798eSgarbled kern_len = kern_stat.st_size + BEBOX_MAGICSIZE + KERNLENSIZE;
70130411c8bSkiyohara } else
70230411c8bSkiyohara kern_len = BEBOX_MAGICSIZE + KERNLENSIZE;
703e7da798eSgarbled
704e7da798eSgarbled for (i = 0; i < ELFGET16(hdr.e_phnum); i++) {
705e7da798eSgarbled lseek(elf_fd, ELFGET32(hdr.e_phoff) + sizeof(phdr) * i,
706e7da798eSgarbled SEEK_SET);
707e7da798eSgarbled if (read(elf_fd, &phdr, sizeof(phdr)) != sizeof(phdr))
708e7da798eSgarbled errx(3, "Can't read input '%s' phdr : %s", boot,
709e7da798eSgarbled strerror(errno));
710e7da798eSgarbled
711e7da798eSgarbled if ((ELFGET32(phdr.p_type) != PT_LOAD) ||
712e7da798eSgarbled !(ELFGET32(phdr.p_flags) & PF_X))
713e7da798eSgarbled continue;
714e7da798eSgarbled
715e7da798eSgarbled fstat(elf_fd, &elf_stat);
716cd228535Skiyohara elf_img_len = ELFGET32(phdr.p_filesz);
717e7da798eSgarbled lseek(elf_fd, ELFGET32(phdr.p_offset), SEEK_SET);
718e7da798eSgarbled
719e7da798eSgarbled break;
720e7da798eSgarbled }
721e7da798eSgarbled if ((bebox_fd = open(outname, O_RDWR|O_TRUNC, 0)) < 0) {
722e7da798eSgarbled /* we couldn't open it, it must be new */
723e7da798eSgarbled bebox_fd = creat(outname, 0644);
724e7da798eSgarbled if (bebox_fd < 0)
725e7da798eSgarbled errx(2, "Can't open output '%s': %s", outname,
726e7da798eSgarbled strerror(errno));
727e7da798eSgarbled }
728e7da798eSgarbled lseek(bebox_fd, hsize, SEEK_SET);
729e7da798eSgarbled
73030411c8bSkiyohara if (inkernflag) {
73130411c8bSkiyohara /*
73230411c8bSkiyohara * write the header with the wrong values to get the offset
73330411c8bSkiyohara * right
73430411c8bSkiyohara */
735cd228535Skiyohara bebox_write_header(bebox_fd, elf_img_len, kern_stat.st_size);
736e7da798eSgarbled
737e7da798eSgarbled /* Copy kernel */
738*4f26b22aSchristos kern_img = malloc(kern_stat.st_size);
739e7da798eSgarbled
740e7da798eSgarbled if (kern_img == NULL)
741e7da798eSgarbled errx(3, "Can't malloc: %s", strerror(errno));
742e7da798eSgarbled
743e7da798eSgarbled /* we need to jump back after having read the headers */
744e7da798eSgarbled lseek(kern_fd, 0, SEEK_SET);
745e7da798eSgarbled if (read(kern_fd, (void *)kern_img, kern_stat.st_size) !=
746e7da798eSgarbled kern_stat.st_size)
74730411c8bSkiyohara errx(3, "Can't read kernel '%s' : %s",
74830411c8bSkiyohara kernel, strerror(errno));
749e7da798eSgarbled
750e7da798eSgarbled gzf = gzdopen(dup(bebox_fd), "a");
751e7da798eSgarbled if (gzf == NULL)
752e7da798eSgarbled errx(3, "Can't init compression: %s", strerror(errno));
75330411c8bSkiyohara if (gzsetparams(gzf, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY) !=
75430411c8bSkiyohara Z_OK)
755e7da798eSgarbled errx(3, "%s", gzerror(gzf, &err));
75630411c8bSkiyohara } else
75730411c8bSkiyohara bebox_write_header(bebox_fd, elf_img_len, 0);
758e7da798eSgarbled
759e7da798eSgarbled /* write a magic number and size before the kernel */
760e7da798eSgarbled write(bebox_fd, (void *)bebox_magic, BEBOX_MAGICSIZE);
761e7da798eSgarbled lenpos = lseek(bebox_fd, 0, SEEK_CUR);
762e7da798eSgarbled tmp = sa_htobe32(0);
763e7da798eSgarbled write(bebox_fd, (void *)&tmp, KERNLENSIZE);
764e7da798eSgarbled
76530411c8bSkiyohara if (inkernflag) {
766e7da798eSgarbled /* write in the compressed kernel */
767e7da798eSgarbled kstart = lseek(bebox_fd, 0, SEEK_CUR);
768e7da798eSgarbled kgzlen = gzwrite(gzf, kern_img, kern_stat.st_size);
769e7da798eSgarbled gzclose(gzf);
770e7da798eSgarbled kend = lseek(bebox_fd, 0, SEEK_CUR);
771e7da798eSgarbled free(kern_img);
77230411c8bSkiyohara } else {
77330411c8bSkiyohara kstart = kend = lseek(bebox_fd, 0, SEEK_CUR);
77430411c8bSkiyohara kgzlen = 0;
77530411c8bSkiyohara }
776e7da798eSgarbled
777e7da798eSgarbled /* jump back to the length position now that we know the length */
778e7da798eSgarbled lseek(bebox_fd, lenpos, SEEK_SET);
779e7da798eSgarbled kgzlen = kend - kstart;
780e7da798eSgarbled tmp = sa_htobe32(kgzlen);
781e7da798eSgarbled write(bebox_fd, (void *)&tmp, KERNLENSIZE);
782e7da798eSgarbled
783e7da798eSgarbled /* now rewrite the header correctly */
784e7da798eSgarbled lseek(bebox_fd, hsize, SEEK_SET);
785cd228535Skiyohara tmp = kgzlen + BEBOX_MAGICSIZE + KERNLENSIZE;
786cd228535Skiyohara toff = bebox_write_header(bebox_fd, elf_img_len, tmp);
787e7da798eSgarbled
788e7da798eSgarbled /* Copy boot image */
789*4f26b22aSchristos elf_img = malloc(elf_img_len);
790e7da798eSgarbled if (!elf_img)
791e7da798eSgarbled errx(3, "Can't malloc: %s", strerror(errno));
792e7da798eSgarbled if (read(elf_fd, elf_img, elf_img_len) != elf_img_len)
793e7da798eSgarbled errx(3, "Can't read file '%s' : %s", boot, strerror(errno));
794e7da798eSgarbled lseek(bebox_fd, toff + hsize, SEEK_SET);
795e7da798eSgarbled write(bebox_fd, elf_img, elf_img_len);
796e7da798eSgarbled free(elf_img);
797e7da798eSgarbled
79830411c8bSkiyohara if (inkernflag)
799e7da798eSgarbled close(kern_fd);
800e7da798eSgarbled close(elf_fd);
801e7da798eSgarbled
802e7da798eSgarbled /* Now go back and write in the block header */
803e7da798eSgarbled endoff = lseek(bebox_fd, 0, SEEK_END);
804e7da798eSgarbled lseek(bebox_fd, 0, SEEK_SET);
805*4f26b22aSchristos header_img = malloc(BEBOX_HEADER_SIZE);
806e7da798eSgarbled if (!header_img)
807e7da798eSgarbled errx(3, "Can't malloc: %s", strerror(errno));
808e7da798eSgarbled memset(header_img, 0, BEBOX_HEADER_SIZE);
809e7da798eSgarbled
810e7da798eSgarbled /* copy the boot image into the buffer */
811e7da798eSgarbled for (p = bebox_image_block; p->offset != -1; p++)
812e7da798eSgarbled memcpy(header_img + p->offset, p->data, p->size);
813e7da798eSgarbled
814e7da798eSgarbled /* fill used block bitmap */
815e7da798eSgarbled memset(header_img + BEBOX_FILE_BLOCK_MAP_START, 0xff,
816e7da798eSgarbled BEBOX_FILE_BLOCK_MAP_END - BEBOX_FILE_BLOCK_MAP_START);
817e7da798eSgarbled
818e7da798eSgarbled /* fix the file size in the header */
819cd228535Skiyohara tmp = endoff - BEBOX_HEADER_SIZE;
820cfdf23c8Sphx *(int32_t *)(header_img + BEBOX_FILE_SIZE_OFFSET) =
821cfdf23c8Sphx (int32_t)sa_htobe32(tmp);
822cfdf23c8Sphx *(int32_t *)(header_img + BEBOX_FILE_SIZE_ALIGN_OFFSET) =
823cfdf23c8Sphx (int32_t)sa_htobe32(roundup(tmp, BEBOX_FILE_BLOCK_SIZE));
824e7da798eSgarbled
825e7da798eSgarbled gettimeofday(&tp, 0);
826e7da798eSgarbled for (offset = bebox_mtime_offset; *offset != -1; offset++)
827cfdf23c8Sphx *(int32_t *)(header_img + *offset) =
828cfdf23c8Sphx (int32_t)sa_htobe32(tp.tv_sec);
829e7da798eSgarbled
830e7da798eSgarbled write(bebox_fd, header_img, BEBOX_HEADER_SIZE);
831e7da798eSgarbled
832e7da798eSgarbled /* now pad the end */
833e7da798eSgarbled flength = roundup(endoff, BEBOX_BLOCK_SIZE);
834e7da798eSgarbled /* refill the header_img with zeros */
835e7da798eSgarbled memset(header_img, 0, BEBOX_BLOCK_SIZE * 2);
836e7da798eSgarbled lseek(bebox_fd, 0, SEEK_END);
837e7da798eSgarbled write(bebox_fd, header_img, flength - endoff);
838e7da798eSgarbled
839e7da798eSgarbled close(bebox_fd);
840*4f26b22aSchristos free(header_img);
841e7da798eSgarbled
842e7da798eSgarbled return 0;
843e7da798eSgarbled }
844e7da798eSgarbled
8454849f95dSgarbled int
main(int argc,char ** argv)8464849f95dSgarbled main(int argc, char **argv)
8474849f95dSgarbled {
8484849f95dSgarbled int ch, lfloppyflag=0;
8494849f95dSgarbled char *kernel = NULL, *boot = NULL, *rawdev = NULL, *outname = NULL;
8504849f95dSgarbled char *march = NULL;
851c3408ed0Sgarbled #ifdef USE_SYSCTL
852feab9a12Smartin char machine[SYS_NMLN];
853feab9a12Smartin int mib[2] = { CTL_HW, HW_MACHINE };
8544849f95dSgarbled #endif
8554849f95dSgarbled
8564849f95dSgarbled setprogname(argv[0]);
8574849f95dSgarbled kern_len = 0;
8584849f95dSgarbled
85930411c8bSkiyohara while ((ch = getopt(argc, argv, "b:Ik:lm:r:sv")) != -1)
8604849f95dSgarbled switch (ch) {
8614849f95dSgarbled case 'b':
8624849f95dSgarbled boot = optarg;
8634849f95dSgarbled break;
86430411c8bSkiyohara case 'I':
86530411c8bSkiyohara inkernflag = 0;
86630411c8bSkiyohara break;
8674849f95dSgarbled case 'k':
8684849f95dSgarbled kernel = optarg;
86930411c8bSkiyohara inkernflag = 1;
8704849f95dSgarbled break;
8714849f95dSgarbled case 'l':
8724849f95dSgarbled lfloppyflag = 1;
8734849f95dSgarbled break;
8744849f95dSgarbled case 'm':
8754849f95dSgarbled march = optarg;
8764849f95dSgarbled break;
8774849f95dSgarbled case 'r':
8784849f95dSgarbled rawdev = optarg;
8794849f95dSgarbled break;
8804849f95dSgarbled case 's':
8814849f95dSgarbled saloneflag = 1;
8824849f95dSgarbled break;
883690f8887Sgarbled case 'v':
884690f8887Sgarbled verboseflag = 1;
885690f8887Sgarbled break;
8864849f95dSgarbled case '?':
8874849f95dSgarbled default:
888690f8887Sgarbled usage(0);
8894849f95dSgarbled /* NOTREACHED */
8904849f95dSgarbled }
8914849f95dSgarbled argc -= optind;
8924849f95dSgarbled argv += optind;
8934849f95dSgarbled
8944849f95dSgarbled if (argc < 1)
895690f8887Sgarbled usage(0);
8964849f95dSgarbled
89730411c8bSkiyohara if (kernel == NULL && inkernflag)
8984849f95dSgarbled kernel = "/netbsd";
8994849f95dSgarbled
9004849f95dSgarbled if (boot == NULL)
9014849f95dSgarbled boot = "/usr/mdec/boot";
9024849f95dSgarbled
903a42bf0b7Sgarbled if (march != NULL && strcmp(march, "") == 0)
904690f8887Sgarbled march = NULL;
9054849f95dSgarbled if (march == NULL) {
9064849f95dSgarbled int i;
907c3408ed0Sgarbled #ifdef USE_SYSCTL
908feab9a12Smartin size_t len = sizeof(machine);
9094849f95dSgarbled
910feab9a12Smartin if (sysctl(mib, sizeof (mib) / sizeof (mib[0]), machine,
9114849f95dSgarbled &len, NULL, 0) != -1) {
9124849f95dSgarbled for (i=0; sup_plats[i] != NULL; i++) {
913feab9a12Smartin if (strcmp(sup_plats[i], machine) == 0) {
9144849f95dSgarbled march = strdup(sup_plats[i]);
9154849f95dSgarbled break;
9164849f95dSgarbled }
9174849f95dSgarbled }
9184849f95dSgarbled }
919690f8887Sgarbled if (march == NULL)
9204849f95dSgarbled #endif
921690f8887Sgarbled usage(1);
9224849f95dSgarbled }
9234849f95dSgarbled
9244849f95dSgarbled outname = argv[0];
9254849f95dSgarbled
9264849f95dSgarbled if (strcmp(march, "prep") == 0)
927690f8887Sgarbled return(prep_build_image(kernel, boot, rawdev, outname));
928690f8887Sgarbled if (strcmp(march, "rs6000") == 0)
929690f8887Sgarbled return(rs6000_build_image(kernel, boot, rawdev, outname));
930e7da798eSgarbled if (strcmp(march, "bebox") == 0)
931e7da798eSgarbled return(bebox_build_image(kernel, boot, rawdev, outname));
9324849f95dSgarbled
933690f8887Sgarbled usage(1);
9344849f95dSgarbled return(0);
93567049908Sgarbled }
936