1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
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 #ifndef lint
30 static const char rcsid[] =
31 "$FreeBSD$";
32 #endif /* not lint */
33
34 #include <sys/param.h>
35 #include <sys/endian.h>
36 #include <sys/stat.h>
37 #include <sys/mman.h>
38
39 /* XXX make this work as an i386/amd64 cross-tool */
40 #include <machine/exec.h>
41 #undef __LDPGSZ
42 #define __LDPGSZ 4096
43
44 #include <netinet/in.h>
45
46 #include <a.out.h>
47 #include <err.h>
48 #include <errno.h>
49 #include <fcntl.h>
50 #include <stdarg.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <unistd.h>
55
56 #include "btx.h"
57 #include "elfh.h"
58
59 #define BTX_PATH "/sys/boot/i386/btx"
60
61 #define I_LDR 0 /* BTX loader */
62 #define I_BTX 1 /* BTX kernel */
63 #define I_CLNT 2 /* Client program */
64
65 #define F_BIN 0 /* Binary */
66 #define F_AOUT 1 /* ZMAGIC a.out */
67 #define F_ELF 2 /* 32-bit ELF */
68 #define F_CNT 3 /* Number of formats */
69
70 #define IMPURE 1 /* Writable text */
71 #define MAXU32 0xffffffff /* Maximum unsigned 32-bit quantity */
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
main(int argc,char * argv[])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
cleanup(void)189 cleanup(void)
190 {
191 if (tname)
192 (void)remove(tname);
193 }
194
195 /*
196 * Read the input files; write the output file; display information.
197 */
198 static void
btxld(const char * iname)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 free((void*)(intptr_t)tname);
291 tname = NULL;
292 if (verbose) {
293 printf(binfo, btx.btx_majver, btx.btx_minver, btx.btx_textsz,
294 BTX_ORIGIN(btx), BTX_ENTRY(btx), BTX_MAPPED(btx) *
295 BTX_PGSIZE / 0x100000, !!(btx.btx_flags & BTX_MAPONE),
296 BTX_MAPPED(btx) - btx.btx_pgctl - BTX_PGBASE /
297 BTX_PGSIZE - BTX_MAPPED(btx) * 4 / BTX_PGSIZE);
298 printf(cinfo, fmtlist[ihdr.fmt], ihdr.size, ihdr.text,
299 ihdr.data, ihdr.bss, ihdr.entry);
300 printf(oinfo, fmtlist[ohdr.fmt], ohdr.size, ohdr.text,
301 ohdr.data, ohdr.org, ohdr.entry);
302 }
303 }
304
305 /*
306 * Read BTX file header.
307 */
308 static void
getbtx(int fd,struct btx_hdr * btx)309 getbtx(int fd, struct btx_hdr * btx)
310 {
311 if (readx(fd, btx, sizeof(*btx), 0) != sizeof(*btx) ||
312 btx->btx_magic[0] != BTX_MAG0 ||
313 btx->btx_magic[1] != BTX_MAG1 ||
314 btx->btx_magic[2] != BTX_MAG2)
315 errx(1, "%s: Not a BTX kernel", fname);
316 btx->btx_pgctl = le16toh(btx->btx_pgctl);
317 btx->btx_textsz = le16toh(btx->btx_textsz);
318 btx->btx_entry = le32toh(btx->btx_entry);
319 }
320
321 /*
322 * Get file size and read a.out or ELF header.
323 */
324 static void
gethdr(int fd,struct hdr * hdr)325 gethdr(int fd, struct hdr *hdr)
326 {
327 struct stat sb;
328 const struct exec *ex;
329 const Elf32_Ehdr *ee;
330 const Elf32_Phdr *ep;
331 void *p;
332 unsigned int fmt, x, n, i;
333
334 memset(hdr, 0, sizeof(*hdr));
335 if (fstat(fd, &sb))
336 err(2, "%s", fname);
337 if (sb.st_size > MAXU32)
338 errx(1, "%s: Too big", fname);
339 hdr->size = sb.st_size;
340 if (!hdr->size)
341 return;
342 if ((p = mmap(NULL, hdr->size, PROT_READ, MAP_SHARED, fd,
343 0)) == MAP_FAILED)
344 err(2, "%s", fname);
345 for (fmt = F_CNT - 1; !hdr->fmt && fmt; fmt--)
346 switch (fmt) {
347 case F_AOUT:
348 ex = p;
349 if (hdr->size >= sizeof(struct exec) && !N_BADMAG(*ex)) {
350 hdr->fmt = fmt;
351 x = N_GETMAGIC(*ex);
352 if (x == OMAGIC || x == NMAGIC) {
353 if (x == NMAGIC)
354 Warn(fname, "Treating %s NMAGIC as OMAGIC",
355 fmtlist[fmt]);
356 hdr->flags |= IMPURE;
357 }
358 hdr->text = le32toh(ex->a_text);
359 hdr->data = le32toh(ex->a_data);
360 hdr->bss = le32toh(ex->a_bss);
361 hdr->entry = le32toh(ex->a_entry);
362 if (le32toh(ex->a_entry) >= BTX_PGSIZE)
363 hdr->org = BTX_PGSIZE;
364 }
365 break;
366 case F_ELF:
367 ee = p;
368 if (hdr->size >= sizeof(Elf32_Ehdr) && IS_ELF(*ee)) {
369 hdr->fmt = fmt;
370 for (n = i = 0; i < le16toh(ee->e_phnum); i++) {
371 ep = (void *)((uint8_t *)p + le32toh(ee->e_phoff) +
372 le16toh(ee->e_phentsize) * i);
373 if (le32toh(ep->p_type) == PT_LOAD)
374 switch (n++) {
375 case 0:
376 hdr->text = le32toh(ep->p_filesz);
377 hdr->org = le32toh(ep->p_paddr);
378 if (le32toh(ep->p_flags) & PF_W)
379 hdr->flags |= IMPURE;
380 break;
381 case 1:
382 hdr->data = le32toh(ep->p_filesz);
383 hdr->bss = le32toh(ep->p_memsz) -
384 le32toh(ep->p_filesz);
385 break;
386 case 2:
387 Warn(fname,
388 "Ignoring extra %s PT_LOAD segments",
389 fmtlist[fmt]);
390 }
391 }
392 hdr->entry = le32toh(ee->e_entry);
393 }
394 }
395 if (munmap(p, hdr->size))
396 err(2, "%s", fname);
397 }
398
399 /*
400 * Write a.out or ELF header.
401 */
402 static void
puthdr(int fd,struct hdr * hdr)403 puthdr(int fd, struct hdr *hdr)
404 {
405 struct exec ex;
406 struct elfh eh;
407
408 switch (hdr->fmt) {
409 case F_AOUT:
410 memset(&ex, 0, sizeof(ex));
411 N_SETMAGIC(ex, ZMAGIC, MID_I386, 0);
412 hdr->text = N_ALIGN(ex, hdr->text);
413 ex.a_text = htole32(hdr->text);
414 hdr->data = N_ALIGN(ex, hdr->data);
415 ex.a_data = htole32(hdr->data);
416 ex.a_entry = htole32(hdr->entry);
417 writex(fd, &ex, sizeof(ex));
418 hdr->size = N_ALIGN(ex, sizeof(ex));
419 seekx(fd, hdr->size);
420 break;
421 case F_ELF:
422 eh = elfhdr;
423 eh.e.e_entry = htole32(hdr->entry);
424 eh.p[0].p_vaddr = eh.p[0].p_paddr = htole32(hdr->org);
425 eh.p[0].p_filesz = eh.p[0].p_memsz = htole32(hdr->text);
426 eh.p[1].p_offset = htole32(le32toh(eh.p[0].p_offset) +
427 le32toh(eh.p[0].p_filesz));
428 eh.p[1].p_vaddr = eh.p[1].p_paddr =
429 htole32(roundup2(le32toh(eh.p[0].p_paddr) + le32toh(eh.p[0].p_memsz),
430 4096));
431 eh.p[1].p_filesz = eh.p[1].p_memsz = htole32(hdr->data);
432 eh.sh[2].sh_addr = eh.p[0].p_vaddr;
433 eh.sh[2].sh_offset = eh.p[0].p_offset;
434 eh.sh[2].sh_size = eh.p[0].p_filesz;
435 eh.sh[3].sh_addr = eh.p[1].p_vaddr;
436 eh.sh[3].sh_offset = eh.p[1].p_offset;
437 eh.sh[3].sh_size = eh.p[1].p_filesz;
438 writex(fd, &eh, sizeof(eh));
439 hdr->size = sizeof(eh);
440 }
441 }
442
443 /*
444 * Safe copy from input file to output file.
445 */
446 static void
copy(int fdi,int fdo,size_t nbyte,off_t offset)447 copy(int fdi, int fdo, size_t nbyte, off_t offset)
448 {
449 char buf[8192];
450 size_t n;
451
452 while (nbyte) {
453 if ((n = sizeof(buf)) > nbyte)
454 n = nbyte;
455 if (readx(fdi, buf, n, offset) != n)
456 errx(2, "%s: Short read", fname);
457 writex(fdo, buf, n);
458 nbyte -= n;
459 offset = -1;
460 }
461 }
462
463 /*
464 * Safe read from input file.
465 */
466 static size_t
readx(int fd,void * buf,size_t nbyte,off_t offset)467 readx(int fd, void *buf, size_t nbyte, off_t offset)
468 {
469 ssize_t n;
470
471 if (offset != -1 && lseek(fd, offset, SEEK_SET) != offset)
472 err(2, "%s", fname);
473 if ((n = read(fd, buf, nbyte)) == -1)
474 err(2, "%s", fname);
475 return n;
476 }
477
478 /*
479 * Safe write to output file.
480 */
481 static void
writex(int fd,const void * buf,size_t nbyte)482 writex(int fd, const void *buf, size_t nbyte)
483 {
484 ssize_t n;
485
486 if ((n = write(fd, buf, nbyte)) == -1)
487 err(2, "%s", tname);
488 if ((size_t)n != nbyte)
489 errx(2, "%s: Short write", tname);
490 }
491
492 /*
493 * Safe seek in output file.
494 */
495 static void
seekx(int fd,off_t offset)496 seekx(int fd, off_t offset)
497 {
498 if (lseek(fd, offset, SEEK_SET) != offset)
499 err(2, "%s", tname);
500 }
501
502 /*
503 * Convert an option argument to a format code.
504 */
505 static unsigned int
optfmt(const char * arg)506 optfmt(const char *arg)
507 {
508 unsigned int i;
509
510 for (i = 0; i < F_CNT && strcmp(arg, fmtlist[i]); i++);
511 if (i == F_CNT)
512 errx(1, "%s: Unknown format", arg);
513 return i;
514 }
515
516 /*
517 * Convert an option argument to an address.
518 */
519 static uint32_t
optaddr(const char * arg)520 optaddr(const char *arg)
521 {
522 char *s;
523 unsigned long x;
524
525 errno = 0;
526 x = strtoul(arg, &s, 0);
527 if (errno || !*arg || *s || x > MAXU32)
528 errx(1, "%s: Illegal address", arg);
529 return x;
530 }
531
532 /*
533 * Convert an option argument to a page number.
534 */
535 static int
optpage(const char * arg,int hi)536 optpage(const char *arg, int hi)
537 {
538 char *s;
539 long x;
540
541 errno = 0;
542 x = strtol(arg, &s, 0);
543 if (errno || !*arg || *s || x < 0 || x > hi)
544 errx(1, "%s: Illegal page number", arg);
545 return x;
546 }
547
548 /*
549 * Display a warning.
550 */
551 static void
Warn(const char * locus,const char * fmt,...)552 Warn(const char *locus, const char *fmt, ...)
553 {
554 va_list ap;
555 char *s;
556
557 if (!quiet) {
558 asprintf(&s, "%s: Warning: %s", locus, fmt);
559 va_start(ap, fmt);
560 vwarnx(s, ap);
561 va_end(ap);
562 free(s);
563 }
564 }
565
566 /*
567 * Display usage information.
568 */
569 static void
usage(void)570 usage(void)
571 {
572 fprintf(stderr, "%s\n%s\n",
573 "usage: btxld [-qv] [-b file] [-E address] [-e address] [-f format]",
574 " [-l file] [-o filename] [-P page] [-W page] file");
575 exit(1);
576 }
577