1 /*
2  * Copyright (c) 1998 Robert Nordier
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms are freely
6  * permitted provided that the above copyright notice and this
7  * paragraph and the following disclaimer are duplicated in all
8  * such forms.
9  *
10  * This software is provided "AS IS" and without any express or
11  * implied warranties, including, without limitation, the implied
12  * warranties of merchantability and fitness for a particular
13  * purpose.
14  */
15 
16 #include <sys/cdefs.h>
17 
18 #include <sys/param.h>
19 #include <sys/gpt.h>
20 #include <sys/dirent.h>
21 #include <sys/reboot.h>
22 
23 #include <machine/bootinfo.h>
24 #include <machine/elf.h>
25 #include <machine/pc/bios.h>
26 #include <machine/psl.h>
27 
28 #include <stdarg.h>
29 
30 #include <a.out.h>
31 
32 #include <btxv86.h>
33 
34 #include "stand.h"
35 
36 #include "bootargs.h"
37 #include "lib.h"
38 #include "rbx.h"
39 #include "drv.h"
40 #include "cons.h"
41 #include "gpt.h"
42 #include "paths.h"
43 
44 #define	ARGS		0x900
45 #define	NOPT		14
46 #define	NDEV		3
47 #define	MEM_BASE	0x12
48 #define	MEM_EXT		0x15
49 
50 #define	DRV_HARD	0x80
51 #define	DRV_MASK	0x7f
52 
53 #define	TYPE_AD		0
54 #define	TYPE_DA		1
55 #define	TYPE_MAXHARD	TYPE_DA
56 #define	TYPE_FD		2
57 
58 /*
59  * Fake multiboot header to provide versioning and to pass
60  * partition start LBA. Partition is either GPT partition or
61  * VTOC slice.
62  */
63 extern const struct multiboot_header mb_header;
64 extern uint64_t start_sector;
65 
66 extern uint32_t _end;
67 
68 static const char optstr[NOPT] = "DhaCcdgmnpqrsv"; /* Also 'P', 'S' */
69 static const unsigned char flags[NOPT] = {
70 	RBX_DUAL,
71 	RBX_SERIAL,
72 	RBX_ASKNAME,
73 	RBX_CDROM,
74 	RBX_CONFIG,
75 	RBX_KDB,
76 	RBX_GDB,
77 	RBX_MUTE,
78 	RBX_NOINTR,
79 	RBX_PAUSE,
80 	RBX_QUIET,
81 	RBX_DFLTROOT,
82 	RBX_SINGLE,
83 	RBX_VERBOSE
84 };
85 uint32_t opts;
86 
87 static const char *const dev_nm[NDEV] = {"ad", "da", "fd"};
88 static const unsigned char dev_maj[NDEV] = {30, 4, 2};
89 
90 static struct dsk dsk;
91 static char kname[1024];
92 static int comspeed = SIOSPD;
93 static struct bootinfo bootinfo;
94 
95 static vm_offset_t	high_heap_base;
96 static uint32_t		bios_basemem, bios_extmem, high_heap_size;
97 
98 static struct bios_smap smap;
99 
100 /*
101  * The minimum amount of memory to reserve in bios_extmem for the heap.
102  */
103 #define	HEAP_MIN	(3 * 1024 * 1024)
104 
105 static char *heap_next;
106 static char *heap_end;
107 
108 int main(void);
109 
110 void exit(int);
111 static void load(void);
112 static int parse_cmds(char *, int *);
113 
114 static uint8_t ls;
115 static uint32_t fs_off;
116 
117 #include "cd9660read.c"
118 
119 static int
xfsread(uint64_t inode,void * buf,size_t nbyte)120 xfsread(uint64_t inode, void *buf, size_t nbyte)
121 {
122 
123 	if ((size_t)cd9660_fsread(inode, buf, nbyte) != nbyte) {
124 		printf("Invalid %s\n", "format");
125 		return (-1);
126 	}
127 	return (0);
128 }
129 
130 static void
bios_getmem(void)131 bios_getmem(void)
132 {
133 	uint64_t size;
134 
135 	/* Parse system memory map */
136 	v86.ebx = 0;
137 	do {
138 		v86.ctl = V86_FLAGS;
139 		v86.addr = MEM_EXT;		/* int 0x15 function 0xe820 */
140 		v86.eax = 0xe820;
141 		v86.ecx = sizeof (struct bios_smap);
142 		v86.edx = SMAP_SIG;
143 		v86.es = VTOPSEG(&smap);
144 		v86.edi = VTOPOFF(&smap);
145 		v86int();
146 		if ((v86.efl & 1) || (v86.eax != SMAP_SIG))
147 			break;
148 		/* look for a low-memory segment that's large enough */
149 		if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) &&
150 		    (smap.length >= (512 * 1024)))
151 			bios_basemem = smap.length;
152 		/* look for the first segment in 'extended' memory */
153 		if ((smap.type == SMAP_TYPE_MEMORY) &&
154 		    (smap.base == 0x100000)) {
155 			bios_extmem = smap.length;
156 		}
157 
158 		/*
159 		 * Look for the largest segment in 'extended' memory beyond
160 		 * 1MB but below 4GB.
161 		 */
162 		if ((smap.type == SMAP_TYPE_MEMORY) &&
163 		    (smap.base > 0x100000) && (smap.base < 0x100000000ull)) {
164 			size = smap.length;
165 
166 			/*
167 			 * If this segment crosses the 4GB boundary,
168 			 * truncate it.
169 			 */
170 			if (smap.base + size > 0x100000000ull)
171 				size = 0x100000000ull - smap.base;
172 
173 			if (size > high_heap_size) {
174 				high_heap_size = size;
175 				high_heap_base = smap.base;
176 			}
177 		}
178 	} while (v86.ebx != 0);
179 
180 	/* Fall back to the old compatibility function for base memory */
181 	if (bios_basemem == 0) {
182 		v86.ctl = 0;
183 		v86.addr = 0x12;		/* int 0x12 */
184 		v86int();
185 
186 		bios_basemem = (v86.eax & 0xffff) * 1024;
187 	}
188 
189 	/*
190 	 * Fall back through several compatibility functions for extended
191 	 * memory
192 	 */
193 	if (bios_extmem == 0) {
194 		v86.ctl = V86_FLAGS;
195 		v86.addr = 0x15;		/* int 0x15 function 0xe801 */
196 		v86.eax = 0xe801;
197 		v86int();
198 		if (!(v86.efl & 1)) {
199 			bios_extmem = ((v86.ecx & 0xffff) +
200 			    ((v86.edx & 0xffff) * 64)) * 1024;
201 		}
202 	}
203 	if (bios_extmem == 0) {
204 		v86.ctl = 0;
205 		v86.addr = 0x15;		/* int 0x15 function 0x88 */
206 		v86.eax = 0x8800;
207 		v86int();
208 		bios_extmem = (v86.eax & 0xffff) * 1024;
209 	}
210 
211 	/*
212 	 * If we have extended memory and did not find a suitable heap
213 	 * region in the SMAP, use the last 3MB of 'extended' memory as a
214 	 * high heap candidate.
215 	 */
216 	if (bios_extmem >= HEAP_MIN && high_heap_size < HEAP_MIN) {
217 		high_heap_size = HEAP_MIN;
218 		high_heap_base = bios_extmem + 0x100000 - HEAP_MIN;
219 	}
220 }
221 
222 int
main(void)223 main(void)
224 {
225 	char cmd[512], cmdtmp[512];
226 	ssize_t sz;
227 	int autoboot, dskupdated;
228 	uint64_t ino;
229 
230 	bios_getmem();
231 
232 	if (high_heap_size > 0) {
233 		heap_end = PTOV(high_heap_base + high_heap_size);
234 		heap_next = PTOV(high_heap_base);
235 	} else {
236 		heap_next = (char *)
237 		    (roundup2(__base + (int32_t)&_end, 0x10000) - __base);
238 		heap_end = (char *)PTOV(bios_basemem);
239 	}
240 	setheap(heap_next, heap_end);
241 
242 	/* Reference start_sector or linker will elliminate it. */
243 	if (start_sector != 0)
244 		printf("isoboot: starting...\n");
245 
246 	v86.ctl = V86_FLAGS;
247 	v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
248 	dsk.drive = *(uint8_t *)PTOV(ARGS);
249 	dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
250 	dsk.unit = dsk.drive & DRV_MASK;
251 	dsk.part = -1;
252 	dsk.start = 0;
253 	bootinfo.bi_version = BOOTINFO_VERSION;
254 	bootinfo.bi_size = sizeof (bootinfo);
255 	bootinfo.bi_basemem = bios_basemem / 1024;
256 	bootinfo.bi_extmem = bios_extmem / 1024;
257 	bootinfo.bi_memsizes_valid++;
258 	bootinfo.bi_bios_dev = dsk.drive;
259 
260 	autoboot = 1;
261 	*cmd = '\0';
262 
263 	for (;;) {
264 		*kname = '\0';
265 		if ((ino = cd9660_lookup(PATH_CONFIG)) ||
266 		    (ino = cd9660_lookup(PATH_DOTCONFIG))) {
267 			sz = cd9660_fsread(ino, cmd, sizeof (cmd) - 1);
268 			cmd[(sz < 0) ? 0 : sz] = '\0';
269 		}
270 		if (*cmd != '\0') {
271 			memcpy(cmdtmp, cmd, sizeof (cmdtmp));
272 			if (parse_cmds(cmdtmp, &dskupdated))
273 				break;
274 			if (!OPT_CHECK(RBX_QUIET))
275 				printf("%s: %s", PATH_CONFIG, cmd);
276 			*cmd = '\0';
277 		}
278 
279 		if (autoboot && keyhit(3)) {
280 			if (*kname == '\0') {
281 				memcpy(kname, PATH_LOADER,
282 				    sizeof (PATH_LOADER));
283 			}
284 			break;
285 		}
286 		autoboot = 0;
287 
288 		/*
289 		 * Try to exec stage 3 boot loader. If interrupted by a
290 		 * keypress, or in case of failure, try to load a kernel
291 		 * directly instead.
292 		 */
293 		if (*kname != '\0')
294 			load();
295 		memcpy(kname, PATH_LOADER, sizeof (PATH_LOADER));
296 		load();
297 		break;
298 	}
299 
300 	/* Present the user with the boot2 prompt. */
301 
302 	for (;;) {
303 		if (!OPT_CHECK(RBX_QUIET)) {
304 			printf("\nillumos/x86 boot\n");
305 			if (dsk.part == -1) {
306 				printf("Default: %u:%s(%u)%s\n",
307 				    dsk.drive & DRV_MASK, dev_nm[dsk.type],
308 				    dsk.unit, kname);
309 			} else {
310 				printf("Default: %u:%s(%up%u)%s\n",
311 				    dsk.drive & DRV_MASK, dev_nm[dsk.type],
312 				    dsk.unit, dsk.part, kname);
313 			}
314 			printf("boot: ");
315 		}
316 		if (ioctrl & IO_SERIAL)
317 			sio_flush();
318 		*cmd = '\0';
319 		if (keyhit(0))
320 			getstr(cmd, sizeof (cmd));
321 		else if (!OPT_CHECK(RBX_QUIET))
322 			putchar('\n');
323 		if (parse_cmds(cmd, &dskupdated)) {
324 			putchar('\a');
325 			continue;
326 		}
327 		load();
328 	}
329 	/* NOTREACHED */
330 }
331 
332 /* Needed so btxld can link us properly; do not remove. */
333 void
exit(int x)334 exit(int x)
335 {
336 
337 	__exit(x);
338 }
339 
340 static void
load(void)341 load(void)
342 {
343 	union {
344 		struct exec ex;
345 		Elf32_Ehdr eh;
346 	} hdr;
347 	static Elf32_Phdr ep[2];
348 	static Elf32_Shdr es[2];
349 	caddr_t p;
350 	uint64_t ino;
351 	uint32_t addr, x;
352 	int fmt, i, j;
353 
354 	if (!(ino = cd9660_lookup(kname))) {
355 		if (!ls) {
356 			printf("%s: No %s on %u:%s(%u", BOOTPROG,
357 			    kname, dsk.drive & DRV_MASK, dev_nm[dsk.type],
358 			    dsk.unit);
359 			if (dsk.part != -1)
360 				printf("p%u", dsk.part);
361 			printf(")\n");
362 		}
363 		return;
364 	}
365 	if (xfsread(ino, &hdr, sizeof (hdr)))
366 		return;
367 	if (N_GETMAGIC(hdr.ex) == ZMAGIC)
368 		fmt = 0;
369 	else if (IS_ELF(hdr.eh))
370 		fmt = 1;
371 	else {
372 		printf("Invalid %s\n", "format");
373 		return;
374 	}
375 	if (fmt == 0) {
376 		addr = hdr.ex.a_entry & 0xffffff;
377 		p = PTOV(addr);
378 		fs_off = PAGE_SIZE;
379 		if (xfsread(ino, p, hdr.ex.a_text))
380 			return;
381 		p += roundup2(hdr.ex.a_text, PAGE_SIZE);
382 		if (xfsread(ino, p, hdr.ex.a_data))
383 			return;
384 		p += hdr.ex.a_data + roundup2(hdr.ex.a_bss, PAGE_SIZE);
385 		bootinfo.bi_symtab = VTOP(p);
386 		memcpy(p, &hdr.ex.a_syms, sizeof (hdr.ex.a_syms));
387 		p += sizeof (hdr.ex.a_syms);
388 		if (hdr.ex.a_syms) {
389 			if (xfsread(ino, p, hdr.ex.a_syms))
390 				return;
391 			p += hdr.ex.a_syms;
392 			if (xfsread(ino, p, sizeof (int)))
393 				return;
394 			x = *(uint32_t *)p;
395 			p += sizeof (int);
396 			x -= sizeof (int);
397 			if (xfsread(ino, p, x))
398 				return;
399 			p += x;
400 		}
401 	} else {
402 		fs_off = hdr.eh.e_phoff;
403 		for (j = i = 0; i < hdr.eh.e_phnum && j < 2; i++) {
404 			if (xfsread(ino, ep + j, sizeof (ep[0])))
405 				return;
406 			if (ep[j].p_type == PT_LOAD)
407 				j++;
408 		}
409 		for (i = 0; i < 2; i++) {
410 			p = PTOV(ep[i].p_paddr & 0xffffff);
411 			fs_off = ep[i].p_offset;
412 			if (xfsread(ino, p, ep[i].p_filesz))
413 				return;
414 		}
415 		p += roundup2(ep[1].p_memsz, PAGE_SIZE);
416 		bootinfo.bi_symtab = VTOP(p);
417 		if (hdr.eh.e_shnum == hdr.eh.e_shstrndx + 3) {
418 			fs_off = hdr.eh.e_shoff + sizeof (es[0]) *
419 			    (hdr.eh.e_shstrndx + 1);
420 			if (xfsread(ino, &es, sizeof (es)))
421 				return;
422 			for (i = 0; i < 2; i++) {
423 				memcpy(p, &es[i].sh_size,
424 				    sizeof (es[i].sh_size));
425 				p += sizeof (es[i].sh_size);
426 				fs_off = es[i].sh_offset;
427 				if (xfsread(ino, p, es[i].sh_size))
428 					return;
429 				p += es[i].sh_size;
430 			}
431 		}
432 		addr = hdr.eh.e_entry & 0xffffff;
433 	}
434 	bootinfo.bi_esymtab = VTOP(p);
435 	bootinfo.bi_kernelname = VTOP(kname);
436 	bootinfo.bi_bios_dev = dsk.drive;
437 	__exec((caddr_t)addr, RB_BOOTINFO | (opts & RBX_MASK),
438 	    MAKEBOOTDEV(dev_maj[dsk.type], 0, dsk.unit, 0),
439 	    KARGS_FLAGS_EXTARG, 0, 0, VTOP(&bootinfo));
440 }
441 
442 static int
parse_cmds(char * cmdstr,int * dskupdated)443 parse_cmds(char *cmdstr, int *dskupdated)
444 {
445 	char *arg;
446 	char *ep, *p, *q;
447 	const char *cp;
448 	unsigned int drv;
449 	int c, i, j;
450 
451 	arg = cmdstr;
452 	*dskupdated = 0;
453 	while ((c = *arg++)) {
454 		if (c == ' ' || c == '\t' || c == '\n')
455 			continue;
456 		for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++)
457 			;
458 		ep = p;
459 		if (*p)
460 			*p++ = 0;
461 		if (c == '-') {
462 			while ((c = *arg++)) {
463 				if (c == 'P') {
464 					if (*(uint8_t *)PTOV(0x496) & 0x10) {
465 						cp = "yes";
466 					} else {
467 						opts |= OPT_SET(RBX_DUAL) |
468 						    OPT_SET(RBX_SERIAL);
469 						cp = "no";
470 					}
471 					printf("Keyboard: %s\n", cp);
472 					continue;
473 				} else if (c == 'S') {
474 					j = 0;
475 					while ((unsigned int)(i = *arg++ - '0')
476 					    <= 9)
477 						j = j * 10 + i;
478 					if (j > 0 && i == -'0') {
479 						comspeed = j;
480 						break;
481 					}
482 					/*
483 					 * Fall through to error below
484 					 * ('S' not in optstr[]).
485 					 */
486 				}
487 				for (i = 0; c != optstr[i]; i++)
488 					if (i == NOPT - 1)
489 						return (-1);
490 				opts ^= OPT_SET(flags[i]);
491 			}
492 			ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) :
493 			    OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD;
494 			if (ioctrl & IO_SERIAL) {
495 				if (sio_init(115200 / comspeed) != 0)
496 					ioctrl &= ~IO_SERIAL;
497 			}
498 		} else {
499 			for (q = arg--; *q && *q != '('; q++)
500 				;
501 			if (*q) {
502 				drv = -1;
503 				if (arg[1] == ':') {
504 					drv = *arg - '0';
505 					if (drv > 9)
506 						return (-1);
507 					arg += 2;
508 				}
509 				if (q - arg != 2)
510 					return (-1);
511 				for (i = 0; arg[0] != dev_nm[i][0] ||
512 				    arg[1] != dev_nm[i][1]; i++)
513 					if (i == NDEV - 1)
514 						return (-1);
515 				dsk.type = i;
516 				arg += 3;
517 				dsk.unit = *arg - '0';
518 				if (arg[1] != 'p' || dsk.unit > 9)
519 					return (-1);
520 				arg += 2;
521 				dsk.part = *arg - '0';
522 				if (dsk.part < 1 || dsk.part > 9)
523 					return (-1);
524 				arg++;
525 				if (arg[0] != ')')
526 					return (-1);
527 				arg++;
528 				if (drv == (unsigned)-1)
529 					drv = dsk.unit;
530 				dsk.drive = (dsk.type <= TYPE_MAXHARD
531 				    ? DRV_HARD : 0) + drv;
532 				*dskupdated = 1;
533 			}
534 			if ((i = ep - arg)) {
535 				if ((size_t)i >= sizeof (kname))
536 					return (-1);
537 				memcpy(kname, arg, i + 1);
538 			}
539 		}
540 		arg = p;
541 	}
542 	return (0);
543 }
544