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
main(int argc,char * argv[])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
cleanup(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
btxld(const char * iname)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
getbtx(int fd,struct btx_hdr * btx)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
gethdr(int fd,struct hdr * hdr)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
puthdr(int fd,struct hdr * hdr)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
copy(int fdi,int fdo,size_t nbyte,off_t offset)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
readx(int fd,void * buf,size_t nbyte,off_t offset)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
writex(int fd,const void * buf,size_t nbyte)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
seekx(int fd,off_t offset)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
optfmt(const char * arg)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
optaddr(const char * arg)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
optpage(const char * arg,int hi)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
Warn(const char * locus,const char * fmt,...)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
usage(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 }
572