xref: /freebsd/stand/i386/loader/main.c (revision 058ac3e8063366dafa634d9107642e12b038bf09)
1 /*-
2  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
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 PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 /*
31  * MD bootstrap main() and assorted miscellaneous
32  * commands.
33  */
34 
35 #include <stand.h>
36 #include <stddef.h>
37 #include <string.h>
38 #include <machine/bootinfo.h>
39 #include <machine/cpufunc.h>
40 #include <machine/psl.h>
41 #include <sys/disk.h>
42 #include <sys/reboot.h>
43 #include <common/drv.h>
44 
45 #include "bootstrap.h"
46 #include "common/bootargs.h"
47 #include "libi386/libi386.h"
48 #include <smbios.h>
49 #include "btxv86.h"
50 
51 #ifdef LOADER_ZFS_SUPPORT
52 #include <sys/zfs_bootenv.h>
53 #include "libzfs.h"
54 #endif
55 
56 CTASSERT(sizeof(struct bootargs) == BOOTARGS_SIZE);
57 CTASSERT(offsetof(struct bootargs, bootinfo) == BA_BOOTINFO);
58 CTASSERT(offsetof(struct bootargs, bootflags) == BA_BOOTFLAGS);
59 CTASSERT(offsetof(struct bootinfo, bi_size) == BI_SIZE);
60 
61 /* Arguments passed in from the boot1/boot2 loader */
62 static struct bootargs *kargs;
63 
64 static uint32_t		initial_howto;
65 static uint32_t		initial_bootdev;
66 static struct bootinfo	*initial_bootinfo;
67 
68 struct arch_switch	archsw;		/* MI/MD interface boundary */
69 
70 static void		extract_currdev(void);
71 static int		isa_inb(int port);
72 static void		isa_outb(int port, int value);
73 void			exit(int code);
74 #ifdef LOADER_GELI_SUPPORT
75 #include "geliboot.h"
76 struct geli_boot_args	*gargs;
77 struct geli_boot_data	*gbdata;
78 #endif
79 #ifdef LOADER_ZFS_SUPPORT
80 struct zfs_boot_args	*zargs;
81 static void		i386_zfs_probe(void);
82 #endif
83 
84 /* XXX debugging */
85 extern char end[];
86 
87 static void *heap_top;
88 static void *heap_bottom;
89 
90 caddr_t
91 ptov(uintptr_t x)
92 {
93 	return (PTOV(x));
94 }
95 
96 int
97 main(void)
98 {
99 	/* Pick up arguments */
100 	kargs = (void *)__args;
101 	initial_howto = kargs->howto;
102 	initial_bootdev = kargs->bootdev;
103 	initial_bootinfo = kargs->bootinfo ?
104 	    (struct bootinfo *)PTOV(kargs->bootinfo) : NULL;
105 
106 	/* Initialize the v86 register set to a known-good state. */
107 	bzero(&v86, sizeof(v86));
108 	v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
109 
110 	/*
111 	 * Initialise the heap as early as possible.
112 	 * Once this is done, malloc() is usable.
113 	 */
114 	bios_getmem();
115 
116 #if defined(LOADER_BZIP2_SUPPORT) || \
117     defined(LOADER_GPT_SUPPORT) || defined(LOADER_ZFS_SUPPORT)
118 	if (high_heap_size > 0) {
119 		heap_top = PTOV(high_heap_base + high_heap_size);
120 		heap_bottom = PTOV(high_heap_base);
121 		if (high_heap_base < memtop_copyin)
122 			memtop_copyin = high_heap_base;
123 	} else
124 #endif
125 	{
126 		heap_top = (void *)PTOV(bios_basemem);
127 		heap_bottom = (void *)end;
128 	}
129 	setheap(heap_bottom, heap_top);
130 
131 	/*
132 	 * Now that malloc is usable, allocate a buffer for tslog and start
133 	 * logging timestamps during the boot process.
134 	 */
135 	tslog_init();
136 
137 	/*
138 	 * detect ACPI for future reference. This may set console to comconsole
139 	 * if we do have ACPI SPCR table.
140 	 */
141 	biosacpi_detect();
142 
143 	/*
144 	 * XXX Chicken-and-egg problem; we want to have console output early,
145 	 * but some console attributes may depend on reading from eg. the boot
146 	 * device, which we can't do yet.
147 	 *
148 	 * We can use printf() etc. once this is done.
149 	 * If the previous boot stage has requested a serial console,
150 	 * prefer that.
151 	 */
152 	bi_setboothowto(initial_howto);
153 	if (initial_howto & RB_MULTIPLE) {
154 		if (initial_howto & RB_SERIAL)
155 			setenv("console", "comconsole vidconsole", 1);
156 		else
157 			setenv("console", "vidconsole comconsole", 1);
158 	} else if (initial_howto & RB_SERIAL) {
159 		setenv("console", "comconsole", 1);
160 	} else if (initial_howto & RB_MUTE) {
161 		setenv("console", "nullconsole", 1);
162 	}
163 	cons_probe();
164 
165 	/* Set up currdev variable to have hooks in place. */
166 	env_setenv("currdev", EV_VOLATILE | EV_NOHOOK, "",
167 	    i386_setcurrdev, env_nounset);
168 
169 	/*
170 	 * Initialise the block cache. Set the upper limit.
171 	 */
172 	bcache_init(32768, 512);
173 
174 	/*
175 	 * Special handling for PXE and CD booting.
176 	 */
177 	if (kargs->bootinfo == 0) {
178 		/*
179 		 * We only want the PXE disk to try to init itself in the below
180 		 * walk through devsw if we actually booted off of PXE.
181 		 */
182 		if (kargs->bootflags & KARGS_FLAGS_PXE)
183 			pxe_enable(kargs->pxeinfo ?
184 			    PTOV(kargs->pxeinfo) : NULL);
185 		else if (kargs->bootflags & KARGS_FLAGS_CD)
186 			bc_add(initial_bootdev);
187 	}
188 
189 	archsw.arch_autoload = i386_autoload;
190 	archsw.arch_getdev = i386_getdev;
191 	archsw.arch_copyin = i386_copyin;
192 	archsw.arch_copyout = i386_copyout;
193 	archsw.arch_readin = i386_readin;
194 	archsw.arch_isainb = isa_inb;
195 	archsw.arch_isaoutb = isa_outb;
196 	archsw.arch_hypervisor = x86_hypervisor;
197 #ifdef LOADER_ZFS_SUPPORT
198 	archsw.arch_zfs_probe = i386_zfs_probe;
199 
200 	/*
201 	 * zfsboot and gptzfsboot have always passed KARGS_FLAGS_ZFS,
202 	 * so if that is set along with KARGS_FLAGS_EXTARG we know we
203 	 * can interpret the extarg data as a struct zfs_boot_args.
204 	 */
205 #define	KARGS_EXTARGS_ZFS	(KARGS_FLAGS_EXTARG | KARGS_FLAGS_ZFS)
206 
207 	if ((kargs->bootflags & KARGS_EXTARGS_ZFS) == KARGS_EXTARGS_ZFS) {
208 		zargs = (struct zfs_boot_args *)(kargs + 1);
209 	}
210 #endif /* LOADER_ZFS_SUPPORT */
211 
212 #ifdef LOADER_GELI_SUPPORT
213 	/*
214 	 * If we decided earlier that we have zfs_boot_args extarg data,
215 	 * and it is big enough to contain the embedded geli data
216 	 * (the early zfs_boot_args structs weren't), then init the gbdata
217 	 * pointer accordingly. If there is extarg data which isn't
218 	 * zfs_boot_args data, determine whether it is geli_boot_args data.
219 	 * Recent versions of gptboot set KARGS_FLAGS_GELI to indicate that.
220 	 * Earlier versions didn't, but we presume that's what we
221 	 * have if the extarg size exactly matches the size of the
222 	 * geli_boot_args struct during that pre-flag era.
223 	 */
224 #define	LEGACY_GELI_ARGS_SIZE	260	/* This can never change */
225 
226 #ifdef LOADER_ZFS_SUPPORT
227 	if (zargs != NULL) {
228 		if (zargs->size > offsetof(struct zfs_boot_args, gelidata)) {
229 			gbdata = &zargs->gelidata;
230 		}
231 	} else
232 #endif /* LOADER_ZFS_SUPPORT */
233 	if ((kargs->bootflags & KARGS_FLAGS_EXTARG) != 0) {
234 		gargs = (struct geli_boot_args *)(kargs + 1);
235 		if ((kargs->bootflags & KARGS_FLAGS_GELI) ||
236 		    gargs->size == LEGACY_GELI_ARGS_SIZE) {
237 			gbdata = &gargs->gelidata;
238 		}
239 	}
240 
241 	if (gbdata != NULL)
242 		import_geli_boot_data(gbdata);
243 #endif /* LOADER_GELI_SUPPORT */
244 
245 	devinit();
246 
247 	printf("BIOS %dkB/%dkB available memory\n", bios_basemem / 1024,
248 	    bios_extmem / 1024);
249 	if (initial_bootinfo != NULL) {
250 		initial_bootinfo->bi_basemem = bios_basemem / 1024;
251 		initial_bootinfo->bi_extmem = bios_extmem / 1024;
252 	}
253 
254 	/* detect SMBIOS for future reference */
255 	smbios_detect(NULL);
256 
257 	/* detect PCI BIOS for future reference */
258 	biospci_detect();
259 
260 	printf("\n%s", bootprog_info);
261 
262 	extract_currdev();		/* set $currdev and $loaddev */
263 	autoload_font(true);
264 
265 	bios_getsmap();
266 
267 	interact();
268 
269 	/* if we ever get here, it is an error */
270 	return (1);
271 }
272 
273 /*
274  * Set the 'current device' by (if possible) recovering the boot device as
275  * supplied by the initial bootstrap.
276  *
277  * XXX should be extended for netbooting.
278  */
279 static void
280 extract_currdev(void)
281 {
282 	struct i386_devdesc	new_currdev;
283 #ifdef LOADER_ZFS_SUPPORT
284 	char			buf[20];
285 	char			*bootonce;
286 #endif
287 	int			biosdev = -1;
288 
289 	/* Assume we are booting from a BIOS disk by default */
290 	new_currdev.dd.d_dev = &bioshd;
291 
292 	/* new-style boot loaders such as pxeldr and cdldr */
293 	if (kargs->bootinfo == 0) {
294 		if ((kargs->bootflags & KARGS_FLAGS_CD) != 0) {
295 			/* we are booting from a CD with cdboot */
296 			new_currdev.dd.d_dev = &bioscd;
297 			new_currdev.dd.d_unit = bd_bios2unit(initial_bootdev);
298 		} else if ((kargs->bootflags & KARGS_FLAGS_PXE) != 0) {
299 			/* we are booting from pxeldr */
300 			new_currdev.dd.d_dev = &pxedisk;
301 			new_currdev.dd.d_unit = 0;
302 		} else {
303 			/* we don't know what our boot device is */
304 			new_currdev.disk.d_slice = -1;
305 			new_currdev.disk.d_partition = 0;
306 			biosdev = -1;
307 		}
308 #ifdef LOADER_ZFS_SUPPORT
309 	} else if ((kargs->bootflags & KARGS_FLAGS_ZFS) != 0) {
310 		/*
311 		 * zargs was set in main() if we have new style extended
312 		 * argument
313 		 */
314 		if (zargs != NULL &&
315 		    zargs->size >=
316 		    offsetof(struct zfs_boot_args, primary_pool)) {
317 			/* sufficient data is provided */
318 			new_currdev.zfs.pool_guid = zargs->pool;
319 			new_currdev.zfs.root_guid = zargs->root;
320 			if (zargs->size >= sizeof(*zargs) &&
321 			    zargs->primary_vdev != 0) {
322 				sprintf(buf, "%llu", zargs->primary_pool);
323 				setenv("vfs.zfs.boot.primary_pool", buf, 1);
324 				sprintf(buf, "%llu", zargs->primary_vdev);
325 				setenv("vfs.zfs.boot.primary_vdev", buf, 1);
326 			}
327 		} else {
328 			/* old style zfsboot block */
329 			new_currdev.zfs.pool_guid = kargs->zfspool;
330 			new_currdev.zfs.root_guid = 0;
331 		}
332 		new_currdev.dd.d_dev = &zfs_dev;
333 
334 		if ((bootonce = malloc(VDEV_PAD_SIZE)) != NULL) {
335 			if (zfs_get_bootonce(&new_currdev, OS_BOOTONCE_USED,
336 			    bootonce, VDEV_PAD_SIZE) == 0) {
337 				setenv("zfs-bootonce", bootonce, 1);
338 			}
339 			free(bootonce);
340 			(void) zfs_attach_nvstore(&new_currdev);
341 		}
342 
343 #endif
344 	} else if ((initial_bootdev & B_MAGICMASK) != B_DEVMAGIC) {
345 		/* The passed-in boot device is bad */
346 		new_currdev.disk.d_slice = -1;
347 		new_currdev.disk.d_partition = 0;
348 		biosdev = -1;
349 	} else {
350 		new_currdev.disk.d_slice = B_SLICE(initial_bootdev) - 1;
351 		new_currdev.disk.d_partition = B_PARTITION(initial_bootdev);
352 		biosdev = initial_bootinfo->bi_bios_dev;
353 
354 		/*
355 		 * If we are booted by an old bootstrap, we have to guess at
356 		 * the BIOS unit number. We will lose if there is more than
357 		 * one disk type and we are not booting from the
358 		 * lowest-numbered disk type (ie. SCSI when IDE also exists).
359 		 */
360 		if ((biosdev == 0) && (B_TYPE(initial_bootdev) != 2)) {
361 			/*
362 			 * biosdev doesn't match major, assume harddisk
363 			 */
364 			biosdev = 0x80 + B_UNIT(initial_bootdev);
365 		}
366 	}
367 
368 	/*
369 	 * If we are booting off of a BIOS disk and we didn't succeed
370 	 * in determining which one we booted off of, just use disk0:
371 	 * as a reasonable default.
372 	 */
373 	if ((new_currdev.dd.d_dev->dv_type == bioshd.dv_type) &&
374 	    ((new_currdev.dd.d_unit = bd_bios2unit(biosdev)) == -1)) {
375 		printf("Can't work out which disk we are booting "
376 		    "from.\nGuessed BIOS device 0x%x not found by "
377 		    "probes, defaulting to disk0:\n", biosdev);
378 		new_currdev.dd.d_unit = 0;
379 	}
380 
381 #ifdef LOADER_ZFS_SUPPORT
382 	if (new_currdev.dd.d_dev->dv_type == DEVT_ZFS)
383 		init_zfs_boot_options(devformat(&new_currdev.dd));
384 #endif
385 
386 	env_setenv("currdev", EV_VOLATILE, devformat(&new_currdev.dd),
387 	    i386_setcurrdev, env_nounset);
388 	env_setenv("loaddev", EV_VOLATILE, devformat(&new_currdev.dd),
389 	    env_noset, env_nounset);
390 }
391 
392 COMMAND_SET(reboot, "reboot", "reboot the system", command_reboot);
393 
394 static int
395 command_reboot(int argc, char *argv[])
396 {
397 	int i;
398 
399 	for (i = 0; devsw[i] != NULL; ++i)
400 		if (devsw[i]->dv_cleanup != NULL)
401 			(devsw[i]->dv_cleanup)();
402 
403 	printf("Rebooting...\n");
404 	delay(1000000);
405 	__exit(0);
406 }
407 
408 /* provide this for panic, as it's not in the startup code */
409 void
410 exit(int code)
411 {
412 	__exit(code);
413 }
414 
415 COMMAND_SET(heap, "heap", "show heap usage", command_heap);
416 
417 static int
418 command_heap(int argc, char *argv[])
419 {
420 	mallocstats();
421 	printf("heap base at %p, top at %p, upper limit at %p\n", heap_bottom,
422 	    sbrk(0), heap_top);
423 	return (CMD_OK);
424 }
425 
426 /* ISA bus access functions for PnP. */
427 static int
428 isa_inb(int port)
429 {
430 
431 	return (inb(port));
432 }
433 
434 static void
435 isa_outb(int port, int value)
436 {
437 
438 	outb(port, value);
439 }
440 
441 #ifdef LOADER_ZFS_SUPPORT
442 static void
443 i386_zfs_probe(void)
444 {
445 	char devname[32];
446 	struct i386_devdesc dev;
447 
448 	/*
449 	 * Open all the disks we can find and see if we can reconstruct
450 	 * ZFS pools from them.
451 	 */
452 	dev.dd.d_dev = &bioshd;
453 	for (dev.dd.d_unit = 0; bd_unit2bios(&dev) >= 0; dev.dd.d_unit++) {
454 		snprintf(devname, sizeof(devname), "%s%d:", bioshd.dv_name,
455 		    dev.dd.d_unit);
456 		zfs_probe_dev(devname, NULL);
457 	}
458 }
459 #endif
460