xref: /titanic_51/usr/src/uts/i86pc/os/fakebop.c (revision 791a814c934fcd4deb13b26c1f116ff283272a0d)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * This file contains the functionality that mimics the boot operations
29  * on SPARC systems or the old boot.bin/multiboot programs on x86 systems.
30  * The x86 kernel now does everything on its own.
31  */
32 
33 #include <sys/types.h>
34 #include <sys/bootconf.h>
35 #include <sys/bootsvcs.h>
36 #include <sys/bootinfo.h>
37 #include <sys/multiboot.h>
38 #include <sys/bootvfs.h>
39 #include <sys/bootprops.h>
40 #include <sys/varargs.h>
41 #include <sys/param.h>
42 #include <sys/machparam.h>
43 #include <sys/archsystm.h>
44 #include <sys/boot_console.h>
45 #include <sys/cmn_err.h>
46 #include <sys/systm.h>
47 #include <sys/promif.h>
48 #include <sys/archsystm.h>
49 #include <sys/x86_archext.h>
50 #include <sys/kobj.h>
51 #include <sys/privregs.h>
52 #include <sys/sysmacros.h>
53 #include <sys/ctype.h>
54 #include <sys/fastboot.h>
55 #ifdef __xpv
56 #include <sys/hypervisor.h>
57 #include <net/if.h>
58 #endif
59 #include <vm/kboot_mmu.h>
60 #include <vm/hat_pte.h>
61 #include <sys/dmar_acpi.h>
62 #include <sys/kobj.h>
63 #include <sys/kobj_lex.h>
64 #include "acpi_fw.h"
65 
66 static int have_console = 0;	/* set once primitive console is initialized */
67 static char *boot_args = "";
68 
69 /*
70  * Debugging macros
71  */
72 static uint_t kbm_debug = 0;
73 #define	DBG_MSG(s)	{ if (kbm_debug) bop_printf(NULL, "%s", s); }
74 #define	DBG(x)		{ if (kbm_debug)			\
75 	bop_printf(NULL, "%s is %" PRIx64 "\n", #x, (uint64_t)(x));	\
76 	}
77 
78 #define	PUT_STRING(s) {				\
79 	char *cp;				\
80 	for (cp = (s); *cp; ++cp)		\
81 		bcons_putchar(*cp);		\
82 	}
83 
84 struct xboot_info *xbootp;	/* boot info from "glue" code in low memory */
85 bootops_t bootop;	/* simple bootops we'll pass on to kernel */
86 struct bsys_mem bm;
87 
88 static uintptr_t next_virt;	/* next available virtual address */
89 static paddr_t next_phys;	/* next available physical address from dboot */
90 static paddr_t high_phys = -(paddr_t)1;	/* last used physical address */
91 
92 /*
93  * buffer for vsnprintf for console I/O
94  */
95 #define	BUFFERSIZE	256
96 static char buffer[BUFFERSIZE];
97 /*
98  * stuff to store/report/manipulate boot property settings.
99  */
100 typedef struct bootprop {
101 	struct bootprop *bp_next;
102 	char *bp_name;
103 	uint_t bp_vlen;
104 	char *bp_value;
105 } bootprop_t;
106 
107 static bootprop_t *bprops = NULL;
108 static char *curr_page = NULL;		/* ptr to avail bprop memory */
109 static int curr_space = 0;		/* amount of memory at curr_page */
110 
111 #ifdef __xpv
112 start_info_t *xen_info;
113 shared_info_t *HYPERVISOR_shared_info;
114 #endif
115 
116 /*
117  * some allocator statistics
118  */
119 static ulong_t total_bop_alloc_scratch = 0;
120 static ulong_t total_bop_alloc_kernel = 0;
121 
122 static void build_firmware_properties(void);
123 
124 static int early_allocation = 1;
125 
126 int force_fastreboot = 0;
127 int fastreboot_onpanic = 0;
128 int post_fastreboot = 0;
129 #ifdef	__xpv
130 int fastreboot_capable = 0;
131 #else
132 int fastreboot_capable = 1;
133 #endif
134 
135 /*
136  * Information saved from current boot for fast reboot.
137  * If the information size exceeds what we have allocated, fast reboot
138  * will not be supported.
139  */
140 multiboot_info_t saved_mbi;
141 mb_memory_map_t saved_mmap[FASTBOOT_SAVED_MMAP_COUNT];
142 struct sol_netinfo saved_drives[FASTBOOT_SAVED_DRIVES_COUNT];
143 char saved_cmdline[FASTBOOT_SAVED_CMDLINE_LEN];
144 int saved_cmdline_len = 0;
145 size_t saved_file_size[FASTBOOT_MAX_FILES_MAP];
146 
147 /*
148  * Turn off fastreboot_onpanic to avoid panic loop.
149  */
150 char fastreboot_onpanic_cmdline[FASTBOOT_SAVED_CMDLINE_LEN];
151 static const char fastreboot_onpanic_args[] = " -B fastreboot_onpanic=0";
152 
153 /*
154  * Pointers to where System Resource Affinity Table (SRAT) and
155  * System Locality Information Table (SLIT) are mapped into virtual memory
156  */
157 struct srat	*srat_ptr = NULL;
158 struct slit	*slit_ptr = NULL;
159 
160 
161 /*
162  * Allocate aligned physical memory at boot time. This allocator allocates
163  * from the highest possible addresses. This avoids exhausting memory that
164  * would be useful for DMA buffers.
165  */
166 paddr_t
167 do_bop_phys_alloc(uint64_t size, uint64_t align)
168 {
169 	paddr_t	pa = 0;
170 	paddr_t	start;
171 	paddr_t	end;
172 	struct memlist	*ml = (struct memlist *)xbootp->bi_phys_install;
173 
174 	/*
175 	 * Be careful if high memory usage is limited in startup.c
176 	 * Since there are holes in the low part of the physical address
177 	 * space we can treat physmem as a pfn (not just a pgcnt) and
178 	 * get a conservative upper limit.
179 	 */
180 	if (physmem != 0 && high_phys > pfn_to_pa(physmem))
181 		high_phys = pfn_to_pa(physmem);
182 
183 	/*
184 	 * find the lowest or highest available memory in physinstalled
185 	 * On 32 bit avoid physmem above 4Gig if PAE isn't enabled
186 	 */
187 #if defined(__i386)
188 	if (xbootp->bi_use_pae == 0 && high_phys > FOUR_GIG)
189 		high_phys = FOUR_GIG;
190 #endif
191 
192 	/*
193 	 * find the highest available memory in physinstalled
194 	 */
195 	size = P2ROUNDUP(size, align);
196 	for (; ml; ml = ml->next) {
197 		start = P2ROUNDUP(ml->address, align);
198 		end = P2ALIGN(ml->address + ml->size, align);
199 		if (start < next_phys)
200 			start = P2ROUNDUP(next_phys, align);
201 		if (end > high_phys)
202 			end = P2ALIGN(high_phys, align);
203 
204 		if (end <= start)
205 			continue;
206 		if (end - start < size)
207 			continue;
208 
209 		/*
210 		 * Early allocations need to use low memory, since
211 		 * physmem might be further limited by bootenv.rc
212 		 */
213 		if (early_allocation) {
214 			if (pa == 0 || start < pa)
215 				pa = start;
216 		} else {
217 			if (end - size > pa)
218 				pa = end - size;
219 		}
220 	}
221 	if (pa != 0) {
222 		if (early_allocation)
223 			next_phys = pa + size;
224 		else
225 			high_phys = pa;
226 		return (pa);
227 	}
228 	bop_panic("do_bop_phys_alloc(0x%" PRIx64 ", 0x%" PRIx64
229 	    ") Out of memory\n", size, align);
230 	/*NOTREACHED*/
231 }
232 
233 static uintptr_t
234 alloc_vaddr(size_t size, paddr_t align)
235 {
236 	uintptr_t rv;
237 
238 	next_virt = P2ROUNDUP(next_virt, (uintptr_t)align);
239 	rv = (uintptr_t)next_virt;
240 	next_virt += size;
241 	return (rv);
242 }
243 
244 /*
245  * Allocate virtual memory. The size is always rounded up to a multiple
246  * of base pagesize.
247  */
248 
249 /*ARGSUSED*/
250 static caddr_t
251 do_bsys_alloc(bootops_t *bop, caddr_t virthint, size_t size, int align)
252 {
253 	paddr_t a = align;	/* same type as pa for masking */
254 	uint_t pgsize;
255 	paddr_t pa;
256 	uintptr_t va;
257 	ssize_t s;		/* the aligned size */
258 	uint_t level;
259 	uint_t is_kernel = (virthint != 0);
260 
261 	if (a < MMU_PAGESIZE)
262 		a = MMU_PAGESIZE;
263 	else if (!ISP2(a))
264 		prom_panic("do_bsys_alloc() incorrect alignment");
265 	size = P2ROUNDUP(size, MMU_PAGESIZE);
266 
267 	/*
268 	 * Use the next aligned virtual address if we weren't given one.
269 	 */
270 	if (virthint == NULL) {
271 		virthint = (caddr_t)alloc_vaddr(size, a);
272 		total_bop_alloc_scratch += size;
273 	} else {
274 		total_bop_alloc_kernel += size;
275 	}
276 
277 	/*
278 	 * allocate the physical memory
279 	 */
280 	pa = do_bop_phys_alloc(size, a);
281 
282 	/*
283 	 * Add the mappings to the page tables, try large pages first.
284 	 */
285 	va = (uintptr_t)virthint;
286 	s = size;
287 	level = 1;
288 	pgsize = xbootp->bi_use_pae ? TWO_MEG : FOUR_MEG;
289 	if (xbootp->bi_use_largepage && a == pgsize) {
290 		while (IS_P2ALIGNED(pa, pgsize) && IS_P2ALIGNED(va, pgsize) &&
291 		    s >= pgsize) {
292 			kbm_map(va, pa, level, is_kernel);
293 			va += pgsize;
294 			pa += pgsize;
295 			s -= pgsize;
296 		}
297 	}
298 
299 	/*
300 	 * Map remaining pages use small mappings
301 	 */
302 	level = 0;
303 	pgsize = MMU_PAGESIZE;
304 	while (s > 0) {
305 		kbm_map(va, pa, level, is_kernel);
306 		va += pgsize;
307 		pa += pgsize;
308 		s -= pgsize;
309 	}
310 	return (virthint);
311 }
312 
313 /*
314  * Free virtual memory - we'll just ignore these.
315  */
316 /*ARGSUSED*/
317 static void
318 do_bsys_free(bootops_t *bop, caddr_t virt, size_t size)
319 {
320 	bop_printf(NULL, "do_bsys_free(virt=0x%p, size=0x%lx) ignored\n",
321 	    (void *)virt, size);
322 }
323 
324 /*
325  * Old interface
326  */
327 /*ARGSUSED*/
328 static caddr_t
329 do_bsys_ealloc(
330 	bootops_t *bop,
331 	caddr_t virthint,
332 	size_t size,
333 	int align,
334 	int flags)
335 {
336 	prom_panic("unsupported call to BOP_EALLOC()\n");
337 	return (0);
338 }
339 
340 
341 static void
342 bsetprop(char *name, int nlen, void *value, int vlen)
343 {
344 	uint_t size;
345 	uint_t need_size;
346 	bootprop_t *b;
347 
348 	/*
349 	 * align the size to 16 byte boundary
350 	 */
351 	size = sizeof (bootprop_t) + nlen + 1 + vlen;
352 	size = (size + 0xf) & ~0xf;
353 	if (size > curr_space) {
354 		need_size = (size + (MMU_PAGEOFFSET)) & MMU_PAGEMASK;
355 		curr_page = do_bsys_alloc(NULL, 0, need_size, MMU_PAGESIZE);
356 		curr_space = need_size;
357 	}
358 
359 	/*
360 	 * use a bootprop_t at curr_page and link into list
361 	 */
362 	b = (bootprop_t *)curr_page;
363 	curr_page += sizeof (bootprop_t);
364 	curr_space -=  sizeof (bootprop_t);
365 	b->bp_next = bprops;
366 	bprops = b;
367 
368 	/*
369 	 * follow by name and ending zero byte
370 	 */
371 	b->bp_name = curr_page;
372 	bcopy(name, curr_page, nlen);
373 	curr_page += nlen;
374 	*curr_page++ = 0;
375 	curr_space -= nlen + 1;
376 
377 	/*
378 	 * copy in value, but no ending zero byte
379 	 */
380 	b->bp_value = curr_page;
381 	b->bp_vlen = vlen;
382 	if (vlen > 0) {
383 		bcopy(value, curr_page, vlen);
384 		curr_page += vlen;
385 		curr_space -= vlen;
386 	}
387 
388 	/*
389 	 * align new values of curr_page, curr_space
390 	 */
391 	while (curr_space & 0xf) {
392 		++curr_page;
393 		--curr_space;
394 	}
395 }
396 
397 static void
398 bsetprops(char *name, char *value)
399 {
400 	bsetprop(name, strlen(name), value, strlen(value) + 1);
401 }
402 
403 static void
404 bsetprop64(char *name, uint64_t value)
405 {
406 	bsetprop(name, strlen(name), (void *)&value, sizeof (value));
407 }
408 
409 static void
410 bsetpropsi(char *name, int value)
411 {
412 	char prop_val[32];
413 
414 	(void) snprintf(prop_val, sizeof (prop_val), "%d", value);
415 	bsetprops(name, prop_val);
416 }
417 
418 /*
419  * to find the size of the buffer to allocate
420  */
421 /*ARGSUSED*/
422 int
423 do_bsys_getproplen(bootops_t *bop, const char *name)
424 {
425 	bootprop_t *b;
426 
427 	for (b = bprops; b; b = b->bp_next) {
428 		if (strcmp(name, b->bp_name) != 0)
429 			continue;
430 		return (b->bp_vlen);
431 	}
432 	return (-1);
433 }
434 
435 /*
436  * get the value associated with this name
437  */
438 /*ARGSUSED*/
439 int
440 do_bsys_getprop(bootops_t *bop, const char *name, void *value)
441 {
442 	bootprop_t *b;
443 
444 	for (b = bprops; b; b = b->bp_next) {
445 		if (strcmp(name, b->bp_name) != 0)
446 			continue;
447 		bcopy(b->bp_value, value, b->bp_vlen);
448 		return (0);
449 	}
450 	return (-1);
451 }
452 
453 /*
454  * get the name of the next property in succession from the standalone
455  */
456 /*ARGSUSED*/
457 static char *
458 do_bsys_nextprop(bootops_t *bop, char *name)
459 {
460 	bootprop_t *b;
461 
462 	/*
463 	 * A null name is a special signal for the 1st boot property
464 	 */
465 	if (name == NULL || strlen(name) == 0) {
466 		if (bprops == NULL)
467 			return (NULL);
468 		return (bprops->bp_name);
469 	}
470 
471 	for (b = bprops; b; b = b->bp_next) {
472 		if (name != b->bp_name)
473 			continue;
474 		b = b->bp_next;
475 		if (b == NULL)
476 			return (NULL);
477 		return (b->bp_name);
478 	}
479 	return (NULL);
480 }
481 
482 /*
483  * Parse numeric value from a string. Understands decimal, hex, octal, - and ~
484  */
485 static int
486 parse_value(char *p, uint64_t *retval)
487 {
488 	int adjust = 0;
489 	uint64_t tmp = 0;
490 	int digit;
491 	int radix = 10;
492 
493 	*retval = 0;
494 	if (*p == '-' || *p == '~')
495 		adjust = *p++;
496 
497 	if (*p == '0') {
498 		++p;
499 		if (*p == 0)
500 			return (0);
501 		if (*p == 'x' || *p == 'X') {
502 			radix = 16;
503 			++p;
504 		} else {
505 			radix = 8;
506 			++p;
507 		}
508 	}
509 	while (*p) {
510 		if ('0' <= *p && *p <= '9')
511 			digit = *p - '0';
512 		else if ('a' <= *p && *p <= 'f')
513 			digit = 10 + *p - 'a';
514 		else if ('A' <= *p && *p <= 'F')
515 			digit = 10 + *p - 'A';
516 		else
517 			return (-1);
518 		if (digit >= radix)
519 			return (-1);
520 		tmp = tmp * radix + digit;
521 		++p;
522 	}
523 	if (adjust == '-')
524 		tmp = -tmp;
525 	else if (adjust == '~')
526 		tmp = ~tmp;
527 	*retval = tmp;
528 	return (0);
529 }
530 
531 /*
532  * 2nd part of building the table of boot properties. This includes:
533  * - values from /boot/solaris/bootenv.rc (ie. eeprom(1m) values)
534  *
535  * lines look like one of:
536  * ^$
537  * ^# comment till end of line
538  * setprop name 'value'
539  * setprop name value
540  * setprop name "value"
541  *
542  * we do single character I/O since this is really just looking at memory
543  */
544 void
545 boot_prop_finish(void)
546 {
547 	int fd;
548 	char *line;
549 	int c;
550 	int bytes_read;
551 	char *name;
552 	int n_len;
553 	char *value;
554 	int v_len;
555 	char *inputdev;	/* these override the command line if serial ports */
556 	char *outputdev;
557 	char *consoledev;
558 	uint64_t lvalue;
559 	int use_xencons = 0;
560 
561 #ifdef __xpv
562 	if (!DOMAIN_IS_INITDOMAIN(xen_info))
563 		use_xencons = 1;
564 #endif /* __xpv */
565 
566 	DBG_MSG("Opening /boot/solaris/bootenv.rc\n");
567 	fd = BRD_OPEN(bfs_ops, "/boot/solaris/bootenv.rc", 0);
568 	DBG(fd);
569 
570 	line = do_bsys_alloc(NULL, NULL, MMU_PAGESIZE, MMU_PAGESIZE);
571 	while (fd >= 0) {
572 
573 		/*
574 		 * get a line
575 		 */
576 		for (c = 0; ; ++c) {
577 			bytes_read = BRD_READ(bfs_ops, fd, line + c, 1);
578 			if (bytes_read == 0) {
579 				if (c == 0)
580 					goto done;
581 				break;
582 			}
583 			if (line[c] == '\n')
584 				break;
585 		}
586 		line[c] = 0;
587 
588 		/*
589 		 * ignore comment lines
590 		 */
591 		c = 0;
592 		while (ISSPACE(line[c]))
593 			++c;
594 		if (line[c] == '#' || line[c] == 0)
595 			continue;
596 
597 		/*
598 		 * must have "setprop " or "setprop\t"
599 		 */
600 		if (strncmp(line + c, "setprop ", 8) != 0 &&
601 		    strncmp(line + c, "setprop\t", 8) != 0)
602 			continue;
603 		c += 8;
604 		while (ISSPACE(line[c]))
605 			++c;
606 		if (line[c] == 0)
607 			continue;
608 
609 		/*
610 		 * gather up the property name
611 		 */
612 		name = line + c;
613 		n_len = 0;
614 		while (line[c] && !ISSPACE(line[c]))
615 			++n_len, ++c;
616 
617 		/*
618 		 * gather up the value, if any
619 		 */
620 		value = "";
621 		v_len = 0;
622 		while (ISSPACE(line[c]))
623 			++c;
624 		if (line[c] != 0) {
625 			value = line + c;
626 			while (line[c] && !ISSPACE(line[c]))
627 				++v_len, ++c;
628 		}
629 
630 		if (v_len >= 2 && value[0] == value[v_len - 1] &&
631 		    (value[0] == '\'' || value[0] == '"')) {
632 			++value;
633 			v_len -= 2;
634 		}
635 		name[n_len] = 0;
636 		if (v_len > 0)
637 			value[v_len] = 0;
638 		else
639 			continue;
640 
641 		/*
642 		 * ignore "boot-file" property, it's now meaningless
643 		 */
644 		if (strcmp(name, "boot-file") == 0)
645 			continue;
646 		if (strcmp(name, "boot-args") == 0 &&
647 		    strlen(boot_args) > 0)
648 			continue;
649 
650 		/*
651 		 * If a property was explicitly set on the command line
652 		 * it will override a setting in bootenv.rc
653 		 */
654 		if (do_bsys_getproplen(NULL, name) > 0)
655 			continue;
656 
657 		bsetprop(name, n_len, value, v_len + 1);
658 	}
659 done:
660 	if (fd >= 0)
661 		BRD_CLOSE(bfs_ops, fd);
662 
663 	/*
664 	 * Check if we have to limit the boot time allocator
665 	 */
666 	if (do_bsys_getproplen(NULL, "physmem") != -1 &&
667 	    do_bsys_getprop(NULL, "physmem", line) >= 0 &&
668 	    parse_value(line, &lvalue) != -1) {
669 		if (0 < lvalue && (lvalue < physmem || physmem == 0)) {
670 			physmem = (pgcnt_t)lvalue;
671 			DBG(physmem);
672 		}
673 	}
674 	early_allocation = 0;
675 
676 	/*
677 	 * check to see if we have to override the default value of the console
678 	 */
679 	if (!use_xencons) {
680 		inputdev = line;
681 		v_len = do_bsys_getproplen(NULL, "input-device");
682 		if (v_len > 0)
683 			(void) do_bsys_getprop(NULL, "input-device", inputdev);
684 		else
685 			v_len = 0;
686 		inputdev[v_len] = 0;
687 
688 		outputdev = inputdev + v_len + 1;
689 		v_len = do_bsys_getproplen(NULL, "output-device");
690 		if (v_len > 0)
691 			(void) do_bsys_getprop(NULL, "output-device",
692 			    outputdev);
693 		else
694 			v_len = 0;
695 		outputdev[v_len] = 0;
696 
697 		consoledev = outputdev + v_len + 1;
698 		v_len = do_bsys_getproplen(NULL, "console");
699 		if (v_len > 0)
700 			(void) do_bsys_getprop(NULL, "console", consoledev);
701 		else
702 			v_len = 0;
703 		consoledev[v_len] = 0;
704 		bcons_init2(inputdev, outputdev, consoledev);
705 	} else {
706 		/*
707 		 * Ensure console property exists
708 		 * If not create it as "hypervisor"
709 		 */
710 		v_len = do_bsys_getproplen(NULL, "console");
711 		if (v_len < 0)
712 			bsetprops("console", "hypervisor");
713 		inputdev = outputdev = consoledev = "hypervisor";
714 		bcons_init2(inputdev, outputdev, consoledev);
715 	}
716 
717 	if (strstr((char *)xbootp->bi_cmdline, "prom_debug") || kbm_debug) {
718 		value = line;
719 		bop_printf(NULL, "\nBoot properties:\n");
720 		name = "";
721 		while ((name = do_bsys_nextprop(NULL, name)) != NULL) {
722 			bop_printf(NULL, "\t0x%p %s = ", (void *)name, name);
723 			(void) do_bsys_getprop(NULL, name, value);
724 			v_len = do_bsys_getproplen(NULL, name);
725 			bop_printf(NULL, "len=%d ", v_len);
726 			value[v_len] = 0;
727 			bop_printf(NULL, "%s\n", value);
728 		}
729 	}
730 }
731 
732 /*
733  * print formatted output
734  */
735 /*PRINTFLIKE2*/
736 /*ARGSUSED*/
737 void
738 bop_printf(bootops_t *bop, const char *fmt, ...)
739 {
740 	va_list	ap;
741 
742 	if (have_console == 0)
743 		return;
744 
745 	va_start(ap, fmt);
746 	(void) vsnprintf(buffer, BUFFERSIZE, fmt, ap);
747 	va_end(ap);
748 	PUT_STRING(buffer);
749 }
750 
751 /*
752  * Another panic() variant; this one can be used even earlier during boot than
753  * prom_panic().
754  */
755 /*PRINTFLIKE1*/
756 void
757 bop_panic(const char *fmt, ...)
758 {
759 	va_list ap;
760 
761 	va_start(ap, fmt);
762 	bop_printf(NULL, fmt, ap);
763 	va_end(ap);
764 
765 	bop_printf(NULL, "\nPress any key to reboot.\n");
766 	(void) bcons_getchar();
767 	bop_printf(NULL, "Resetting...\n");
768 	pc_reset();
769 }
770 
771 /*
772  * Do a real mode interrupt BIOS call
773  */
774 typedef struct bios_regs {
775 	unsigned short ax, bx, cx, dx, si, di, bp, es, ds;
776 } bios_regs_t;
777 typedef int (*bios_func_t)(int, bios_regs_t *);
778 
779 /*ARGSUSED*/
780 static void
781 do_bsys_doint(bootops_t *bop, int intnum, struct bop_regs *rp)
782 {
783 #if defined(__xpv)
784 	prom_panic("unsupported call to BOP_DOINT()\n");
785 #else	/* __xpv */
786 	static int firsttime = 1;
787 	bios_func_t bios_func = (bios_func_t)(void *)(uintptr_t)0x5000;
788 	bios_regs_t br;
789 
790 	/*
791 	 * The first time we do this, we have to copy the pre-packaged
792 	 * low memory bios call code image into place.
793 	 */
794 	if (firsttime) {
795 		extern char bios_image[];
796 		extern uint32_t bios_size;
797 
798 		bcopy(bios_image, (void *)bios_func, bios_size);
799 		firsttime = 0;
800 	}
801 
802 	br.ax = rp->eax.word.ax;
803 	br.bx = rp->ebx.word.bx;
804 	br.cx = rp->ecx.word.cx;
805 	br.dx = rp->edx.word.dx;
806 	br.bp = rp->ebp.word.bp;
807 	br.si = rp->esi.word.si;
808 	br.di = rp->edi.word.di;
809 	br.ds = rp->ds;
810 	br.es = rp->es;
811 
812 	DBG_MSG("Doing BIOS call...");
813 	DBG(br.ax);
814 	DBG(br.bx);
815 	DBG(br.dx);
816 	rp->eflags = bios_func(intnum, &br);
817 	DBG_MSG("done\n");
818 
819 	rp->eax.word.ax = br.ax;
820 	rp->ebx.word.bx = br.bx;
821 	rp->ecx.word.cx = br.cx;
822 	rp->edx.word.dx = br.dx;
823 	rp->ebp.word.bp = br.bp;
824 	rp->esi.word.si = br.si;
825 	rp->edi.word.di = br.di;
826 	rp->ds = br.ds;
827 	rp->es = br.es;
828 #endif /* __xpv */
829 }
830 
831 static struct boot_syscalls bop_sysp = {
832 	bcons_getchar,
833 	bcons_putchar,
834 	bcons_ischar,
835 };
836 
837 static char *whoami;
838 
839 #define	BUFLEN	64
840 
841 #if defined(__xpv)
842 
843 static char namebuf[32];
844 
845 static void
846 xen_parse_props(char *s, char *prop_map[], int n_prop)
847 {
848 	char **prop_name = prop_map;
849 	char *cp = s, *scp;
850 
851 	do {
852 		scp = cp;
853 		while ((*cp != NULL) && (*cp != ':'))
854 			cp++;
855 
856 		if ((scp != cp) && (*prop_name != NULL)) {
857 			*cp = NULL;
858 			bsetprops(*prop_name, scp);
859 		}
860 
861 		cp++;
862 		prop_name++;
863 		n_prop--;
864 	} while (n_prop > 0);
865 }
866 
867 #define	VBDPATHLEN	64
868 
869 /*
870  * parse the 'xpv-root' property to create properties used by
871  * ufs_mountroot.
872  */
873 static void
874 xen_vbdroot_props(char *s)
875 {
876 	char vbdpath[VBDPATHLEN] = "/xpvd/xdf@";
877 	const char lnamefix[] = "/dev/dsk/c0d";
878 	char *pnp;
879 	char *prop_p;
880 	char mi;
881 	short minor;
882 	long addr = 0;
883 
884 	pnp = vbdpath + strlen(vbdpath);
885 	prop_p = s + strlen(lnamefix);
886 	while ((*prop_p != '\0') && (*prop_p != 's') && (*prop_p != 'p'))
887 		addr = addr * 10 + *prop_p++ - '0';
888 	(void) snprintf(pnp, VBDPATHLEN, "%lx", addr);
889 	pnp = vbdpath + strlen(vbdpath);
890 	if (*prop_p == 's')
891 		mi = 'a';
892 	else if (*prop_p == 'p')
893 		mi = 'q';
894 	else
895 		ASSERT(0); /* shouldn't be here */
896 	prop_p++;
897 	ASSERT(*prop_p != '\0');
898 	if (ISDIGIT(*prop_p)) {
899 		minor = *prop_p - '0';
900 		prop_p++;
901 		if (ISDIGIT(*prop_p)) {
902 			minor = minor * 10 + *prop_p - '0';
903 		}
904 	} else {
905 		/* malformed root path, use 0 as default */
906 		minor = 0;
907 	}
908 	ASSERT(minor < 16); /* at most 16 partitions */
909 	mi += minor;
910 	*pnp++ = ':';
911 	*pnp++ = mi;
912 	*pnp++ = '\0';
913 	bsetprops("fstype", "ufs");
914 	bsetprops("bootpath", vbdpath);
915 
916 	DBG_MSG("VBD bootpath set to ");
917 	DBG_MSG(vbdpath);
918 	DBG_MSG("\n");
919 }
920 
921 /*
922  * parse the xpv-nfsroot property to create properties used by
923  * nfs_mountroot.
924  */
925 static void
926 xen_nfsroot_props(char *s)
927 {
928 	char *prop_map[] = {
929 		BP_SERVER_IP,	/* server IP address */
930 		BP_SERVER_NAME,	/* server hostname */
931 		BP_SERVER_PATH,	/* root path */
932 	};
933 	int n_prop = sizeof (prop_map) / sizeof (prop_map[0]);
934 
935 	bsetprop("fstype", 6, "nfs", 4);
936 
937 	xen_parse_props(s, prop_map, n_prop);
938 
939 	/*
940 	 * If a server name wasn't specified, use a default.
941 	 */
942 	if (do_bsys_getproplen(NULL, BP_SERVER_NAME) == -1)
943 		bsetprops(BP_SERVER_NAME, "unknown");
944 }
945 
946 /*
947  * Extract our IP address, etc. from the "xpv-ip" property.
948  */
949 static void
950 xen_ip_props(char *s)
951 {
952 	char *prop_map[] = {
953 		BP_HOST_IP,		/* IP address */
954 		NULL,			/* NFS server IP address (ignored in */
955 					/* favour of xpv-nfsroot) */
956 		BP_ROUTER_IP,		/* IP gateway */
957 		BP_SUBNET_MASK,		/* IP subnet mask */
958 		"xpv-hostname",		/* hostname (ignored) */
959 		BP_NETWORK_INTERFACE,	/* interface name */
960 		"xpv-hcp",		/* host configuration protocol */
961 	};
962 	int n_prop = sizeof (prop_map) / sizeof (prop_map[0]);
963 	char ifname[IFNAMSIZ];
964 
965 	xen_parse_props(s, prop_map, n_prop);
966 
967 	/*
968 	 * A Linux dom0 administrator expects all interfaces to be
969 	 * called "ethX", which is not the case here.
970 	 *
971 	 * If the interface name specified is "eth0", presume that
972 	 * this is really intended to be "xnf0" (the first domU ->
973 	 * dom0 interface for this domain).
974 	 */
975 	if ((do_bsys_getprop(NULL, BP_NETWORK_INTERFACE, ifname) == 0) &&
976 	    (strcmp("eth0", ifname) == 0)) {
977 		bsetprops(BP_NETWORK_INTERFACE, "xnf0");
978 		bop_printf(NULL,
979 		    "network interface name 'eth0' replaced with 'xnf0'\n");
980 	}
981 }
982 
983 #else	/* __xpv */
984 
985 static void
986 setup_rarp_props(struct sol_netinfo *sip)
987 {
988 	char buf[BUFLEN];	/* to hold ip/mac addrs */
989 	uint8_t *val;
990 
991 	val = (uint8_t *)&sip->sn_ciaddr;
992 	(void) snprintf(buf, BUFLEN, "%d.%d.%d.%d",
993 	    val[0], val[1], val[2], val[3]);
994 	bsetprops(BP_HOST_IP, buf);
995 
996 	val = (uint8_t *)&sip->sn_siaddr;
997 	(void) snprintf(buf, BUFLEN, "%d.%d.%d.%d",
998 	    val[0], val[1], val[2], val[3]);
999 	bsetprops(BP_SERVER_IP, buf);
1000 
1001 	if (sip->sn_giaddr != 0) {
1002 		val = (uint8_t *)&sip->sn_giaddr;
1003 		(void) snprintf(buf, BUFLEN, "%d.%d.%d.%d",
1004 		    val[0], val[1], val[2], val[3]);
1005 		bsetprops(BP_ROUTER_IP, buf);
1006 	}
1007 
1008 	if (sip->sn_netmask != 0) {
1009 		val = (uint8_t *)&sip->sn_netmask;
1010 		(void) snprintf(buf, BUFLEN, "%d.%d.%d.%d",
1011 		    val[0], val[1], val[2], val[3]);
1012 		bsetprops(BP_SUBNET_MASK, buf);
1013 	}
1014 
1015 	if (sip->sn_mactype != 4 || sip->sn_maclen != 6) {
1016 		bop_printf(NULL, "unsupported mac type %d, mac len %d\n",
1017 		    sip->sn_mactype, sip->sn_maclen);
1018 	} else {
1019 		val = sip->sn_macaddr;
1020 		(void) snprintf(buf, BUFLEN, "%x:%x:%x:%x:%x:%x",
1021 		    val[0], val[1], val[2], val[3], val[4], val[5]);
1022 		bsetprops(BP_BOOT_MAC, buf);
1023 	}
1024 }
1025 
1026 #endif	/* __xpv */
1027 
1028 static void
1029 build_panic_cmdline(const char *cmd, int cmdlen)
1030 {
1031 	int proplen;
1032 	size_t arglen;
1033 
1034 	arglen = sizeof (fastreboot_onpanic_args);
1035 	/*
1036 	 * If we allready have fastreboot-onpanic set to zero,
1037 	 * don't add them again.
1038 	 */
1039 	if ((proplen = do_bsys_getproplen(NULL, FASTREBOOT_ONPANIC)) > 0 &&
1040 	    proplen <=  sizeof (fastreboot_onpanic_cmdline)) {
1041 		(void) do_bsys_getprop(NULL, FASTREBOOT_ONPANIC,
1042 		    fastreboot_onpanic_cmdline);
1043 		if (FASTREBOOT_ONPANIC_NOTSET(fastreboot_onpanic_cmdline))
1044 			arglen = 1;
1045 	}
1046 
1047 	/*
1048 	 * construct fastreboot_onpanic_cmdline
1049 	 */
1050 	if (cmdlen + arglen > sizeof (fastreboot_onpanic_cmdline)) {
1051 		DBG_MSG("Command line too long: clearing "
1052 		    FASTREBOOT_ONPANIC "\n");
1053 		fastreboot_onpanic = 0;
1054 	} else {
1055 		bcopy(cmd, fastreboot_onpanic_cmdline, cmdlen);
1056 		if (arglen != 1)
1057 			bcopy(fastreboot_onpanic_args,
1058 			    fastreboot_onpanic_cmdline + cmdlen, arglen);
1059 		else
1060 			fastreboot_onpanic_cmdline[cmdlen] = 0;
1061 	}
1062 }
1063 
1064 
1065 #ifndef	__xpv
1066 /*
1067  * Construct boot command line for Fast Reboot
1068  */
1069 static void
1070 build_fastboot_cmdline(void)
1071 {
1072 	saved_cmdline_len =  strlen(xbootp->bi_cmdline) + 1;
1073 	if (saved_cmdline_len > FASTBOOT_SAVED_CMDLINE_LEN) {
1074 		DBG(saved_cmdline_len);
1075 		DBG_MSG("Command line too long: clearing fastreboot_capable\n");
1076 		fastreboot_capable = 0;
1077 	} else {
1078 		bcopy((void *)(xbootp->bi_cmdline), (void *)saved_cmdline,
1079 		    saved_cmdline_len);
1080 		saved_cmdline[saved_cmdline_len - 1] = '\0';
1081 		build_panic_cmdline(saved_cmdline, saved_cmdline_len - 1);
1082 	}
1083 }
1084 
1085 /*
1086  * Save memory layout, disk drive information, unix and boot archive sizes for
1087  * Fast Reboot.
1088  */
1089 static void
1090 save_boot_info(multiboot_info_t *mbi, struct xboot_info *xbi)
1091 {
1092 	struct boot_modules *modp;
1093 	int i;
1094 
1095 	bcopy(mbi, &saved_mbi, sizeof (multiboot_info_t));
1096 	if (mbi->mmap_length > sizeof (saved_mmap)) {
1097 		DBG_MSG("mbi->mmap_length too big: clearing "
1098 		    "fastreboot_capable\n");
1099 		fastreboot_capable = 0;
1100 	} else {
1101 		bcopy((void *)(uintptr_t)mbi->mmap_addr, (void *)saved_mmap,
1102 		    mbi->mmap_length);
1103 	}
1104 
1105 	if (mbi->drives_length > sizeof (saved_drives)) {
1106 		DBG(mbi->drives_length);
1107 		DBG_MSG("mbi->drives_length too big: clearing "
1108 		    "fastreboot_capable\n");
1109 		fastreboot_capable = 0;
1110 	} else {
1111 		bcopy((void *)(uintptr_t)mbi->drives_addr, (void *)saved_drives,
1112 		    mbi->drives_length);
1113 	}
1114 
1115 	/*
1116 	 * Current file sizes.  Used by fastboot.c to figure out how much
1117 	 * memory to reserve for panic reboot.
1118 	 * Use the module list from the dboot-constructed xboot_info
1119 	 * instead of the list referenced by the multiboot structure
1120 	 * because that structure may not be addressable now.
1121 	 */
1122 	saved_file_size[FASTBOOT_NAME_UNIX] = FOUR_MEG - PAGESIZE;
1123 	for (i = 0, modp = (struct boot_modules *)(uintptr_t)xbi->bi_modules;
1124 	    i < xbi->bi_module_cnt; i++, modp++) {
1125 		saved_file_size[FASTBOOT_NAME_BOOTARCHIVE] += modp->bm_size;
1126 	}
1127 
1128 }
1129 #endif	/* __xpv */
1130 
1131 
1132 /*
1133  * 1st pass at building the table of boot properties. This includes:
1134  * - values set on the command line: -B a=x,b=y,c=z ....
1135  * - known values we just compute (ie. from xbootp)
1136  * - values from /boot/solaris/bootenv.rc (ie. eeprom(1m) values)
1137  *
1138  * the grub command line looked like:
1139  * kernel boot-file [-B prop=value[,prop=value]...] [boot-args]
1140  *
1141  * whoami is the same as boot-file
1142  */
1143 static void
1144 build_boot_properties(void)
1145 {
1146 	char *name;
1147 	int name_len;
1148 	char *value;
1149 	int value_len;
1150 	struct boot_modules *bm;
1151 	char *propbuf;
1152 	int quoted = 0;
1153 	int boot_arg_len;
1154 #ifndef __xpv
1155 	static int stdout_val = 0;
1156 	uchar_t boot_device;
1157 	char str[3];
1158 	multiboot_info_t *mbi;
1159 	int netboot;
1160 	struct sol_netinfo *sip;
1161 #endif
1162 
1163 	/*
1164 	 * These have to be done first, so that kobj_mount_root() works
1165 	 */
1166 	DBG_MSG("Building boot properties\n");
1167 	propbuf = do_bsys_alloc(NULL, NULL, MMU_PAGESIZE, 0);
1168 	DBG((uintptr_t)propbuf);
1169 	if (xbootp->bi_module_cnt > 0) {
1170 		bm = xbootp->bi_modules;
1171 		bsetprop64("ramdisk_start", (uint64_t)(uintptr_t)bm->bm_addr);
1172 		bsetprop64("ramdisk_end", (uint64_t)(uintptr_t)bm->bm_addr +
1173 		    bm->bm_size);
1174 	}
1175 
1176 	DBG_MSG("Parsing command line for boot properties\n");
1177 	value = xbootp->bi_cmdline;
1178 
1179 	/*
1180 	 * allocate memory to collect boot_args into
1181 	 */
1182 	boot_arg_len = strlen(xbootp->bi_cmdline) + 1;
1183 	boot_args = do_bsys_alloc(NULL, NULL, boot_arg_len, MMU_PAGESIZE);
1184 	boot_args[0] = 0;
1185 	boot_arg_len = 0;
1186 
1187 #ifdef __xpv
1188 	/*
1189 	 * Xen puts a lot of device information in front of the kernel name
1190 	 * let's grab them and make them boot properties.  The first
1191 	 * string w/o an "=" in it will be the boot-file property.
1192 	 */
1193 	(void) strcpy(namebuf, "xpv-");
1194 	for (;;) {
1195 		/*
1196 		 * get to next property
1197 		 */
1198 		while (ISSPACE(*value))
1199 			++value;
1200 		name = value;
1201 		/*
1202 		 * look for an "="
1203 		 */
1204 		while (*value && !ISSPACE(*value) && *value != '=') {
1205 			value++;
1206 		}
1207 		if (*value != '=') { /* no "=" in the property */
1208 			value = name;
1209 			break;
1210 		}
1211 		name_len = value - name;
1212 		value_len = 0;
1213 		/*
1214 		 * skip over the "="
1215 		 */
1216 		value++;
1217 		while (value[value_len] && !ISSPACE(value[value_len])) {
1218 			++value_len;
1219 		}
1220 		/*
1221 		 * build property name with "xpv-" prefix
1222 		 */
1223 		if (name_len + 4 > 32) { /* skip if name too long */
1224 			value += value_len;
1225 			continue;
1226 		}
1227 		bcopy(name, &namebuf[4], name_len);
1228 		name_len += 4;
1229 		namebuf[name_len] = 0;
1230 		bcopy(value, propbuf, value_len);
1231 		propbuf[value_len] = 0;
1232 		bsetprops(namebuf, propbuf);
1233 
1234 		/*
1235 		 * xpv-root is set to the logical disk name of the xen
1236 		 * VBD when booting from a disk-based filesystem.
1237 		 */
1238 		if (strcmp(namebuf, "xpv-root") == 0)
1239 			xen_vbdroot_props(propbuf);
1240 		/*
1241 		 * While we're here, if we have a "xpv-nfsroot" property
1242 		 * then we need to set "fstype" to "nfs" so we mount
1243 		 * our root from the nfs server.  Also parse the xpv-nfsroot
1244 		 * property to create the properties that nfs_mountroot will
1245 		 * need to find the root and mount it.
1246 		 */
1247 		if (strcmp(namebuf, "xpv-nfsroot") == 0)
1248 			xen_nfsroot_props(propbuf);
1249 
1250 		if (strcmp(namebuf, "xpv-ip") == 0)
1251 			xen_ip_props(propbuf);
1252 		value += value_len;
1253 	}
1254 #endif
1255 
1256 	while (ISSPACE(*value))
1257 		++value;
1258 	/*
1259 	 * value now points at the boot-file
1260 	 */
1261 	value_len = 0;
1262 	while (value[value_len] && !ISSPACE(value[value_len]))
1263 		++value_len;
1264 	if (value_len > 0) {
1265 		whoami = propbuf;
1266 		bcopy(value, whoami, value_len);
1267 		whoami[value_len] = 0;
1268 		bsetprops("boot-file", whoami);
1269 		/*
1270 		 * strip leading path stuff from whoami, so running from
1271 		 * PXE/miniroot makes sense.
1272 		 */
1273 		if (strstr(whoami, "/platform/") != NULL)
1274 			whoami = strstr(whoami, "/platform/");
1275 		bsetprops("whoami", whoami);
1276 	}
1277 
1278 	/*
1279 	 * Values forcibly set boot properties on the command line via -B.
1280 	 * Allow use of quotes in values. Other stuff goes on kernel
1281 	 * command line.
1282 	 */
1283 	name = value + value_len;
1284 	while (*name != 0) {
1285 		/*
1286 		 * anything not " -B" is copied to the command line
1287 		 */
1288 		if (!ISSPACE(name[0]) || name[1] != '-' || name[2] != 'B') {
1289 			boot_args[boot_arg_len++] = *name;
1290 			boot_args[boot_arg_len] = 0;
1291 			++name;
1292 			continue;
1293 		}
1294 
1295 		/*
1296 		 * skip the " -B" and following white space
1297 		 */
1298 		name += 3;
1299 		while (ISSPACE(*name))
1300 			++name;
1301 		while (*name && !ISSPACE(*name)) {
1302 			value = strstr(name, "=");
1303 			if (value == NULL)
1304 				break;
1305 			name_len = value - name;
1306 			++value;
1307 			value_len = 0;
1308 			quoted = 0;
1309 			for (; ; ++value_len) {
1310 				if (!value[value_len])
1311 					break;
1312 
1313 				/*
1314 				 * is this value quoted?
1315 				 */
1316 				if (value_len == 0 &&
1317 				    (value[0] == '\'' || value[0] == '"')) {
1318 					quoted = value[0];
1319 					++value_len;
1320 				}
1321 
1322 				/*
1323 				 * In the quote accept any character,
1324 				 * but look for ending quote.
1325 				 */
1326 				if (quoted) {
1327 					if (value[value_len] == quoted)
1328 						quoted = 0;
1329 					continue;
1330 				}
1331 
1332 				/*
1333 				 * a comma or white space ends the value
1334 				 */
1335 				if (value[value_len] == ',' ||
1336 				    ISSPACE(value[value_len]))
1337 					break;
1338 			}
1339 
1340 			if (value_len == 0) {
1341 				bsetprop(name, name_len, "true", 5);
1342 			} else {
1343 				char *v = value;
1344 				int l = value_len;
1345 				if (v[0] == v[l - 1] &&
1346 				    (v[0] == '\'' || v[0] == '"')) {
1347 					++v;
1348 					l -= 2;
1349 				}
1350 				bcopy(v, propbuf, l);
1351 				propbuf[l] = '\0';
1352 				bsetprop(name, name_len, propbuf,
1353 				    l + 1);
1354 			}
1355 			name = value + value_len;
1356 			while (*name == ',')
1357 				++name;
1358 		}
1359 	}
1360 
1361 	/*
1362 	 * set boot-args property
1363 	 * 1275 name is bootargs, so set
1364 	 * that too
1365 	 */
1366 	bsetprops("boot-args", boot_args);
1367 	bsetprops("bootargs", boot_args);
1368 
1369 #ifndef __xpv
1370 	/*
1371 	 * set the BIOS boot device from GRUB
1372 	 */
1373 	netboot = 0;
1374 	mbi = xbootp->bi_mb_info;
1375 
1376 	/*
1377 	 * Build boot command line for Fast Reboot
1378 	 */
1379 	build_fastboot_cmdline();
1380 
1381 	/*
1382 	 * Save various boot information for Fast Reboot
1383 	 */
1384 	save_boot_info(mbi, xbootp);
1385 
1386 	if (mbi != NULL && mbi->flags & 0x2) {
1387 		boot_device = mbi->boot_device >> 24;
1388 		if (boot_device == 0x20)
1389 			netboot++;
1390 		str[0] = (boot_device >> 4) + '0';
1391 		str[1] = (boot_device & 0xf) + '0';
1392 		str[2] = 0;
1393 		bsetprops("bios-boot-device", str);
1394 	} else {
1395 		netboot = 1;
1396 	}
1397 
1398 	/*
1399 	 * In the netboot case, drives_info is overloaded with the dhcp ack.
1400 	 * This is not multiboot compliant and requires special pxegrub!
1401 	 */
1402 	if (netboot && mbi->drives_length != 0) {
1403 		sip = (struct sol_netinfo *)(uintptr_t)mbi->drives_addr;
1404 		if (sip->sn_infotype == SN_TYPE_BOOTP)
1405 			bsetprop("bootp-response", sizeof ("bootp-response"),
1406 			    (void *)(uintptr_t)mbi->drives_addr,
1407 			    mbi->drives_length);
1408 		else if (sip->sn_infotype == SN_TYPE_RARP)
1409 			setup_rarp_props(sip);
1410 	}
1411 	bsetprop("stdout", strlen("stdout"),
1412 	    &stdout_val, sizeof (stdout_val));
1413 #endif /* __xpv */
1414 
1415 	/*
1416 	 * more conjured up values for made up things....
1417 	 */
1418 #if defined(__xpv)
1419 	bsetprops("mfg-name", "i86xpv");
1420 	bsetprops("impl-arch-name", "i86xpv");
1421 #else
1422 	bsetprops("mfg-name", "i86pc");
1423 	bsetprops("impl-arch-name", "i86pc");
1424 #endif
1425 
1426 	/*
1427 	 * Build firmware-provided system properties
1428 	 */
1429 	build_firmware_properties();
1430 
1431 	/*
1432 	 * XXPV
1433 	 *
1434 	 * Find out what these are:
1435 	 * - cpuid_feature_ecx_include
1436 	 * - cpuid_feature_ecx_exclude
1437 	 * - cpuid_feature_edx_include
1438 	 * - cpuid_feature_edx_exclude
1439 	 *
1440 	 * Find out what these are in multiboot:
1441 	 * - netdev-path
1442 	 * - fstype
1443 	 */
1444 }
1445 
1446 #ifdef __xpv
1447 /*
1448  * Under the Hypervisor, memory usable for DMA may be scarce. One
1449  * very likely large pool of DMA friendly memory is occupied by
1450  * the boot_archive, as it was loaded by grub into low MFNs.
1451  *
1452  * Here we free up that memory by copying the boot archive to what are
1453  * likely higher MFN pages and then swapping the mfn/pfn mappings.
1454  */
1455 #define	PFN_2GIG	0x80000
1456 static void
1457 relocate_boot_archive(void)
1458 {
1459 	mfn_t max_mfn = HYPERVISOR_memory_op(XENMEM_maximum_ram_page, NULL);
1460 	struct boot_modules *bm = xbootp->bi_modules;
1461 	uintptr_t va;
1462 	pfn_t va_pfn;
1463 	mfn_t va_mfn;
1464 	caddr_t copy;
1465 	pfn_t copy_pfn;
1466 	mfn_t copy_mfn;
1467 	size_t	len;
1468 	int slop;
1469 	int total = 0;
1470 	int relocated = 0;
1471 	int mmu_update_return;
1472 	mmu_update_t t[2];
1473 	x86pte_t pte;
1474 
1475 	/*
1476 	 * If all MFN's are below 2Gig, don't bother doing this.
1477 	 */
1478 	if (max_mfn < PFN_2GIG)
1479 		return;
1480 	if (xbootp->bi_module_cnt < 1) {
1481 		DBG_MSG("no boot_archive!");
1482 		return;
1483 	}
1484 
1485 	DBG_MSG("moving boot_archive to high MFN memory\n");
1486 	va = (uintptr_t)bm->bm_addr;
1487 	len = bm->bm_size;
1488 	slop = va & MMU_PAGEOFFSET;
1489 	if (slop) {
1490 		va += MMU_PAGESIZE - slop;
1491 		len -= MMU_PAGESIZE - slop;
1492 	}
1493 	len = P2ALIGN(len, MMU_PAGESIZE);
1494 
1495 	/*
1496 	 * Go through all boot_archive pages, swapping any low MFN pages
1497 	 * with memory at next_phys.
1498 	 */
1499 	while (len != 0) {
1500 		++total;
1501 		va_pfn = mmu_btop(va - ONE_GIG);
1502 		va_mfn = mfn_list[va_pfn];
1503 		if (mfn_list[va_pfn] < PFN_2GIG) {
1504 			copy = kbm_remap_window(next_phys, 1);
1505 			bcopy((void *)va, copy, MMU_PAGESIZE);
1506 			copy_pfn = mmu_btop(next_phys);
1507 			copy_mfn = mfn_list[copy_pfn];
1508 
1509 			pte = mfn_to_ma(copy_mfn) | PT_NOCONSIST | PT_VALID;
1510 			if (HYPERVISOR_update_va_mapping(va, pte,
1511 			    UVMF_INVLPG | UVMF_LOCAL))
1512 				bop_panic("relocate_boot_archive():  "
1513 				    "HYPERVISOR_update_va_mapping() failed");
1514 
1515 			mfn_list[va_pfn] = copy_mfn;
1516 			mfn_list[copy_pfn] = va_mfn;
1517 
1518 			t[0].ptr = mfn_to_ma(copy_mfn) | MMU_MACHPHYS_UPDATE;
1519 			t[0].val = va_pfn;
1520 			t[1].ptr = mfn_to_ma(va_mfn) | MMU_MACHPHYS_UPDATE;
1521 			t[1].val = copy_pfn;
1522 			if (HYPERVISOR_mmu_update(t, 2, &mmu_update_return,
1523 			    DOMID_SELF) != 0 || mmu_update_return != 2)
1524 				bop_panic("relocate_boot_archive():  "
1525 				    "HYPERVISOR_mmu_update() failed");
1526 
1527 			next_phys += MMU_PAGESIZE;
1528 			++relocated;
1529 		}
1530 		len -= MMU_PAGESIZE;
1531 		va += MMU_PAGESIZE;
1532 	}
1533 	DBG_MSG("Relocated pages:\n");
1534 	DBG(relocated);
1535 	DBG_MSG("Out of total pages:\n");
1536 	DBG(total);
1537 }
1538 #endif /* __xpv */
1539 
1540 #if !defined(__xpv)
1541 /*
1542  * Install a temporary IDT that lets us catch errors in the boot time code.
1543  * We shouldn't get any faults at all while this is installed, so we'll
1544  * just generate a traceback and exit.
1545  */
1546 #ifdef __amd64
1547 static const int bcode_sel = B64CODE_SEL;
1548 #else
1549 static const int bcode_sel = B32CODE_SEL;
1550 #endif
1551 
1552 /*
1553  * simple description of a stack frame (args are 32 bit only currently)
1554  */
1555 typedef struct bop_frame {
1556 	struct bop_frame *old_frame;
1557 	pc_t retaddr;
1558 	long arg[1];
1559 } bop_frame_t;
1560 
1561 void
1562 bop_traceback(bop_frame_t *frame)
1563 {
1564 	pc_t pc;
1565 	int cnt;
1566 	int a;
1567 	char *ksym;
1568 	ulong_t off;
1569 
1570 	bop_printf(NULL, "Stack traceback:\n");
1571 	for (cnt = 0; cnt < 30; ++cnt) {	/* up to 30 frames */
1572 		pc = frame->retaddr;
1573 		if (pc == 0)
1574 			break;
1575 		ksym = kobj_getsymname(pc, &off);
1576 		if (ksym)
1577 			bop_printf(NULL, "  %s+%lx", ksym, off);
1578 		else
1579 			bop_printf(NULL, "  0x%lx", pc);
1580 
1581 		frame = frame->old_frame;
1582 		if (frame == 0) {
1583 			bop_printf(NULL, "\n");
1584 			break;
1585 		}
1586 		for (a = 0; a < 6; ++a) {	/* try for 6 args */
1587 #if defined(__i386)
1588 			if ((void *)&frame->arg[a] == (void *)frame->old_frame)
1589 				break;
1590 			if (a == 0)
1591 				bop_printf(NULL, "(");
1592 			else
1593 				bop_printf(NULL, ",");
1594 			bop_printf(NULL, "0x%lx", frame->arg[a]);
1595 #endif
1596 		}
1597 		bop_printf(NULL, ")\n");
1598 	}
1599 }
1600 
1601 struct trapframe {
1602 	ulong_t frame_ptr;	/* %[er]bp pushed by our code */
1603 	ulong_t error_code;	/* optional */
1604 	ulong_t inst_ptr;
1605 	ulong_t code_seg;
1606 	ulong_t flags_reg;
1607 #ifdef __amd64
1608 	ulong_t stk_ptr;
1609 	ulong_t stk_seg;
1610 #endif
1611 };
1612 
1613 void
1614 bop_trap(struct trapframe *tf)
1615 {
1616 	bop_frame_t fakeframe;
1617 	static int depth = 0;
1618 
1619 	/*
1620 	 * Check for an infinite loop of traps.
1621 	 */
1622 	if (++depth > 2)
1623 		bop_panic("Nested trap");
1624 
1625 	/*
1626 	 * adjust the tf for optional error_code by detecting the code selector
1627 	 */
1628 	if (tf->code_seg != bcode_sel)
1629 		tf = (struct trapframe *)((uintptr_t)tf - sizeof (ulong_t));
1630 
1631 	bop_printf(NULL, "Unexpected trap\n");
1632 	bop_printf(NULL, "instruction pointer  0x%lx\n", tf->inst_ptr);
1633 	bop_printf(NULL, "error code, optional 0x%lx\n",
1634 	    tf->error_code & 0xffffffff);
1635 	bop_printf(NULL, "code segment         0x%lx\n", tf->code_seg & 0xffff);
1636 	bop_printf(NULL, "flags register       0x%lx\n", tf->flags_reg);
1637 #ifdef __amd64
1638 	bop_printf(NULL, "return %%rsp         0x%lx\n", tf->stk_ptr);
1639 	bop_printf(NULL, "return %%ss          0x%lx\n", tf->stk_seg & 0xffff);
1640 #endif
1641 	fakeframe.old_frame = (bop_frame_t *)tf->frame_ptr;
1642 	fakeframe.retaddr = (pc_t)tf->inst_ptr;
1643 	bop_printf(NULL, "Attempting stack backtrace:\n");
1644 	bop_traceback(&fakeframe);
1645 	bop_panic("unexpected trap in early boot");
1646 }
1647 
1648 extern void bop_trap_handler(void);
1649 
1650 static gate_desc_t *bop_idt;
1651 
1652 static desctbr_t bop_idt_info;
1653 
1654 static void
1655 bop_idt_init(void)
1656 {
1657 	int t;
1658 
1659 	bop_idt = (gate_desc_t *)
1660 	    do_bsys_alloc(NULL, NULL, MMU_PAGESIZE, MMU_PAGESIZE);
1661 	bzero(bop_idt, MMU_PAGESIZE);
1662 	for (t = 0; t < NIDT; ++t) {
1663 		/*
1664 		 * Note that since boot runs without a TSS, the
1665 		 * double fault handler cannot use an alternate stack
1666 		 * (64-bit) or a task gate (32-bit).
1667 		 */
1668 		set_gatesegd(&bop_idt[t], &bop_trap_handler, bcode_sel,
1669 		    SDT_SYSIGT, TRP_KPL, 0);
1670 	}
1671 	bop_idt_info.dtr_limit = (NIDT * sizeof (gate_desc_t)) - 1;
1672 	bop_idt_info.dtr_base = (uintptr_t)bop_idt;
1673 	wr_idtr(&bop_idt_info);
1674 }
1675 #endif	/* !defined(__xpv) */
1676 
1677 /*
1678  * This is where we enter the kernel. It dummies up the boot_ops and
1679  * boot_syscalls vectors and jumps off to _kobj_boot()
1680  */
1681 void
1682 _start(struct xboot_info *xbp)
1683 {
1684 	bootops_t *bops = &bootop;
1685 	extern void _kobj_boot();
1686 
1687 	/*
1688 	 * 1st off - initialize the console for any error messages
1689 	 */
1690 	xbootp = xbp;
1691 #ifdef __xpv
1692 	HYPERVISOR_shared_info = (void *)xbootp->bi_shared_info;
1693 	xen_info = xbootp->bi_xen_start_info;
1694 #endif
1695 	bcons_init((void *)xbootp->bi_cmdline);
1696 	have_console = 1;
1697 
1698 #ifndef __xpv
1699 	if (*((uint32_t *)(FASTBOOT_SWTCH_PA + FASTBOOT_STACK_OFFSET)) ==
1700 	    FASTBOOT_MAGIC) {
1701 		post_fastreboot = 1;
1702 		*((uint32_t *)(FASTBOOT_SWTCH_PA + FASTBOOT_STACK_OFFSET)) = 0;
1703 	}
1704 #endif
1705 
1706 	/*
1707 	 * enable debugging
1708 	 */
1709 	if (strstr((char *)xbootp->bi_cmdline, "kbm_debug"))
1710 		kbm_debug = 1;
1711 
1712 	DBG_MSG("\n\n*** Entered Solaris in _start() cmdline is: ");
1713 	DBG_MSG((char *)xbootp->bi_cmdline);
1714 	DBG_MSG("\n\n\n");
1715 
1716 	/*
1717 	 * physavail is no longer used by startup
1718 	 */
1719 	bm.physinstalled = xbp->bi_phys_install;
1720 	bm.pcimem = xbp->bi_pcimem;
1721 	bm.rsvdmem = xbp->bi_rsvdmem;
1722 	bm.physavail = NULL;
1723 
1724 	/*
1725 	 * initialize the boot time allocator
1726 	 */
1727 	next_phys = xbootp->bi_next_paddr;
1728 	DBG(next_phys);
1729 	next_virt = (uintptr_t)xbootp->bi_next_vaddr;
1730 	DBG(next_virt);
1731 	DBG_MSG("Initializing boot time memory management...");
1732 #ifdef __xpv
1733 	{
1734 		xen_platform_parameters_t p;
1735 
1736 		/* This call shouldn't fail, dboot already did it once. */
1737 		(void) HYPERVISOR_xen_version(XENVER_platform_parameters, &p);
1738 		mfn_to_pfn_mapping = (pfn_t *)(xen_virt_start = p.virt_start);
1739 		DBG(xen_virt_start);
1740 	}
1741 #endif
1742 	kbm_init(xbootp);
1743 	DBG_MSG("done\n");
1744 
1745 	/*
1746 	 * Fill in the bootops vector
1747 	 */
1748 	bops->bsys_version = BO_VERSION;
1749 	bops->boot_mem = &bm;
1750 	bops->bsys_alloc = do_bsys_alloc;
1751 	bops->bsys_free = do_bsys_free;
1752 	bops->bsys_getproplen = do_bsys_getproplen;
1753 	bops->bsys_getprop = do_bsys_getprop;
1754 	bops->bsys_nextprop = do_bsys_nextprop;
1755 	bops->bsys_printf = bop_printf;
1756 	bops->bsys_doint = do_bsys_doint;
1757 
1758 	/*
1759 	 * BOP_EALLOC() is no longer needed
1760 	 */
1761 	bops->bsys_ealloc = do_bsys_ealloc;
1762 
1763 #ifdef __xpv
1764 	/*
1765 	 * On domain 0 we need to free up some physical memory that is
1766 	 * usable for DMA. Since GRUB loaded the boot_archive, it is
1767 	 * sitting in low MFN memory. We'll relocated the boot archive
1768 	 * pages to high PFN memory.
1769 	 */
1770 	if (DOMAIN_IS_INITDOMAIN(xen_info))
1771 		relocate_boot_archive();
1772 #endif
1773 
1774 #ifndef __xpv
1775 	/*
1776 	 * Install an IDT to catch early pagefaults (shouldn't have any).
1777 	 * Also needed for kmdb.
1778 	 */
1779 	bop_idt_init();
1780 #endif
1781 
1782 	/*
1783 	 * Start building the boot properties from the command line
1784 	 */
1785 	DBG_MSG("Initializing boot properties:\n");
1786 	build_boot_properties();
1787 
1788 	if (strstr((char *)xbootp->bi_cmdline, "prom_debug") || kbm_debug) {
1789 		char *name;
1790 		char *value;
1791 		char *cp;
1792 		int len;
1793 
1794 		value = do_bsys_alloc(NULL, NULL, MMU_PAGESIZE, MMU_PAGESIZE);
1795 		bop_printf(NULL, "\nBoot properties:\n");
1796 		name = "";
1797 		while ((name = do_bsys_nextprop(NULL, name)) != NULL) {
1798 			bop_printf(NULL, "\t0x%p %s = ", (void *)name, name);
1799 			(void) do_bsys_getprop(NULL, name, value);
1800 			len = do_bsys_getproplen(NULL, name);
1801 			bop_printf(NULL, "len=%d ", len);
1802 			value[len] = 0;
1803 			for (cp = value; *cp; ++cp) {
1804 				if (' ' <= *cp && *cp <= '~')
1805 					bop_printf(NULL, "%c", *cp);
1806 				else
1807 					bop_printf(NULL, "-0x%x-", *cp);
1808 			}
1809 			bop_printf(NULL, "\n");
1810 		}
1811 	}
1812 
1813 	/*
1814 	 * jump into krtld...
1815 	 */
1816 	_kobj_boot(&bop_sysp, NULL, bops, NULL);
1817 }
1818 
1819 
1820 /*ARGSUSED*/
1821 static caddr_t
1822 no_more_alloc(bootops_t *bop, caddr_t virthint, size_t size, int align)
1823 {
1824 	panic("Attempt to bsys_alloc() too late\n");
1825 	return (NULL);
1826 }
1827 
1828 /*ARGSUSED*/
1829 static void
1830 no_more_free(bootops_t *bop, caddr_t virt, size_t size)
1831 {
1832 	panic("Attempt to bsys_free() too late\n");
1833 }
1834 
1835 void
1836 bop_no_more_mem(void)
1837 {
1838 	DBG(total_bop_alloc_scratch);
1839 	DBG(total_bop_alloc_kernel);
1840 	bootops->bsys_alloc = no_more_alloc;
1841 	bootops->bsys_free = no_more_free;
1842 }
1843 
1844 
1845 #ifndef __xpv
1846 /*
1847  * Set ACPI firmware properties
1848  */
1849 
1850 static caddr_t
1851 vmap_phys(size_t length, paddr_t pa)
1852 {
1853 	paddr_t	start, end;
1854 	caddr_t	va;
1855 	size_t	len, page;
1856 
1857 	start = P2ALIGN(pa, MMU_PAGESIZE);
1858 	end = P2ROUNDUP(pa + length, MMU_PAGESIZE);
1859 	len = end - start;
1860 	va = (caddr_t)alloc_vaddr(len, MMU_PAGESIZE);
1861 	for (page = 0; page < len; page += MMU_PAGESIZE)
1862 		kbm_map((uintptr_t)va + page, start + page, 0, 0);
1863 	return (va + (pa & MMU_PAGEOFFSET));
1864 }
1865 
1866 static uint8_t
1867 checksum_table(uint8_t *tp, size_t len)
1868 {
1869 	uint8_t sum = 0;
1870 
1871 	while (len-- > 0)
1872 		sum += *tp++;
1873 
1874 	return (sum);
1875 }
1876 
1877 static int
1878 valid_rsdp(struct rsdp *rp)
1879 {
1880 
1881 	/* validate the V1.x checksum */
1882 	if (checksum_table((uint8_t *)&rp->v1, sizeof (struct rsdp_v1)) != 0)
1883 		return (0);
1884 
1885 	/* If pre-ACPI 2.0, this is a valid RSDP */
1886 	if (rp->v1.revision < 2)
1887 		return (1);
1888 
1889 	/* validate the V2.x checksum */
1890 	if (checksum_table((uint8_t *)rp, sizeof (struct rsdp)) != 0)
1891 		return (0);
1892 
1893 	return (1);
1894 }
1895 
1896 /*
1897  * Scan memory range for an RSDP;
1898  * see ACPI 3.0 Spec, 5.2.5.1
1899  */
1900 static struct rsdp *
1901 scan_rsdp(paddr_t start, paddr_t end)
1902 {
1903 	size_t len  = end - start + 1;
1904 	caddr_t ptr;
1905 
1906 	ptr = vmap_phys(len, start);
1907 	while (len > 0) {
1908 		if (strncmp(ptr, ACPI_RSDP_SIG, ACPI_RSDP_SIG_LEN) == 0)
1909 			if (valid_rsdp((struct rsdp *)ptr))
1910 				return ((struct rsdp *)ptr);
1911 		ptr += 16;
1912 		len -= 16;
1913 	}
1914 
1915 	return (NULL);
1916 }
1917 
1918 /*
1919  * Refer to ACPI 3.0 Spec, section 5.2.5.1 to understand this function
1920  */
1921 static struct rsdp *
1922 find_rsdp() {
1923 	struct rsdp *rsdp;
1924 	uint16_t *ebda_seg;
1925 	paddr_t  ebda_addr;
1926 
1927 	/*
1928 	 * Get the EBDA segment and scan the first 1K
1929 	 */
1930 	ebda_seg = (uint16_t *)vmap_phys(sizeof (uint16_t), ACPI_EBDA_SEG_ADDR);
1931 	ebda_addr = *ebda_seg << 4;
1932 	rsdp = scan_rsdp(ebda_addr, ebda_addr + ACPI_EBDA_LEN - 1);
1933 	if (rsdp == NULL)
1934 		/* if EBDA doesn't contain RSDP, look in BIOS memory */
1935 		rsdp = scan_rsdp(0xe0000, 0xfffff);
1936 	return (rsdp);
1937 }
1938 
1939 static struct table_header *
1940 map_fw_table(paddr_t table_addr)
1941 {
1942 	struct table_header *tp;
1943 	size_t len = MAX(sizeof (struct table_header), MMU_PAGESIZE);
1944 
1945 	/*
1946 	 * Map at least a page; if the table is larger than this, remap it
1947 	 */
1948 	tp = (struct table_header *)vmap_phys(len, table_addr);
1949 	if (tp->len > len)
1950 		tp = (struct table_header *)vmap_phys(tp->len, table_addr);
1951 	return (tp);
1952 }
1953 
1954 static struct table_header *
1955 find_fw_table(char *signature)
1956 {
1957 	static int revision = 0;
1958 	static struct xsdt *xsdt;
1959 	static int len;
1960 	paddr_t xsdt_addr;
1961 	struct rsdp *rsdp;
1962 	struct table_header *tp;
1963 	paddr_t table_addr;
1964 	int	n;
1965 
1966 	if (strlen(signature) != ACPI_TABLE_SIG_LEN)
1967 		return (NULL);
1968 
1969 	/*
1970 	 * Reading the ACPI 3.0 Spec, section 5.2.5.3 will help
1971 	 * understand this code.  If we haven't already found the RSDT/XSDT,
1972 	 * revision will be 0. Find the RSDP and check the revision
1973 	 * to find out whether to use the RSDT or XSDT.  If revision is
1974 	 * 0 or 1, use the RSDT and set internal revision to 1; if it is 2,
1975 	 * use the XSDT.  If the XSDT address is 0, though, fall back to
1976 	 * revision 1 and use the RSDT.
1977 	 */
1978 	if (revision == 0) {
1979 		if ((rsdp = (struct rsdp *)find_rsdp()) != NULL) {
1980 			revision = rsdp->v1.revision;
1981 			switch (revision) {
1982 			case 2:
1983 				/*
1984 				 * Use the XSDT unless BIOS is buggy and
1985 				 * claims to be rev 2 but has a null XSDT
1986 				 * address
1987 				 */
1988 				xsdt_addr = rsdp->xsdt;
1989 				if (xsdt_addr != 0)
1990 					break;
1991 				/* FALLTHROUGH */
1992 			case 0:
1993 				/* treat RSDP rev 0 as revision 1 internally */
1994 				revision = 1;
1995 				/* FALLTHROUGH */
1996 			case 1:
1997 				/* use the RSDT for rev 0/1 */
1998 				xsdt_addr = rsdp->v1.rsdt;
1999 				break;
2000 			default:
2001 				/* unknown revision */
2002 				revision = 0;
2003 				break;
2004 			}
2005 		}
2006 		if (revision == 0)
2007 			return (NULL);
2008 
2009 		/* cache the XSDT info */
2010 		xsdt = (struct xsdt *)map_fw_table(xsdt_addr);
2011 		len = (xsdt->hdr.len - sizeof (xsdt->hdr)) /
2012 		    ((revision == 1) ? sizeof (uint32_t) : sizeof (uint64_t));
2013 	}
2014 
2015 	/*
2016 	 * Scan the table headers looking for a signature match
2017 	 */
2018 	for (n = 0; n < len; n++) {
2019 		table_addr = (revision == 1) ? xsdt->p.r[n] : xsdt->p.x[n];
2020 		if (table_addr == 0)
2021 			continue;
2022 		tp = map_fw_table(table_addr);
2023 		if (strncmp(tp->sig, signature, ACPI_TABLE_SIG_LEN) == 0) {
2024 			return (tp);
2025 		}
2026 	}
2027 	return (NULL);
2028 }
2029 
2030 static void
2031 process_madt(struct madt *tp)
2032 {
2033 	struct madt_processor *cpu, *end;
2034 	uint32_t cpu_count = 0;
2035 	uint8_t cpu_apicid_array[UINT8_MAX + 1];
2036 
2037 	if (tp != NULL) {
2038 		/*
2039 		 * Determine number of CPUs and keep track of "final" APIC ID
2040 		 * for each CPU by walking through ACPI MADT processor list
2041 		 */
2042 		end = (struct madt_processor *)(tp->hdr.len + (uintptr_t)tp);
2043 		cpu = tp->list;
2044 		while (cpu < end) {
2045 			if (cpu->type == MADT_PROCESSOR) {
2046 				if (cpu->flags & 1) {
2047 					if (cpu_count < UINT8_MAX)
2048 						cpu_apicid_array[cpu_count] =
2049 						    cpu->apic_id;
2050 					cpu_count++;
2051 				}
2052 			}
2053 
2054 			cpu = (struct madt_processor *)
2055 			    (cpu->len + (uintptr_t)cpu);
2056 		}
2057 
2058 		/*
2059 		 * Make boot property for array of "final" APIC IDs for each
2060 		 * CPU
2061 		 */
2062 		bsetprop(BP_CPU_APICID_ARRAY, strlen(BP_CPU_APICID_ARRAY),
2063 		    cpu_apicid_array, cpu_count * sizeof (uint8_t));
2064 	}
2065 
2066 	/*
2067 	 * User-set boot-ncpus overrides firmware count
2068 	 */
2069 	if (do_bsys_getproplen(NULL, "boot-ncpus") >= 0)
2070 		return;
2071 
2072 	/*
2073 	 * Set boot property for boot-ncpus to number of CPUs given in MADT
2074 	 * if user hasn't set the property already
2075 	 */
2076 	if (tp != NULL)
2077 		bsetpropsi("boot-ncpus", cpu_count);
2078 }
2079 
2080 static void
2081 process_srat(struct srat *tp)
2082 {
2083 	struct srat_item *item, *end;
2084 	int i;
2085 	int proc_num, mem_num;
2086 #pragma pack(1)
2087 	struct {
2088 		uint32_t domain;
2089 		uint32_t apic_id;
2090 		uint32_t sapic_id;
2091 	} processor;
2092 	struct {
2093 		uint32_t domain;
2094 		uint32_t x2apic_id;
2095 	} x2apic;
2096 	struct {
2097 		uint32_t domain;
2098 		uint64_t addr;
2099 		uint64_t length;
2100 		uint32_t flags;
2101 	} memory;
2102 #pragma pack()
2103 	char prop_name[30];
2104 
2105 	if (tp == NULL)
2106 		return;
2107 
2108 	proc_num = mem_num = 0;
2109 	end = (struct srat_item *)(tp->hdr.len + (uintptr_t)tp);
2110 	item = tp->list;
2111 	while (item < end) {
2112 		switch (item->type) {
2113 		case SRAT_PROCESSOR:
2114 			if (!(item->i.p.flags & SRAT_ENABLED))
2115 				break;
2116 			processor.domain = item->i.p.domain1;
2117 			for (i = 0; i < 3; i++)
2118 				processor.domain +=
2119 				    item->i.p.domain2[i] << ((i + 1) * 8);
2120 			processor.apic_id = item->i.p.apic_id;
2121 			processor.sapic_id = item->i.p.local_sapic_eid;
2122 			(void) snprintf(prop_name, 30, "acpi-srat-processor-%d",
2123 			    proc_num);
2124 			bsetprop(prop_name, strlen(prop_name), &processor,
2125 			    sizeof (processor));
2126 			proc_num++;
2127 			break;
2128 		case SRAT_MEMORY:
2129 			if (!(item->i.m.flags & SRAT_ENABLED))
2130 				break;
2131 			memory.domain = item->i.m.domain;
2132 			memory.addr = item->i.m.base_addr;
2133 			memory.length = item->i.m.len;
2134 			memory.flags = item->i.m.flags;
2135 			(void) snprintf(prop_name, 30, "acpi-srat-memory-%d",
2136 			    mem_num);
2137 			bsetprop(prop_name, strlen(prop_name), &memory,
2138 			    sizeof (memory));
2139 			mem_num++;
2140 			break;
2141 		case SRAT_X2APIC:
2142 			if (!(item->i.xp.flags & SRAT_ENABLED))
2143 				break;
2144 			x2apic.domain = item->i.xp.domain;
2145 			x2apic.x2apic_id = item->i.xp.x2apic_id;
2146 			(void) snprintf(prop_name, 30, "acpi-srat-processor-%d",
2147 			    proc_num);
2148 			bsetprop(prop_name, strlen(prop_name), &x2apic,
2149 			    sizeof (x2apic));
2150 			proc_num++;
2151 			break;
2152 		}
2153 
2154 		item = (struct srat_item *)
2155 		    (item->len + (caddr_t)item);
2156 	}
2157 }
2158 
2159 static void
2160 process_slit(struct slit *tp)
2161 {
2162 
2163 	/*
2164 	 * Check the number of localities; if it's too huge, we just
2165 	 * return and locality enumeration code will handle this later,
2166 	 * if possible.
2167 	 *
2168 	 * Note that the size of the table is the square of the
2169 	 * number of localities; if the number of localities exceeds
2170 	 * UINT16_MAX, the table size may overflow an int when being
2171 	 * passed to bsetprop() below.
2172 	 */
2173 	if (tp->number >= SLIT_LOCALITIES_MAX)
2174 		return;
2175 
2176 	bsetprop(SLIT_NUM_PROPNAME, strlen(SLIT_NUM_PROPNAME), &tp->number,
2177 	    sizeof (tp->number));
2178 	bsetprop(SLIT_PROPNAME, strlen(SLIT_PROPNAME), &tp->entry,
2179 	    tp->number * tp->number);
2180 }
2181 
2182 static void
2183 process_dmar(struct dmar *tp)
2184 {
2185 	bsetprop(DMAR_TABLE_PROPNAME, strlen(DMAR_TABLE_PROPNAME),
2186 	    tp, tp->hdr.len);
2187 }
2188 
2189 #else /* __xpv */
2190 static void
2191 enumerate_xen_cpus()
2192 {
2193 	processorid_t	id, max_id;
2194 
2195 	/*
2196 	 * User-set boot-ncpus overrides enumeration
2197 	 */
2198 	if (do_bsys_getproplen(NULL, "boot-ncpus") >= 0)
2199 		return;
2200 
2201 	/*
2202 	 * Probe every possible virtual CPU id and remember the
2203 	 * highest id present; the count of CPUs is one greater
2204 	 * than this.  This tacitly assumes at least cpu 0 is present.
2205 	 */
2206 	max_id = 0;
2207 	for (id = 0; id < MAX_VIRT_CPUS; id++)
2208 		if (HYPERVISOR_vcpu_op(VCPUOP_is_up, id, NULL) == 0)
2209 			max_id = id;
2210 
2211 	bsetpropsi("boot-ncpus", max_id+1);
2212 
2213 }
2214 #endif /* __xpv */
2215 
2216 static void
2217 build_firmware_properties(void)
2218 {
2219 #ifndef __xpv
2220 	struct table_header *tp;
2221 
2222 	if ((tp = find_fw_table("APIC")) != NULL)
2223 		process_madt((struct madt *)tp);
2224 
2225 	if ((srat_ptr = (struct srat *)find_fw_table("SRAT")) != NULL)
2226 		process_srat(srat_ptr);
2227 
2228 	if (slit_ptr = (struct slit *)find_fw_table("SLIT"))
2229 		process_slit(slit_ptr);
2230 
2231 	if (tp = find_fw_table("DMAR"))
2232 		process_dmar((struct dmar *)tp);
2233 #else /* __xpv */
2234 	enumerate_xen_cpus();
2235 #endif /* __xpv */
2236 }
2237 
2238 /*
2239  * fake up a boot property for deferred early console output
2240  * this is used by both graphical boot and the (developer only)
2241  * USB serial console
2242  */
2243 void *
2244 defcons_init(size_t size)
2245 {
2246 	static char *p = NULL;
2247 
2248 	p = do_bsys_alloc(NULL, NULL, size, MMU_PAGESIZE);
2249 	*p = 0;
2250 	bsetprop("deferred-console-buf", strlen("deferred-console-buf") + 1,
2251 	    &p, sizeof (p));
2252 	return (p);
2253 }
2254 
2255 /*ARGSUSED*/
2256 int
2257 boot_compinfo(int fd, struct compinfo *cbp)
2258 {
2259 	cbp->iscmp = 0;
2260 	cbp->blksize = MAXBSIZE;
2261 	return (0);
2262 }
2263 
2264 #define	BP_MAX_STRLEN	32
2265 
2266 /*
2267  * Get value for given boot property
2268  */
2269 int
2270 bootprop_getval(const char *prop_name, u_longlong_t *prop_value)
2271 {
2272 	int		boot_prop_len;
2273 	char		str[BP_MAX_STRLEN];
2274 	u_longlong_t	value;
2275 
2276 	boot_prop_len = BOP_GETPROPLEN(bootops, prop_name);
2277 	if (boot_prop_len < 0 || boot_prop_len > sizeof (str) ||
2278 	    BOP_GETPROP(bootops, prop_name, str) < 0 ||
2279 	    kobj_getvalue(str, &value) == -1)
2280 		return (-1);
2281 
2282 	if (prop_value)
2283 		*prop_value = value;
2284 
2285 	return (0);
2286 }
2287