usr.sbin/btxld/btxld.c

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