usr.sbin/btxld/btxld.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 1998 Robert Nordier
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
  20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
  21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  22  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  23  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  25  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  26  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/endian.h>
  31 #include <sys/stat.h>
  32 #include <sys/mman.h>
  33
  34 /* XXX make this work as an i386/amd64 cross-tool */
  35 #include <machine/exec.h>
  36 #undef __LDPGSZ
  37 #define __LDPGSZ        4096
  38
  39 #include <netinet/in.h>
  40
  41 #include <a.out.h>
  42 #include <err.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <stdarg.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <unistd.h>
  50
  51 #include "btx.h"
  52 #include "elfh.h"
  53
  54 #define BTX_PATH                "/sys/boot/i386/btx"
  55
  56 #define I_LDR   0               /* BTX loader */
  57 #define I_BTX   1               /* BTX kernel */
  58 #define I_CLNT  2               /* Client program */
  59
  60 #define F_BIN   0               /* Binary */
  61 #define F_AOUT  1               /* ZMAGIC a.out */
  62 #define F_ELF   2               /* 32-bit ELF */
  63 #define F_CNT   3               /* Number of formats */
  64
  65 #define IMPURE  1               /* Writable text */
  66 #define MAXU32  0xffffffff      /* Maximum unsigned 32-bit quantity */
  67
  68 struct hdr {
  69     uint32_t fmt;               /* Format */
  70     uint32_t flags;             /* Bit flags */
  71     uint32_t size;              /* Size of file */
  72     uint32_t text;              /* Size of text segment */
  73     uint32_t data;              /* Size of data segment */
  74     uint32_t bss;               /* Size of bss segment */
  75     uint32_t org;               /* Program origin */
  76     uint32_t entry;             /* Program entry point */
  77 };
  78
  79 static const char *const fmtlist[] = {"bin", "aout", "elf"};
  80
  81 static const char binfo[] =
  82     "kernel: ver=%u.%02u size=%x load=%x entry=%x map=%uM "
  83     "pgctl=%x:%x\n";
  84 static const char cinfo[] =
  85     "client: fmt=%s size=%x text=%x data=%x bss=%x entry=%x\n";
  86 static const char oinfo[] =
  87     "output: fmt=%s size=%x text=%x data=%x org=%x entry=%x\n";
  88
  89 static const char *lname =
  90     BTX_PATH "/btxldr/btxldr";  /* BTX loader */
  91 static const char *bname =
  92     BTX_PATH "/btx/btx";        /* BTX kernel */
  93 static const char *oname =
  94     "a.out";                    /* Output filename */
  95
  96 static int ppage = -1;          /* First page present */
  97 static int wpage = -1;          /* First page writable */
  98
  99 static unsigned int format;     /* Output format */
 100
 101 static uint32_t centry;         /* Client entry address */
 102 static uint32_t lentry;         /* Loader entry address */
 103
 104 static int Eflag;               /* Client entry option */
 105
 106 static int quiet;               /* Inhibit warnings */
 107 static int verbose;             /* Display information */
 108
 109 static const char *tname;       /* Temporary output file */
 110 static const char *fname;       /* Current input file */
 111
 112 static void cleanup(void);
 113 static void btxld(const char *);
 114 static void getbtx(int, struct btx_hdr *);
 115 static void gethdr(int, struct hdr *);
 116 static void puthdr(int, struct hdr *);
 117 static void copy(int, int, size_t, off_t);
 118 static size_t readx(int, void *, size_t, off_t);
 119 static void writex(int, const void *, size_t);
 120 static void seekx(int, off_t);
 121 static unsigned int optfmt(const char *);
 122 static uint32_t optaddr(const char *);
 123 static int optpage(const char *, int);
 124 static void Warn(const char *, const char *, ...);
 125 static void usage(void) __dead2;
 126
 127 /*
 128  * A link editor for BTX clients.
 129  */
 130 int
 131 main(int argc, char *argv[])
 132 {
 133     int c;
 134
 135     while ((c = getopt(argc, argv, "qvb:E:e:f:l:o:P:W:")) != -1)
 136         switch (c) {
 137         case 'q':
 138             quiet = 1;
 139             break;
 140         case 'v':
 141             verbose = 1;
 142             break;
 143         case 'b':
 144             bname = optarg;
 145             break;
 146         case 'E':
 147             centry = optaddr(optarg);
 148             Eflag = 1;
 149             break;
 150         case 'e':
 151             lentry = optaddr(optarg);
 152             break;
 153         case 'f':
 154             format = optfmt(optarg);
 155             break;
 156         case 'l':
 157             lname = optarg;
 158             break;
 159         case 'o':
 160             oname = optarg;
 161             break;
 162         case 'P':
 163             ppage = optpage(optarg, 1);
 164             break;
 165         case 'W':
 166             wpage = optpage(optarg, BTX_MAXCWR);
 167             break;
 168         default:
 169             usage();
 170         }
 171     argc -= optind;
 172     argv += optind;
 173     if (argc != 1)
 174         usage();
 175     atexit(cleanup);
 176     btxld(*argv);
 177     return 0;
 178 }
 179
 180 /*
 181  * Clean up after errors.
 182  */
 183 static void
 184 cleanup(void)
 185 {
 186     if (tname)
 187         (void)remove(tname);
 188 }
 189
 190 /*
 191  * Read the input files; write the output file; display information.
 192  */
 193 static void
 194 btxld(const char *iname)
 195 {
 196     char name[FILENAME_MAX];
 197     struct btx_hdr btx, btxle;
 198     struct hdr ihdr, ohdr;
 199     unsigned int ldr_size, cwr;
 200     int fdi[3], fdo, i;
 201
 202     ldr_size = 0;
 203
 204     for (i = I_LDR; i <= I_CLNT; i++) {
 205         fname = i == I_LDR ? lname : i == I_BTX ? bname : iname;
 206         if ((fdi[i] = open(fname, O_RDONLY)) == -1)
 207             err(2, "%s", fname);
 208         switch (i) {
 209         case I_LDR:
 210             gethdr(fdi[i], &ihdr);
 211             if (ihdr.fmt != F_BIN)
 212                 Warn(fname, "Loader format is %s; processing as %s",
 213                      fmtlist[ihdr.fmt], fmtlist[F_BIN]);
 214             ldr_size = ihdr.size;
 215             break;
 216         case I_BTX:
 217             getbtx(fdi[i], &btx);
 218             break;
 219         case I_CLNT:
 220             gethdr(fdi[i], &ihdr);
 221             if (ihdr.org && ihdr.org != BTX_PGSIZE)
 222                 Warn(fname,
 223                      "Client origin is 0x%x; expecting 0 or 0x%x",
 224                      ihdr.org, BTX_PGSIZE);
 225         }
 226     }
 227     memset(&ohdr, 0, sizeof(ohdr));
 228     ohdr.fmt = format;
 229     ohdr.text = ldr_size;
 230     ohdr.data = btx.btx_textsz + ihdr.size;
 231     ohdr.org = lentry;
 232     ohdr.entry = lentry;
 233     cwr = 0;
 234     if (wpage > 0 || (wpage == -1 && !(ihdr.flags & IMPURE))) {
 235         if (wpage > 0)
 236             cwr = wpage;
 237         else {
 238             cwr = howmany(ihdr.text, BTX_PGSIZE);
 239             if (cwr > BTX_MAXCWR)
 240                 cwr = BTX_MAXCWR;
 241         }
 242     }
 243     if (ppage > 0 || (ppage && wpage && ihdr.org >= BTX_PGSIZE)) {
 244         btx.btx_flags |= BTX_MAPONE;
 245         if (!cwr)
 246             cwr++;
 247     }
 248     btx.btx_pgctl -= cwr;
 249     btx.btx_entry = Eflag ? centry : ihdr.entry;
 250     if ((size_t)snprintf(name, sizeof(name), "%s.tmp", oname) >= sizeof(name))
 251         errx(2, "%s: Filename too long", oname);
 252     if ((fdo = open(name, O_CREAT | O_TRUNC | O_WRONLY, 0666)) == -1)
 253         err(2, "%s", name);
 254     if (!(tname = strdup(name)))
 255         err(2, NULL);
 256     puthdr(fdo, &ohdr);
 257     for (i = I_LDR; i <= I_CLNT; i++) {
 258         fname = i == I_LDR ? lname : i == I_BTX ? bname : iname;
 259         switch (i) {
 260         case I_LDR:
 261             copy(fdi[i], fdo, ldr_size, 0);
 262             seekx(fdo, ohdr.size += ohdr.text);
 263             break;
 264         case I_BTX:
 265             btxle = btx;
 266             btxle.btx_pgctl = htole16(btxle.btx_pgctl);
 267             btxle.btx_textsz = htole16(btxle.btx_textsz);
 268             btxle.btx_entry = htole32(btxle.btx_entry);
 269             writex(fdo, &btxle, sizeof(btxle));
 270             copy(fdi[i], fdo, btx.btx_textsz - sizeof(btx),
 271                  sizeof(btx));
 272             break;
 273         case I_CLNT:
 274             copy(fdi[i], fdo, ihdr.size, 0);
 275             if (ftruncate(fdo, ohdr.size += ohdr.data))
 276                 err(2, "%s", tname);
 277         }
 278         if (close(fdi[i]))
 279             err(2, "%s", fname);
 280     }
 281     if (close(fdo))
 282         err(2, "%s", tname);
 283     if (rename(tname, oname))
 284         err(2, "%s: Can't rename to %s", tname, oname);
 285     free((void*)(intptr_t)tname);
 286     tname = NULL;
 287     if (verbose) {
 288         printf(binfo, btx.btx_majver, btx.btx_minver, btx.btx_textsz,
 289                BTX_ORIGIN(btx), BTX_ENTRY(btx), BTX_MAPPED(btx) *
 290                BTX_PGSIZE / 0x100000, !!(btx.btx_flags & BTX_MAPONE),
 291                BTX_MAPPED(btx) - btx.btx_pgctl - BTX_PGBASE /
 292                BTX_PGSIZE - BTX_MAPPED(btx) * 4 / BTX_PGSIZE);
 293         printf(cinfo, fmtlist[ihdr.fmt], ihdr.size, ihdr.text,
 294                ihdr.data, ihdr.bss, ihdr.entry);
 295         printf(oinfo, fmtlist[ohdr.fmt], ohdr.size, ohdr.text,
 296                ohdr.data, ohdr.org, ohdr.entry);
 297     }
 298 }
 299
 300 /*
 301  * Read BTX file header.
 302  */
 303 static void
 304 getbtx(int fd, struct btx_hdr * btx)
 305 {
 306     if (readx(fd, btx, sizeof(*btx), 0) != sizeof(*btx) ||
 307         btx->btx_magic[0] != BTX_MAG0 ||
 308         btx->btx_magic[1] != BTX_MAG1 ||
 309         btx->btx_magic[2] != BTX_MAG2)
 310         errx(1, "%s: Not a BTX kernel", fname);
 311     btx->btx_pgctl = le16toh(btx->btx_pgctl);
 312     btx->btx_textsz = le16toh(btx->btx_textsz);
 313     btx->btx_entry = le32toh(btx->btx_entry);
 314 }
 315
 316 /*
 317  * Get file size and read a.out or ELF header.
 318  */
 319 static void
 320 gethdr(int fd, struct hdr *hdr)
 321 {
 322     struct stat sb;
 323     const struct exec *ex;
 324     const Elf32_Ehdr *ee;
 325     const Elf32_Phdr *ep;
 326     void *p;
 327     unsigned int fmt, x, n, i;
 328
 329     memset(hdr, 0, sizeof(*hdr));
 330     if (fstat(fd, &sb))
 331         err(2, "%s", fname);
 332     if (sb.st_size > MAXU32)
 333         errx(1, "%s: Too big", fname);
 334     hdr->size = sb.st_size;
 335     if (!hdr->size)
 336         return;
 337     if ((p = mmap(NULL, hdr->size, PROT_READ, MAP_SHARED, fd,
 338                   0)) == MAP_FAILED)
 339         err(2, "%s", fname);
 340     for (fmt = F_CNT - 1; !hdr->fmt && fmt; fmt--)
 341         switch (fmt) {
 342         case F_AOUT:
 343             ex = p;
 344             if (hdr->size >= sizeof(struct exec) && !N_BADMAG(*ex)) {
 345                 hdr->fmt = fmt;
 346                 x = N_GETMAGIC(*ex);
 347                 if (x == OMAGIC || x == NMAGIC) {
 348                     if (x == NMAGIC)
 349                         Warn(fname, "Treating %s NMAGIC as OMAGIC",
 350                              fmtlist[fmt]);
 351                     hdr->flags |= IMPURE;
 352                 }
 353                 hdr->text = le32toh(ex->a_text);
 354                 hdr->data = le32toh(ex->a_data);
 355                 hdr->bss = le32toh(ex->a_bss);
 356                 hdr->entry = le32toh(ex->a_entry);
 357                 if (le32toh(ex->a_entry) >= BTX_PGSIZE)
 358                     hdr->org = BTX_PGSIZE;
 359             }
 360             break;
 361         case F_ELF:
 362             ee = p;
 363             if (hdr->size >= sizeof(Elf32_Ehdr) && IS_ELF(*ee)) {
 364                 hdr->fmt = fmt;
 365                 for (n = i = 0; i < le16toh(ee->e_phnum); i++) {
 366                     ep = (void *)((uint8_t *)p + le32toh(ee->e_phoff) +
 367                                   le16toh(ee->e_phentsize) * i);
 368                     if (le32toh(ep->p_type) == PT_LOAD)
 369                         switch (n++) {
 370                         case 0:
 371                             hdr->text = le32toh(ep->p_filesz);
 372                             hdr->org = le32toh(ep->p_paddr);
 373                             if (le32toh(ep->p_flags) & PF_W)
 374                                 hdr->flags |= IMPURE;
 375                             break;
 376                         case 1:
 377                             hdr->data = le32toh(ep->p_filesz);
 378                             hdr->bss = le32toh(ep->p_memsz) -
 379                                 le32toh(ep->p_filesz);
 380                             break;
 381                         case 2:
 382                             Warn(fname,
 383                                  "Ignoring extra %s PT_LOAD segments",
 384                                  fmtlist[fmt]);
 385                         }
 386                 }
 387                 hdr->entry = le32toh(ee->e_entry);
 388             }
 389         }
 390     if (munmap(p, hdr->size))
 391         err(2, "%s", fname);
 392 }
 393
 394 /*
 395  * Write a.out or ELF header.
 396  */
 397 static void
 398 puthdr(int fd, struct hdr *hdr)
 399 {
 400     struct exec ex;
 401     struct elfh eh;
 402
 403     switch (hdr->fmt) {
 404     case F_AOUT:
 405         memset(&ex, 0, sizeof(ex));
 406         N_SETMAGIC(ex, ZMAGIC, MID_I386, 0);
 407         hdr->text = N_ALIGN(ex, hdr->text);
 408         ex.a_text = htole32(hdr->text);
 409         hdr->data = N_ALIGN(ex, hdr->data);
 410         ex.a_data = htole32(hdr->data);
 411         ex.a_entry = htole32(hdr->entry);
 412         writex(fd, &ex, sizeof(ex));
 413         hdr->size = N_ALIGN(ex, sizeof(ex));
 414         seekx(fd, hdr->size);
 415         break;
 416     case F_ELF:
 417         eh = elfhdr;
 418         eh.e.e_entry = htole32(hdr->entry);
 419         eh.p[0].p_vaddr = eh.p[0].p_paddr = htole32(hdr->org);
 420         eh.p[0].p_filesz = eh.p[0].p_memsz = htole32(hdr->text);
 421         eh.p[1].p_offset = htole32(le32toh(eh.p[0].p_offset) +
 422             le32toh(eh.p[0].p_filesz));
 423         eh.p[1].p_vaddr = eh.p[1].p_paddr =
 424             htole32(roundup2(le32toh(eh.p[0].p_paddr) + le32toh(eh.p[0].p_memsz),
 425             4096));
 426         eh.p[1].p_filesz = eh.p[1].p_memsz = htole32(hdr->data);
 427         eh.sh[2].sh_addr = eh.p[0].p_vaddr;
 428         eh.sh[2].sh_offset = eh.p[0].p_offset;
 429         eh.sh[2].sh_size = eh.p[0].p_filesz;
 430         eh.sh[3].sh_addr = eh.p[1].p_vaddr;
 431         eh.sh[3].sh_offset = eh.p[1].p_offset;
 432         eh.sh[3].sh_size = eh.p[1].p_filesz;
 433         writex(fd, &eh, sizeof(eh));
 434         hdr->size = sizeof(eh);
 435     }
 436 }
 437
 438 /*
 439  * Safe copy from input file to output file.
 440  */
 441 static void
 442 copy(int fdi, int fdo, size_t nbyte, off_t offset)
 443 {
 444     char buf[8192];
 445     size_t n;
 446
 447     while (nbyte) {
 448         if ((n = sizeof(buf)) > nbyte)
 449             n = nbyte;
 450         if (readx(fdi, buf, n, offset) != n)
 451             errx(2, "%s: Short read", fname);
 452         writex(fdo, buf, n);
 453         nbyte -= n;
 454         offset = -1;
 455     }
 456 }
 457
 458 /*
 459  * Safe read from input file.
 460  */
 461 static size_t
 462 readx(int fd, void *buf, size_t nbyte, off_t offset)
 463 {
 464     ssize_t n;
 465
 466     if (offset != -1 && lseek(fd, offset, SEEK_SET) != offset)
 467         err(2, "%s", fname);
 468     if ((n = read(fd, buf, nbyte)) == -1)
 469         err(2, "%s", fname);
 470     return n;
 471 }
 472
 473 /*
 474  * Safe write to output file.
 475  */
 476 static void
 477 writex(int fd, const void *buf, size_t nbyte)
 478 {
 479     ssize_t n;
 480
 481     if ((n = write(fd, buf, nbyte)) == -1)
 482         err(2, "%s", tname);
 483     if ((size_t)n != nbyte)
 484         errx(2, "%s: Short write", tname);
 485 }
 486
 487 /*
 488  * Safe seek in output file.
 489  */
 490 static void
 491 seekx(int fd, off_t offset)
 492 {
 493     if (lseek(fd, offset, SEEK_SET) != offset)
 494         err(2, "%s", tname);
 495 }
 496
 497 /*
 498  * Convert an option argument to a format code.
 499  */
 500 static unsigned int
 501 optfmt(const char *arg)
 502 {
 503     unsigned int i;
 504
 505     for (i = 0; i < F_CNT && strcmp(arg, fmtlist[i]); i++);
 506     if (i == F_CNT)
 507         errx(1, "%s: Unknown format", arg);
 508     return i;
 509 }
 510
 511 /*
 512  * Convert an option argument to an address.
 513  */
 514 static uint32_t
 515 optaddr(const char *arg)
 516 {
 517     char *s;
 518     unsigned long x;
 519
 520     errno = 0;
 521     x = strtoul(arg, &s, 0);
 522     if (errno || !*arg || *s || x > MAXU32)
 523         errx(1, "%s: Illegal address", arg);
 524     return x;
 525 }
 526
 527 /*
 528  * Convert an option argument to a page number.
 529  */
 530 static int
 531 optpage(const char *arg, int hi)
 532 {
 533     char *s;
 534     long x;
 535
 536     errno = 0;
 537     x = strtol(arg, &s, 0);
 538     if (errno || !*arg || *s || x < 0 || x > hi)
 539         errx(1, "%s: Illegal page number", arg);
 540     return x;
 541 }
 542
 543 /*
 544  * Display a warning.
 545  */
 546 static void
 547 Warn(const char *locus, const char *fmt, ...)
 548 {
 549     va_list ap;
 550     char *s;
 551
 552     if (!quiet) {
 553         asprintf(&s, "%s: Warning: %s", locus, fmt);
 554         va_start(ap, fmt);
 555         vwarnx(s, ap);
 556         va_end(ap);
 557         free(s);
 558     }
 559 }
 560
 561 /*
 562  * Display usage information.
 563  */
 564 static void
 565 usage(void)
 566 {
 567     fprintf(stderr, "%s\n%s\n",
 568     "usage: btxld [-qv] [-b file] [-E address] [-e address] [-f format]",
 569     "             [-l file] [-o filename] [-P page] [-W page] file");
 570     exit(1);
 571 }