xref: /titanic_50/usr/src/uts/i86pc/os/startup.c (revision 79ec9da85c2648e2e165ce68612ad0cb6e185618)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5100b72f4Sandrei  * Common Development and Distribution License (the "License").
6100b72f4Sandrei  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
220db3240dSStephen Hanson  * Copyright (c) 1993, 2010, Oracle and/or its affiliates. All rights reserved.
239e3e4df2SGarrett D'Amore  * Copyright 2012 DEY Storage Systems, Inc.  All rights reserved.
24*79ec9da8SYuri Pankov  * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
257c478bd9Sstevel@tonic-gate  */
26a3114836SGerry Liu /*
27a3114836SGerry Liu  * Copyright (c) 2010, Intel Corporation.
28a3114836SGerry Liu  * All rights reserved.
29a3114836SGerry Liu  */
307c478bd9Sstevel@tonic-gate 
317c478bd9Sstevel@tonic-gate #include <sys/types.h>
327c478bd9Sstevel@tonic-gate #include <sys/t_lock.h>
337c478bd9Sstevel@tonic-gate #include <sys/param.h>
347c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
357c478bd9Sstevel@tonic-gate #include <sys/signal.h>
367c478bd9Sstevel@tonic-gate #include <sys/systm.h>
377c478bd9Sstevel@tonic-gate #include <sys/user.h>
387c478bd9Sstevel@tonic-gate #include <sys/mman.h>
397c478bd9Sstevel@tonic-gate #include <sys/vm.h>
407c478bd9Sstevel@tonic-gate #include <sys/conf.h>
417c478bd9Sstevel@tonic-gate #include <sys/avintr.h>
427c478bd9Sstevel@tonic-gate #include <sys/autoconf.h>
437c478bd9Sstevel@tonic-gate #include <sys/disp.h>
447c478bd9Sstevel@tonic-gate #include <sys/class.h>
457c478bd9Sstevel@tonic-gate #include <sys/bitmap.h>
467c478bd9Sstevel@tonic-gate 
477c478bd9Sstevel@tonic-gate #include <sys/privregs.h>
487c478bd9Sstevel@tonic-gate 
497c478bd9Sstevel@tonic-gate #include <sys/proc.h>
507c478bd9Sstevel@tonic-gate #include <sys/buf.h>
517c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
52ae115bc7Smrj #include <sys/mem.h>
537c478bd9Sstevel@tonic-gate #include <sys/kstat.h>
547c478bd9Sstevel@tonic-gate 
557c478bd9Sstevel@tonic-gate #include <sys/reboot.h>
567c478bd9Sstevel@tonic-gate 
577c478bd9Sstevel@tonic-gate #include <sys/cred.h>
587c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
597c478bd9Sstevel@tonic-gate #include <sys/file.h>
607c478bd9Sstevel@tonic-gate 
617c478bd9Sstevel@tonic-gate #include <sys/procfs.h>
627c478bd9Sstevel@tonic-gate 
637c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
647c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
657c478bd9Sstevel@tonic-gate #include <sys/utsname.h>
667c478bd9Sstevel@tonic-gate #include <sys/debug.h>
677c478bd9Sstevel@tonic-gate #include <sys/kdi.h>
687c478bd9Sstevel@tonic-gate 
697c478bd9Sstevel@tonic-gate #include <sys/dumphdr.h>
707c478bd9Sstevel@tonic-gate #include <sys/bootconf.h>
71a3114836SGerry Liu #include <sys/memlist_plat.h>
727c478bd9Sstevel@tonic-gate #include <sys/varargs.h>
737c478bd9Sstevel@tonic-gate #include <sys/promif.h>
74843e1988Sjohnlev #include <sys/modctl.h>
757c478bd9Sstevel@tonic-gate 
767c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
777c478bd9Sstevel@tonic-gate #include <sys/sunndi.h>
787c478bd9Sstevel@tonic-gate #include <sys/ndi_impldefs.h>
797c478bd9Sstevel@tonic-gate #include <sys/ddidmareq.h>
807c478bd9Sstevel@tonic-gate #include <sys/psw.h>
817c478bd9Sstevel@tonic-gate #include <sys/regset.h>
827c478bd9Sstevel@tonic-gate #include <sys/clock.h>
837c478bd9Sstevel@tonic-gate #include <sys/pte.h>
847c478bd9Sstevel@tonic-gate #include <sys/tss.h>
857c478bd9Sstevel@tonic-gate #include <sys/stack.h>
867c478bd9Sstevel@tonic-gate #include <sys/trap.h>
877c478bd9Sstevel@tonic-gate #include <sys/fp.h>
881d03c31eSjohnlev #include <vm/kboot_mmu.h>
897c478bd9Sstevel@tonic-gate #include <vm/anon.h>
907c478bd9Sstevel@tonic-gate #include <vm/as.h>
917c478bd9Sstevel@tonic-gate #include <vm/page.h>
927c478bd9Sstevel@tonic-gate #include <vm/seg.h>
937c478bd9Sstevel@tonic-gate #include <vm/seg_dev.h>
947c478bd9Sstevel@tonic-gate #include <vm/seg_kmem.h>
957c478bd9Sstevel@tonic-gate #include <vm/seg_kpm.h>
967c478bd9Sstevel@tonic-gate #include <vm/seg_map.h>
977c478bd9Sstevel@tonic-gate #include <vm/seg_vn.h>
987c478bd9Sstevel@tonic-gate #include <vm/seg_kp.h>
997c478bd9Sstevel@tonic-gate #include <sys/memnode.h>
1007c478bd9Sstevel@tonic-gate #include <vm/vm_dep.h>
1017c478bd9Sstevel@tonic-gate #include <sys/thread.h>
1027c478bd9Sstevel@tonic-gate #include <sys/sysconf.h>
1037c478bd9Sstevel@tonic-gate #include <sys/vm_machparam.h>
1047c478bd9Sstevel@tonic-gate #include <sys/archsystm.h>
1057c478bd9Sstevel@tonic-gate #include <sys/machsystm.h>
1067c478bd9Sstevel@tonic-gate #include <vm/hat.h>
1077c478bd9Sstevel@tonic-gate #include <vm/hat_i86.h>
1087c478bd9Sstevel@tonic-gate #include <sys/pmem.h>
1097c478bd9Sstevel@tonic-gate #include <sys/smp_impldefs.h>
1107c478bd9Sstevel@tonic-gate #include <sys/x86_archext.h>
111a563a037Sbholler #include <sys/cpuvar.h>
1127c478bd9Sstevel@tonic-gate #include <sys/segments.h>
1137c478bd9Sstevel@tonic-gate #include <sys/clconf.h>
1147c478bd9Sstevel@tonic-gate #include <sys/kobj.h>
1157c478bd9Sstevel@tonic-gate #include <sys/kobj_lex.h>
1167c478bd9Sstevel@tonic-gate #include <sys/cpc_impl.h>
1177aec1d6eScindi #include <sys/cpu_module.h>
11884ab085aSmws #include <sys/smbios.h>
119ae115bc7Smrj #include <sys/debug_info.h>
1201d03c31eSjohnlev #include <sys/bootinfo.h>
121dd4eeefdSeota #include <sys/ddi_timer.h>
1225679c89fSjv227347 #include <sys/systeminfo.h>
12319397407SSherry Moore #include <sys/multiboot.h>
124ae115bc7Smrj 
125843e1988Sjohnlev #ifdef	__xpv
1261d03c31eSjohnlev 
127843e1988Sjohnlev #include <sys/hypervisor.h>
128843e1988Sjohnlev #include <sys/xen_mmu.h>
129843e1988Sjohnlev #include <sys/evtchn_impl.h>
130843e1988Sjohnlev #include <sys/gnttab.h>
131843e1988Sjohnlev #include <sys/xpv_panic.h>
132843e1988Sjohnlev #include <xen/sys/xenbus_comms.h>
133843e1988Sjohnlev #include <xen/public/physdev.h>
134ae115bc7Smrj 
1351d03c31eSjohnlev extern void xen_late_startup(void);
1361d03c31eSjohnlev 
1371d03c31eSjohnlev struct xen_evt_data cpu0_evt_data;
1381d03c31eSjohnlev 
139a3114836SGerry Liu #else	/* __xpv */
140a3114836SGerry Liu #include <sys/memlist_impl.h>
141a3114836SGerry Liu 
142a3114836SGerry Liu extern void mem_config_init(void);
1431d03c31eSjohnlev #endif /* __xpv */
1447c478bd9Sstevel@tonic-gate 
1457c478bd9Sstevel@tonic-gate extern void progressbar_init(void);
1469acbbeafSnn35248 extern void brand_init(void);
14706fb6a36Sdv142724 extern void pcf_init(void);
1480e751525SEric Saxe extern void pg_init(void);
1497c478bd9Sstevel@tonic-gate 
150d7d93655Sblakej extern int size_pse_array(pgcnt_t, int);
151d7d93655Sblakej 
152ed5289f9SKen Erickson #if defined(_SOFT_HOSTID)
153ed5289f9SKen Erickson 
154ed5289f9SKen Erickson #include <sys/rtc.h>
155ed5289f9SKen Erickson 
156ed5289f9SKen Erickson static int32_t set_soft_hostid(void);
157ed5289f9SKen Erickson static char hostid_file[] = "/etc/hostid";
158ed5289f9SKen Erickson 
159ed5289f9SKen Erickson #endif
160ed5289f9SKen Erickson 
16194f1124eSVikram Hegde void *gfx_devinfo_list;
162ed5289f9SKen Erickson 
1633a634bfcSVikram Hegde #if defined(__amd64) && !defined(__xpv)
1643a634bfcSVikram Hegde extern void immu_startup(void);
1653a634bfcSVikram Hegde #endif
1663a634bfcSVikram Hegde 
1677c478bd9Sstevel@tonic-gate /*
1687c478bd9Sstevel@tonic-gate  * XXX make declaration below "static" when drivers no longer use this
1697c478bd9Sstevel@tonic-gate  * interface.
1707c478bd9Sstevel@tonic-gate  */
1717c478bd9Sstevel@tonic-gate extern caddr_t p0_va;	/* Virtual address for accessing physical page 0 */
1727c478bd9Sstevel@tonic-gate 
1737c478bd9Sstevel@tonic-gate /*
1747c478bd9Sstevel@tonic-gate  * segkp
1757c478bd9Sstevel@tonic-gate  */
1767c478bd9Sstevel@tonic-gate extern int segkp_fromheap;
1777c478bd9Sstevel@tonic-gate 
1787c478bd9Sstevel@tonic-gate static void kvm_init(void);
1797c478bd9Sstevel@tonic-gate static void startup_init(void);
1807c478bd9Sstevel@tonic-gate static void startup_memlist(void);
181ae115bc7Smrj static void startup_kmem(void);
1827c478bd9Sstevel@tonic-gate static void startup_modules(void);
1837c478bd9Sstevel@tonic-gate static void startup_vm(void);
1847c478bd9Sstevel@tonic-gate static void startup_end(void);
18535b1ab99Sjosephb static void layout_kernel_va(void);
1867c478bd9Sstevel@tonic-gate 
1877c478bd9Sstevel@tonic-gate /*
1887c478bd9Sstevel@tonic-gate  * Declare these as initialized data so we can patch them.
1897c478bd9Sstevel@tonic-gate  */
190f53ad214Skchow #ifdef __i386
19135b1ab99Sjosephb 
192f53ad214Skchow /*
193f53ad214Skchow  * Due to virtual address space limitations running in 32 bit mode, restrict
19435b1ab99Sjosephb  * the amount of physical memory configured to a max of PHYSMEM pages (16g).
195f53ad214Skchow  *
196f53ad214Skchow  * If the physical max memory size of 64g were allowed to be configured, the
197f53ad214Skchow  * size of user virtual address space will be less than 1g. A limited user
198f53ad214Skchow  * address space greatly reduces the range of applications that can run.
199f53ad214Skchow  *
20035b1ab99Sjosephb  * If more physical memory than PHYSMEM is required, users should preferably
20135b1ab99Sjosephb  * run in 64 bit mode which has far looser virtual address space limitations.
202f53ad214Skchow  *
203f53ad214Skchow  * If 64 bit mode is not available (as in IA32) and/or more physical memory
20435b1ab99Sjosephb  * than PHYSMEM is required in 32 bit mode, physmem can be set to the desired
205f53ad214Skchow  * value or to 0 (to configure all available memory) via eeprom(1M). kernelbase
206f53ad214Skchow  * should also be carefully tuned to balance out the need of the user
207f53ad214Skchow  * application while minimizing the risk of kernel heap exhaustion due to
208f53ad214Skchow  * kernelbase being set too high.
209f53ad214Skchow  */
21035b1ab99Sjosephb #define	PHYSMEM	0x400000
211f53ad214Skchow 
21235b1ab99Sjosephb #else /* __amd64 */
21335b1ab99Sjosephb 
21435b1ab99Sjosephb /*
21535b1ab99Sjosephb  * For now we can handle memory with physical addresses up to about
21635b1ab99Sjosephb  * 64 Terabytes. This keeps the kernel above the VA hole, leaving roughly
21735b1ab99Sjosephb  * half the VA space for seg_kpm. When systems get bigger than 64TB this
21835b1ab99Sjosephb  * code will need revisiting. There is an implicit assumption that there
21935b1ab99Sjosephb  * are no *huge* holes in the physical address space too.
22035b1ab99Sjosephb  */
22135b1ab99Sjosephb #define	TERABYTE		(1ul << 40)
22235b1ab99Sjosephb #define	PHYSMEM_MAX64		mmu_btop(64 * TERABYTE)
22335b1ab99Sjosephb #define	PHYSMEM			PHYSMEM_MAX64
22435b1ab99Sjosephb #define	AMD64_VA_HOLE_END	0xFFFF800000000000ul
22535b1ab99Sjosephb 
22635b1ab99Sjosephb #endif /* __amd64 */
22735b1ab99Sjosephb 
22835b1ab99Sjosephb pgcnt_t physmem = PHYSMEM;
2297c478bd9Sstevel@tonic-gate pgcnt_t obp_pages;	/* Memory used by PROM for its text and data */
2307c478bd9Sstevel@tonic-gate 
2317c478bd9Sstevel@tonic-gate char *kobj_file_buf;
2327c478bd9Sstevel@tonic-gate int kobj_file_bufsize;	/* set in /etc/system */
2337c478bd9Sstevel@tonic-gate 
2347c478bd9Sstevel@tonic-gate /* Global variables for MP support. Used in mp_startup */
23519397407SSherry Moore caddr_t	rm_platter_va = 0;
2367c478bd9Sstevel@tonic-gate uint32_t rm_platter_pa;
2377c478bd9Sstevel@tonic-gate 
23883f9b804Skchow int	auto_lpg_disable = 1;
23983f9b804Skchow 
2407c478bd9Sstevel@tonic-gate /*
2417c478bd9Sstevel@tonic-gate  * Some CPUs have holes in the middle of the 64-bit virtual address range.
2427c478bd9Sstevel@tonic-gate  */
2437c478bd9Sstevel@tonic-gate uintptr_t hole_start, hole_end;
2447c478bd9Sstevel@tonic-gate 
2457c478bd9Sstevel@tonic-gate /*
2467c478bd9Sstevel@tonic-gate  * kpm mapping window
2477c478bd9Sstevel@tonic-gate  */
2487c478bd9Sstevel@tonic-gate caddr_t kpm_vbase;
2497c478bd9Sstevel@tonic-gate size_t  kpm_size;
25035b1ab99Sjosephb static int kpm_desired;
25135b1ab99Sjosephb #ifdef __amd64
25235b1ab99Sjosephb static uintptr_t segkpm_base = (uintptr_t)SEGKPM_BASE;
25335b1ab99Sjosephb #endif
2547c478bd9Sstevel@tonic-gate 
2557c478bd9Sstevel@tonic-gate /*
2567c478bd9Sstevel@tonic-gate  * Configuration parameters set at boot time.
2577c478bd9Sstevel@tonic-gate  */
2587c478bd9Sstevel@tonic-gate 
2597c478bd9Sstevel@tonic-gate caddr_t econtig;		/* end of first block of contiguous kernel */
2607c478bd9Sstevel@tonic-gate 
2617c478bd9Sstevel@tonic-gate struct bootops		*bootops = 0;	/* passed in from boot */
2627c478bd9Sstevel@tonic-gate struct bootops		**bootopsp;
2637c478bd9Sstevel@tonic-gate struct boot_syscalls	*sysp;		/* passed in from boot */
2647c478bd9Sstevel@tonic-gate 
2657c478bd9Sstevel@tonic-gate char bootblock_fstype[16];
2667c478bd9Sstevel@tonic-gate 
2677c478bd9Sstevel@tonic-gate char kern_bootargs[OBP_MAXPATHLEN];
26819397407SSherry Moore char kern_bootfile[OBP_MAXPATHLEN];
2697c478bd9Sstevel@tonic-gate 
2707c478bd9Sstevel@tonic-gate /*
271ad23a2dbSjohansen  * ZFS zio segment.  This allows us to exclude large portions of ZFS data that
272ad23a2dbSjohansen  * gets cached in kmem caches on the heap.  If this is set to zero, we allocate
273ad23a2dbSjohansen  * zio buffers from their own segment, otherwise they are allocated from the
274ad23a2dbSjohansen  * heap.  The optimization of allocating zio buffers from their own segment is
275ad23a2dbSjohansen  * only valid on 64-bit kernels.
276ad23a2dbSjohansen  */
277ad23a2dbSjohansen #if defined(__amd64)
278ad23a2dbSjohansen int segzio_fromheap = 0;
279ad23a2dbSjohansen #else
280ad23a2dbSjohansen int segzio_fromheap = 1;
281ad23a2dbSjohansen #endif
282ad23a2dbSjohansen 
283ad23a2dbSjohansen /*
2847c478bd9Sstevel@tonic-gate  * new memory fragmentations are possible in startup() due to BOP_ALLOCs. this
2857c478bd9Sstevel@tonic-gate  * depends on number of BOP_ALLOC calls made and requested size, memory size
2867c478bd9Sstevel@tonic-gate  * combination and whether boot.bin memory needs to be freed.
2877c478bd9Sstevel@tonic-gate  */
2887c478bd9Sstevel@tonic-gate #define	POSS_NEW_FRAGMENTS	12
2897c478bd9Sstevel@tonic-gate 
2907c478bd9Sstevel@tonic-gate /*
2917c478bd9Sstevel@tonic-gate  * VM data structures
2927c478bd9Sstevel@tonic-gate  */
2937c478bd9Sstevel@tonic-gate long page_hashsz;		/* Size of page hash table (power of two) */
294cb15d5d9SPeter Rival unsigned int page_hashsz_shift;	/* log2(page_hashsz) */
2957c478bd9Sstevel@tonic-gate struct page *pp_base;		/* Base of initial system page struct array */
2967c478bd9Sstevel@tonic-gate struct page **page_hash;	/* Page hash table */
297d7d93655Sblakej pad_mutex_t *pse_mutex;		/* Locks protecting pp->p_selock */
298d7d93655Sblakej size_t pse_table_size;		/* Number of mutexes in pse_mutex[] */
299d7d93655Sblakej int pse_shift;			/* log2(pse_table_size) */
3007c478bd9Sstevel@tonic-gate struct seg ktextseg;		/* Segment used for kernel executable image */
3017c478bd9Sstevel@tonic-gate struct seg kvalloc;		/* Segment used for "valloc" mapping */
3027c478bd9Sstevel@tonic-gate struct seg kpseg;		/* Segment used for pageable kernel virt mem */
3037c478bd9Sstevel@tonic-gate struct seg kmapseg;		/* Segment used for generic kernel mappings */
3047c478bd9Sstevel@tonic-gate struct seg kdebugseg;		/* Segment used for the kernel debugger */
3057c478bd9Sstevel@tonic-gate 
3067c478bd9Sstevel@tonic-gate struct seg *segkmap = &kmapseg;	/* Kernel generic mapping segment */
307ae115bc7Smrj static struct seg *segmap = &kmapseg;	/* easier to use name for in here */
308ae115bc7Smrj 
3097c478bd9Sstevel@tonic-gate struct seg *segkp = &kpseg;	/* Pageable kernel virtual memory segment */
3107c478bd9Sstevel@tonic-gate 
3117c478bd9Sstevel@tonic-gate #if defined(__amd64)
3127c478bd9Sstevel@tonic-gate struct seg kvseg_core;		/* Segment used for the core heap */
3137c478bd9Sstevel@tonic-gate struct seg kpmseg;		/* Segment used for physical mapping */
3147c478bd9Sstevel@tonic-gate struct seg *segkpm = &kpmseg;	/* 64bit kernel physical mapping segment */
3157c478bd9Sstevel@tonic-gate #else
3167c478bd9Sstevel@tonic-gate struct seg *segkpm = NULL;	/* Unused on IA32 */
3177c478bd9Sstevel@tonic-gate #endif
3187c478bd9Sstevel@tonic-gate 
3197c478bd9Sstevel@tonic-gate caddr_t segkp_base;		/* Base address of segkp */
320ad23a2dbSjohansen caddr_t segzio_base;		/* Base address of segzio */
3217c478bd9Sstevel@tonic-gate #if defined(__amd64)
3227c478bd9Sstevel@tonic-gate pgcnt_t segkpsize = btop(SEGKPDEFSIZE);	/* size of segkp segment in pages */
3237c478bd9Sstevel@tonic-gate #else
3247c478bd9Sstevel@tonic-gate pgcnt_t segkpsize = 0;
3257c478bd9Sstevel@tonic-gate #endif
326ad23a2dbSjohansen pgcnt_t segziosize = 0;		/* size of zio segment in pages */
3277c478bd9Sstevel@tonic-gate 
328ae115bc7Smrj /*
329a3114836SGerry Liu  * A static DR page_t VA map is reserved that can map the page structures
330a3114836SGerry Liu  * for a domain's entire RA space. The pages that back this space are
331a3114836SGerry Liu  * dynamically allocated and need not be physically contiguous.  The DR
332a3114836SGerry Liu  * map size is derived from KPM size.
333a3114836SGerry Liu  * This mechanism isn't used by x86 yet, so just stubs here.
334a3114836SGerry Liu  */
335a3114836SGerry Liu int ppvm_enable = 0;		/* Static virtual map for page structs */
336a3114836SGerry Liu page_t *ppvm_base = NULL;	/* Base of page struct map */
337a3114836SGerry Liu pgcnt_t ppvm_size = 0;		/* Size of page struct map */
338a3114836SGerry Liu 
339a3114836SGerry Liu /*
340ae115bc7Smrj  * VA range available to the debugger
341ae115bc7Smrj  */
342ae115bc7Smrj const caddr_t kdi_segdebugbase = (const caddr_t)SEGDEBUGBASE;
343ae115bc7Smrj const size_t kdi_segdebugsize = SEGDEBUGSIZE;
344ae115bc7Smrj 
3457c478bd9Sstevel@tonic-gate struct memseg *memseg_base;
3467c478bd9Sstevel@tonic-gate struct vnode unused_pages_vp;
3477c478bd9Sstevel@tonic-gate 
3487c478bd9Sstevel@tonic-gate #define	FOURGB	0x100000000LL
3497c478bd9Sstevel@tonic-gate 
3507c478bd9Sstevel@tonic-gate struct memlist *memlist;
3517c478bd9Sstevel@tonic-gate 
3527c478bd9Sstevel@tonic-gate caddr_t s_text;		/* start of kernel text segment */
3537c478bd9Sstevel@tonic-gate caddr_t e_text;		/* end of kernel text segment */
3547c478bd9Sstevel@tonic-gate caddr_t s_data;		/* start of kernel data segment */
3557c478bd9Sstevel@tonic-gate caddr_t e_data;		/* end of kernel data segment */
3567c478bd9Sstevel@tonic-gate caddr_t modtext;	/* start of loadable module text reserved */
3577c478bd9Sstevel@tonic-gate caddr_t e_modtext;	/* end of loadable module text reserved */
3587c478bd9Sstevel@tonic-gate caddr_t moddata;	/* start of loadable module data reserved */
3597c478bd9Sstevel@tonic-gate caddr_t e_moddata;	/* end of loadable module data reserved */
3607c478bd9Sstevel@tonic-gate 
3617c478bd9Sstevel@tonic-gate struct memlist *phys_install;	/* Total installed physical memory */
3627c478bd9Sstevel@tonic-gate struct memlist *phys_avail;	/* Total available physical memory */
3631de082f7SVikram Hegde struct memlist *bios_rsvd;	/* Bios reserved memory */
3647c478bd9Sstevel@tonic-gate 
3657c478bd9Sstevel@tonic-gate /*
3667c478bd9Sstevel@tonic-gate  * kphysm_init returns the number of pages that were processed
3677c478bd9Sstevel@tonic-gate  */
368ae115bc7Smrj static pgcnt_t kphysm_init(page_t *, pgcnt_t);
3697c478bd9Sstevel@tonic-gate 
3707c478bd9Sstevel@tonic-gate #define	IO_PROP_SIZE	64	/* device property size */
3717c478bd9Sstevel@tonic-gate 
3727c478bd9Sstevel@tonic-gate /*
3737c478bd9Sstevel@tonic-gate  * a couple useful roundup macros
3747c478bd9Sstevel@tonic-gate  */
3757c478bd9Sstevel@tonic-gate #define	ROUND_UP_PAGE(x)	\
3767c478bd9Sstevel@tonic-gate 	((uintptr_t)P2ROUNDUP((uintptr_t)(x), (uintptr_t)MMU_PAGESIZE))
3777c478bd9Sstevel@tonic-gate #define	ROUND_UP_LPAGE(x)	\
3787c478bd9Sstevel@tonic-gate 	((uintptr_t)P2ROUNDUP((uintptr_t)(x), mmu.level_size[1]))
3797c478bd9Sstevel@tonic-gate #define	ROUND_UP_4MEG(x)	\
380ae115bc7Smrj 	((uintptr_t)P2ROUNDUP((uintptr_t)(x), (uintptr_t)FOUR_MEG))
3817c478bd9Sstevel@tonic-gate #define	ROUND_UP_TOPLEVEL(x)	\
3827c478bd9Sstevel@tonic-gate 	((uintptr_t)P2ROUNDUP((uintptr_t)(x), mmu.level_size[mmu.max_level]))
3837c478bd9Sstevel@tonic-gate 
3847c478bd9Sstevel@tonic-gate /*
3857c478bd9Sstevel@tonic-gate  *	32-bit Kernel's Virtual memory layout.
3867c478bd9Sstevel@tonic-gate  *		+-----------------------+
387ae115bc7Smrj  *		|			|
3887c478bd9Sstevel@tonic-gate  * 0xFFC00000  -|-----------------------|- ARGSBASE
3897c478bd9Sstevel@tonic-gate  *		|	debugger	|
3907c478bd9Sstevel@tonic-gate  * 0xFF800000  -|-----------------------|- SEGDEBUGBASE
3917c478bd9Sstevel@tonic-gate  *		|      Kernel Data	|
3927c478bd9Sstevel@tonic-gate  * 0xFEC00000  -|-----------------------|
3937c478bd9Sstevel@tonic-gate  *              |      Kernel Text	|
394843e1988Sjohnlev  * 0xFE800000  -|-----------------------|- KERNEL_TEXT (0xFB400000 on Xen)
395ae115bc7Smrj  *		|---       GDT       ---|- GDT page (GDT_VA)
396ae115bc7Smrj  *		|---    debug info   ---|- debug info (DEBUG_INFO_VA)
397ae115bc7Smrj  *		|			|
398ae115bc7Smrj  * 		|   page_t structures	|
3997c478bd9Sstevel@tonic-gate  * 		|   memsegs, memlists, 	|
4007c478bd9Sstevel@tonic-gate  * 		|   page hash, etc.	|
401ae115bc7Smrj  * ---	       -|-----------------------|- ekernelheap, valloc_base (floating)
402ae115bc7Smrj  *		|			|  (segkp is just an arena in the heap)
4037c478bd9Sstevel@tonic-gate  *		|			|
4047c478bd9Sstevel@tonic-gate  *		|	kvseg		|
4057c478bd9Sstevel@tonic-gate  *		|			|
4067c478bd9Sstevel@tonic-gate  *		|			|
4077c478bd9Sstevel@tonic-gate  * ---         -|-----------------------|- kernelheap (floating)
4087c478bd9Sstevel@tonic-gate  * 		|        Segkmap	|
409ae115bc7Smrj  * 0xC3002000  -|-----------------------|- segmap_start (floating)
4107c478bd9Sstevel@tonic-gate  *		|	Red Zone	|
4117c478bd9Sstevel@tonic-gate  * 0xC3000000  -|-----------------------|- kernelbase / userlimit (floating)
4127c478bd9Sstevel@tonic-gate  *		|			|			||
4137c478bd9Sstevel@tonic-gate  *		|     Shared objects	|			\/
4147c478bd9Sstevel@tonic-gate  *		|			|
4157c478bd9Sstevel@tonic-gate  *		:			:
4167c478bd9Sstevel@tonic-gate  *		|	user data	|
4177c478bd9Sstevel@tonic-gate  *		|-----------------------|
4187c478bd9Sstevel@tonic-gate  *		|	user text	|
4197c478bd9Sstevel@tonic-gate  * 0x08048000  -|-----------------------|
4207c478bd9Sstevel@tonic-gate  *		|	user stack	|
4217c478bd9Sstevel@tonic-gate  *		:			:
4227c478bd9Sstevel@tonic-gate  *		|	invalid		|
4237c478bd9Sstevel@tonic-gate  * 0x00000000	+-----------------------+
4247c478bd9Sstevel@tonic-gate  *
4257c478bd9Sstevel@tonic-gate  *
4267c478bd9Sstevel@tonic-gate  *		64-bit Kernel's Virtual memory layout. (assuming 64 bit app)
4277c478bd9Sstevel@tonic-gate  *			+-----------------------+
428ae115bc7Smrj  *			|			|
4297c478bd9Sstevel@tonic-gate  * 0xFFFFFFFF.FFC00000  |-----------------------|- ARGSBASE
4307c478bd9Sstevel@tonic-gate  *			|	debugger (?)	|
4317c478bd9Sstevel@tonic-gate  * 0xFFFFFFFF.FF800000  |-----------------------|- SEGDEBUGBASE
4327c478bd9Sstevel@tonic-gate  *			|      unused    	|
4337c478bd9Sstevel@tonic-gate  *			+-----------------------+
4347c478bd9Sstevel@tonic-gate  *			|      Kernel Data	|
4357c478bd9Sstevel@tonic-gate  * 0xFFFFFFFF.FBC00000  |-----------------------|
4367c478bd9Sstevel@tonic-gate  *			|      Kernel Text	|
4377c478bd9Sstevel@tonic-gate  * 0xFFFFFFFF.FB800000  |-----------------------|- KERNEL_TEXT
438ae115bc7Smrj  *			|---       GDT       ---|- GDT page (GDT_VA)
439ae115bc7Smrj  *			|---    debug info   ---|- debug info (DEBUG_INFO_VA)
440ae115bc7Smrj  *			|			|
4417c478bd9Sstevel@tonic-gate  * 			|      Core heap	| (used for loadable modules)
4427c478bd9Sstevel@tonic-gate  * 0xFFFFFFFF.C0000000  |-----------------------|- core_base / ekernelheap
4437c478bd9Sstevel@tonic-gate  *			|	 Kernel		|
4447c478bd9Sstevel@tonic-gate  *			|	  heap		|
4457c478bd9Sstevel@tonic-gate  * 0xFFFFFXXX.XXX00000  |-----------------------|- kernelheap (floating)
446ae115bc7Smrj  *			|	 segmap		|
447ae115bc7Smrj  * 0xFFFFFXXX.XXX00000  |-----------------------|- segmap_start (floating)
4487c478bd9Sstevel@tonic-gate  *			|    device mappings	|
4497c478bd9Sstevel@tonic-gate  * 0xFFFFFXXX.XXX00000  |-----------------------|- toxic_addr (floating)
450ad23a2dbSjohansen  *			|	  segzio	|
451ad23a2dbSjohansen  * 0xFFFFFXXX.XXX00000  |-----------------------|- segzio_base (floating)
4527c478bd9Sstevel@tonic-gate  *			|	  segkp		|
453ae115bc7Smrj  * ---                  |-----------------------|- segkp_base (floating)
454ae115bc7Smrj  * 			|   page_t structures	|  valloc_base + valloc_sz
455ae115bc7Smrj  * 			|   memsegs, memlists, 	|
456ae115bc7Smrj  * 			|   page hash, etc.	|
45735b1ab99Sjosephb  * 0xFFFFFF00.00000000  |-----------------------|- valloc_base (lower if > 1TB)
4587c478bd9Sstevel@tonic-gate  *			|	 segkpm		|
4597c478bd9Sstevel@tonic-gate  * 0xFFFFFE00.00000000  |-----------------------|
4607c478bd9Sstevel@tonic-gate  *			|	Red Zone	|
46135b1ab99Sjosephb  * 0xFFFFFD80.00000000  |-----------------------|- KERNELBASE (lower if > 1TB)
4627c478bd9Sstevel@tonic-gate  *			|     User stack	|- User space memory
4637c478bd9Sstevel@tonic-gate  * 			|			|
4647c478bd9Sstevel@tonic-gate  * 			| shared objects, etc	|	(grows downwards)
4657c478bd9Sstevel@tonic-gate  *			:			:
4667c478bd9Sstevel@tonic-gate  * 			|			|
4677c478bd9Sstevel@tonic-gate  * 0xFFFF8000.00000000  |-----------------------|
4687c478bd9Sstevel@tonic-gate  * 			|			|
4697c478bd9Sstevel@tonic-gate  * 			| VA Hole / unused	|
4707c478bd9Sstevel@tonic-gate  * 			|			|
4717c478bd9Sstevel@tonic-gate  * 0x00008000.00000000  |-----------------------|
4727c478bd9Sstevel@tonic-gate  *			|			|
4737c478bd9Sstevel@tonic-gate  *			|			|
4747c478bd9Sstevel@tonic-gate  *			:			:
4757c478bd9Sstevel@tonic-gate  *			|	user heap	|	(grows upwards)
4767c478bd9Sstevel@tonic-gate  *			|			|
4777c478bd9Sstevel@tonic-gate  *			|	user data	|
4787c478bd9Sstevel@tonic-gate  *			|-----------------------|
4797c478bd9Sstevel@tonic-gate  *			|	user text	|
4807c478bd9Sstevel@tonic-gate  * 0x00000000.04000000  |-----------------------|
4817c478bd9Sstevel@tonic-gate  *			|	invalid		|
4827c478bd9Sstevel@tonic-gate  * 0x00000000.00000000	+-----------------------+
4837c478bd9Sstevel@tonic-gate  *
4847c478bd9Sstevel@tonic-gate  * A 32 bit app on the 64 bit kernel sees the same layout as on the 32 bit
4857c478bd9Sstevel@tonic-gate  * kernel, except that userlimit is raised to 0xfe000000
4867c478bd9Sstevel@tonic-gate  *
4877c478bd9Sstevel@tonic-gate  * Floating values:
4887c478bd9Sstevel@tonic-gate  *
4897c478bd9Sstevel@tonic-gate  * valloc_base: start of the kernel's memory management/tracking data
490ae115bc7Smrj  * structures.  This region contains page_t structures for
491ae115bc7Smrj  * physical memory, memsegs, memlists, and the page hash.
4927c478bd9Sstevel@tonic-gate  *
4937c478bd9Sstevel@tonic-gate  * core_base: start of the kernel's "core" heap area on 64-bit systems.
4947c478bd9Sstevel@tonic-gate  * This area is intended to be used for global data as well as for module
4957c478bd9Sstevel@tonic-gate  * text/data that does not fit into the nucleus pages.  The core heap is
4967c478bd9Sstevel@tonic-gate  * restricted to a 2GB range, allowing every address within it to be
4977c478bd9Sstevel@tonic-gate  * accessed using rip-relative addressing
4987c478bd9Sstevel@tonic-gate  *
4997c478bd9Sstevel@tonic-gate  * ekernelheap: end of kernelheap and start of segmap.
5007c478bd9Sstevel@tonic-gate  *
5017c478bd9Sstevel@tonic-gate  * kernelheap: start of kernel heap.  On 32-bit systems, this starts right
5027c478bd9Sstevel@tonic-gate  * above a red zone that separates the user's address space from the
5037c478bd9Sstevel@tonic-gate  * kernel's.  On 64-bit systems, it sits above segkp and segkpm.
5047c478bd9Sstevel@tonic-gate  *
505ae115bc7Smrj  * segmap_start: start of segmap. The length of segmap can be modified
50652eef812SAmrita Sadhukhan  * through eeprom. The default length is 16MB on 32-bit systems and 64MB
50752eef812SAmrita Sadhukhan  * on 64-bit systems.
5087c478bd9Sstevel@tonic-gate  *
5097c478bd9Sstevel@tonic-gate  * kernelbase: On a 32-bit kernel the default value of 0xd4000000 will be
5107c478bd9Sstevel@tonic-gate  * decreased by 2X the size required for page_t.  This allows the kernel
5117c478bd9Sstevel@tonic-gate  * heap to grow in size with physical memory.  With sizeof(page_t) == 80
5127c478bd9Sstevel@tonic-gate  * bytes, the following shows the values of kernelbase and kernel heap
5137c478bd9Sstevel@tonic-gate  * sizes for different memory configurations (assuming default segmap and
5147c478bd9Sstevel@tonic-gate  * segkp sizes).
5157c478bd9Sstevel@tonic-gate  *
5167c478bd9Sstevel@tonic-gate  *	mem	size for	kernelbase	kernel heap
5177c478bd9Sstevel@tonic-gate  *	size	page_t's			size
5187c478bd9Sstevel@tonic-gate  *	----	---------	----------	-----------
5197c478bd9Sstevel@tonic-gate  *	1gb	0x01400000	0xd1800000	684MB
5207c478bd9Sstevel@tonic-gate  *	2gb	0x02800000	0xcf000000	704MB
5217c478bd9Sstevel@tonic-gate  *	4gb	0x05000000	0xca000000	744MB
5227c478bd9Sstevel@tonic-gate  *	6gb	0x07800000	0xc5000000	784MB
5237c478bd9Sstevel@tonic-gate  *	8gb	0x0a000000	0xc0000000	824MB
5247c478bd9Sstevel@tonic-gate  *	16gb	0x14000000	0xac000000	984MB
5257c478bd9Sstevel@tonic-gate  *	32gb	0x28000000	0x84000000	1304MB
5267c478bd9Sstevel@tonic-gate  *	64gb	0x50000000	0x34000000	1944MB (*)
5277c478bd9Sstevel@tonic-gate  *
5287c478bd9Sstevel@tonic-gate  * kernelbase is less than the abi minimum of 0xc0000000 for memory
5297c478bd9Sstevel@tonic-gate  * configurations above 8gb.
5307c478bd9Sstevel@tonic-gate  *
5317c478bd9Sstevel@tonic-gate  * (*) support for memory configurations above 32gb will require manual tuning
5327c478bd9Sstevel@tonic-gate  * of kernelbase to balance out the need of user applications.
5337c478bd9Sstevel@tonic-gate  */
5347c478bd9Sstevel@tonic-gate 
5357c478bd9Sstevel@tonic-gate /* real-time-clock initialization parameters */
536ae115bc7Smrj extern time_t process_rtc_config_file(void);
5377c478bd9Sstevel@tonic-gate 
5387c478bd9Sstevel@tonic-gate uintptr_t	kernelbase;
539ae115bc7Smrj uintptr_t	postbootkernelbase;	/* not set till boot loader is gone */
5407c478bd9Sstevel@tonic-gate uintptr_t	eprom_kernelbase;
5417c478bd9Sstevel@tonic-gate size_t		segmapsize;
542ae115bc7Smrj uintptr_t	segmap_start;
5437c478bd9Sstevel@tonic-gate int		segmapfreelists;
5447c478bd9Sstevel@tonic-gate pgcnt_t		npages;
545ae115bc7Smrj pgcnt_t		orig_npages;
5467c478bd9Sstevel@tonic-gate size_t		core_size;		/* size of "core" heap */
5477c478bd9Sstevel@tonic-gate uintptr_t	core_base;		/* base address of "core" heap */
5487c478bd9Sstevel@tonic-gate 
5497c478bd9Sstevel@tonic-gate /*
5507c478bd9Sstevel@tonic-gate  * List of bootstrap pages. We mark these as allocated in startup.
5517c478bd9Sstevel@tonic-gate  * release_bootstrap() will free them when we're completely done with
5527c478bd9Sstevel@tonic-gate  * the bootstrap.
5537c478bd9Sstevel@tonic-gate  */
554ae115bc7Smrj static page_t *bootpages;
555ae115bc7Smrj 
556ae115bc7Smrj /*
557ae115bc7Smrj  * boot time pages that have a vnode from the ramdisk will keep that forever.
558ae115bc7Smrj  */
559ae115bc7Smrj static page_t *rd_pages;
5607c478bd9Sstevel@tonic-gate 
56119397407SSherry Moore /*
56219397407SSherry Moore  * Lower 64K
56319397407SSherry Moore  */
56419397407SSherry Moore static page_t *lower_pages = NULL;
56519397407SSherry Moore static int lower_pages_count = 0;
56619397407SSherry Moore 
5677c478bd9Sstevel@tonic-gate struct system_hardware system_hardware;
5687c478bd9Sstevel@tonic-gate 
5697c478bd9Sstevel@tonic-gate /*
5707c478bd9Sstevel@tonic-gate  * Enable some debugging messages concerning memory usage...
5717c478bd9Sstevel@tonic-gate  */
5727c478bd9Sstevel@tonic-gate static void
573ae115bc7Smrj print_memlist(char *title, struct memlist *mp)
5747c478bd9Sstevel@tonic-gate {
5757c478bd9Sstevel@tonic-gate 	prom_printf("MEMLIST: %s:\n", title);
5767c478bd9Sstevel@tonic-gate 	while (mp != NULL)  {
5777c478bd9Sstevel@tonic-gate 		prom_printf("\tAddress 0x%" PRIx64 ", size 0x%" PRIx64 "\n",
57856f33205SJonathan Adams 		    mp->ml_address, mp->ml_size);
57956f33205SJonathan Adams 		mp = mp->ml_next;
5807c478bd9Sstevel@tonic-gate 	}
5817c478bd9Sstevel@tonic-gate }
5827c478bd9Sstevel@tonic-gate 
5837c478bd9Sstevel@tonic-gate /*
5847c478bd9Sstevel@tonic-gate  * XX64 need a comment here.. are these just default values, surely
5857c478bd9Sstevel@tonic-gate  * we read the "cpuid" type information to figure this out.
5867c478bd9Sstevel@tonic-gate  */
5877c478bd9Sstevel@tonic-gate int	l2cache_sz = 0x80000;
5887c478bd9Sstevel@tonic-gate int	l2cache_linesz = 0x40;
5897c478bd9Sstevel@tonic-gate int	l2cache_assoc = 1;
5907c478bd9Sstevel@tonic-gate 
5912cb27123Saguzovsk static size_t	textrepl_min_gb = 10;
5922cb27123Saguzovsk 
5937c478bd9Sstevel@tonic-gate /*
5947c478bd9Sstevel@tonic-gate  * on 64 bit we use a predifined VA range for mapping devices in the kernel
5957c478bd9Sstevel@tonic-gate  * on 32 bit the mappings are intermixed in the heap, so we use a bit map
5967c478bd9Sstevel@tonic-gate  */
5977c478bd9Sstevel@tonic-gate #ifdef __amd64
5987c478bd9Sstevel@tonic-gate 
5997c478bd9Sstevel@tonic-gate vmem_t		*device_arena;
6007c478bd9Sstevel@tonic-gate uintptr_t	toxic_addr = (uintptr_t)NULL;
601ae115bc7Smrj size_t		toxic_size = 1024 * 1024 * 1024; /* Sparc uses 1 gig too */
6027c478bd9Sstevel@tonic-gate 
6037c478bd9Sstevel@tonic-gate #else	/* __i386 */
6047c478bd9Sstevel@tonic-gate 
6057c478bd9Sstevel@tonic-gate ulong_t		*toxic_bit_map;	/* one bit for each 4k of VA in heap_arena */
6067c478bd9Sstevel@tonic-gate size_t		toxic_bit_map_len = 0;	/* in bits */
6077c478bd9Sstevel@tonic-gate 
6087c478bd9Sstevel@tonic-gate #endif	/* __i386 */
6097c478bd9Sstevel@tonic-gate 
6107c478bd9Sstevel@tonic-gate /*
6117c478bd9Sstevel@tonic-gate  * Simple boot time debug facilities
6127c478bd9Sstevel@tonic-gate  */
6137c478bd9Sstevel@tonic-gate static char *prm_dbg_str[] = {
6147c478bd9Sstevel@tonic-gate 	"%s:%d: '%s' is 0x%x\n",
6157c478bd9Sstevel@tonic-gate 	"%s:%d: '%s' is 0x%llx\n"
6167c478bd9Sstevel@tonic-gate };
6177c478bd9Sstevel@tonic-gate 
6187c478bd9Sstevel@tonic-gate int prom_debug;
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate #define	PRM_DEBUG(q)	if (prom_debug) 	\
6217c478bd9Sstevel@tonic-gate 	prom_printf(prm_dbg_str[sizeof (q) >> 3], "startup.c", __LINE__, #q, q);
6227c478bd9Sstevel@tonic-gate #define	PRM_POINT(q)	if (prom_debug) 	\
6237c478bd9Sstevel@tonic-gate 	prom_printf("%s:%d: %s\n", "startup.c", __LINE__, q);
6247c478bd9Sstevel@tonic-gate 
6257c478bd9Sstevel@tonic-gate /*
6267c478bd9Sstevel@tonic-gate  * This structure is used to keep track of the intial allocations
6277c478bd9Sstevel@tonic-gate  * done in startup_memlist(). The value of NUM_ALLOCATIONS needs to
6287c478bd9Sstevel@tonic-gate  * be >= the number of ADD_TO_ALLOCATIONS() executed in the code.
6297c478bd9Sstevel@tonic-gate  */
6301de082f7SVikram Hegde #define	NUM_ALLOCATIONS 8
6317c478bd9Sstevel@tonic-gate int num_allocations = 0;
6327c478bd9Sstevel@tonic-gate struct {
6337c478bd9Sstevel@tonic-gate 	void **al_ptr;
6347c478bd9Sstevel@tonic-gate 	size_t al_size;
6357c478bd9Sstevel@tonic-gate } allocations[NUM_ALLOCATIONS];
6367c478bd9Sstevel@tonic-gate size_t valloc_sz = 0;
6377c478bd9Sstevel@tonic-gate uintptr_t valloc_base;
6387c478bd9Sstevel@tonic-gate 
6397c478bd9Sstevel@tonic-gate #define	ADD_TO_ALLOCATIONS(ptr, size) {					\
6407c478bd9Sstevel@tonic-gate 		size = ROUND_UP_PAGE(size);		 		\
6417c478bd9Sstevel@tonic-gate 		if (num_allocations == NUM_ALLOCATIONS)			\
6427c478bd9Sstevel@tonic-gate 			panic("too many ADD_TO_ALLOCATIONS()");		\
6437c478bd9Sstevel@tonic-gate 		allocations[num_allocations].al_ptr = (void**)&ptr;	\
6447c478bd9Sstevel@tonic-gate 		allocations[num_allocations].al_size = size;		\
6457c478bd9Sstevel@tonic-gate 		valloc_sz += size;					\
6467c478bd9Sstevel@tonic-gate 		++num_allocations;				 	\
6477c478bd9Sstevel@tonic-gate 	}
6487c478bd9Sstevel@tonic-gate 
649ae115bc7Smrj /*
650ae115bc7Smrj  * Allocate all the initial memory needed by the page allocator.
651ae115bc7Smrj  */
6527c478bd9Sstevel@tonic-gate static void
6537c478bd9Sstevel@tonic-gate perform_allocations(void)
6547c478bd9Sstevel@tonic-gate {
6557c478bd9Sstevel@tonic-gate 	caddr_t mem;
6567c478bd9Sstevel@tonic-gate 	int i;
657ae115bc7Smrj 	int valloc_align;
6587c478bd9Sstevel@tonic-gate 
659ae115bc7Smrj 	PRM_DEBUG(valloc_base);
660ae115bc7Smrj 	PRM_DEBUG(valloc_sz);
661ae115bc7Smrj 	valloc_align = mmu.level_size[mmu.max_page_level > 0];
662ae115bc7Smrj 	mem = BOP_ALLOC(bootops, (caddr_t)valloc_base, valloc_sz, valloc_align);
6637c478bd9Sstevel@tonic-gate 	if (mem != (caddr_t)valloc_base)
6647c478bd9Sstevel@tonic-gate 		panic("BOP_ALLOC() failed");
6657c478bd9Sstevel@tonic-gate 	bzero(mem, valloc_sz);
6667c478bd9Sstevel@tonic-gate 	for (i = 0; i < num_allocations; ++i) {
6677c478bd9Sstevel@tonic-gate 		*allocations[i].al_ptr = (void *)mem;
6687c478bd9Sstevel@tonic-gate 		mem += allocations[i].al_size;
6697c478bd9Sstevel@tonic-gate 	}
6707c478bd9Sstevel@tonic-gate }
6717c478bd9Sstevel@tonic-gate 
6727c478bd9Sstevel@tonic-gate /*
6737c478bd9Sstevel@tonic-gate  * Our world looks like this at startup time.
6747c478bd9Sstevel@tonic-gate  *
6757c478bd9Sstevel@tonic-gate  * In a 32-bit OS, boot loads the kernel text at 0xfe800000 and kernel data
6767c478bd9Sstevel@tonic-gate  * at 0xfec00000.  On a 64-bit OS, kernel text and data are loaded at
6777c478bd9Sstevel@tonic-gate  * 0xffffffff.fe800000 and 0xffffffff.fec00000 respectively.  Those
6787c478bd9Sstevel@tonic-gate  * addresses are fixed in the binary at link time.
6797c478bd9Sstevel@tonic-gate  *
6807c478bd9Sstevel@tonic-gate  * On the text page:
6817c478bd9Sstevel@tonic-gate  * unix/genunix/krtld/module text loads.
6827c478bd9Sstevel@tonic-gate  *
6837c478bd9Sstevel@tonic-gate  * On the data page:
684ae115bc7Smrj  * unix/genunix/krtld/module data loads.
685ae115bc7Smrj  *
6867c478bd9Sstevel@tonic-gate  * Machine-dependent startup code
6877c478bd9Sstevel@tonic-gate  */
6887c478bd9Sstevel@tonic-gate void
6897c478bd9Sstevel@tonic-gate startup(void)
6907c478bd9Sstevel@tonic-gate {
691843e1988Sjohnlev #if !defined(__xpv)
69275bcd456Sjg 	extern void startup_pci_bios(void);
693843e1988Sjohnlev #endif
694a563a037Sbholler 	extern cpuset_t cpu_ready_set;
695a563a037Sbholler 
696843e1988Sjohnlev 	/*
697843e1988Sjohnlev 	 * Make sure that nobody tries to use sekpm until we have
698843e1988Sjohnlev 	 * initialized it properly.
699843e1988Sjohnlev 	 */
7007c478bd9Sstevel@tonic-gate #if defined(__amd64)
70135b1ab99Sjosephb 	kpm_desired = 1;
7027c478bd9Sstevel@tonic-gate #endif
7037c478bd9Sstevel@tonic-gate 	kpm_enable = 0;
704a563a037Sbholler 	CPUSET_ONLY(cpu_ready_set, 0);	/* cpu 0 is boot cpu */
7057c478bd9Sstevel@tonic-gate 
706843e1988Sjohnlev #if defined(__xpv)	/* XXPV fix me! */
707843e1988Sjohnlev 	{
708843e1988Sjohnlev 		extern int segvn_use_regions;
709843e1988Sjohnlev 		segvn_use_regions = 0;
710843e1988Sjohnlev 	}
711843e1988Sjohnlev #endif
7127c478bd9Sstevel@tonic-gate 	progressbar_init();
7137c478bd9Sstevel@tonic-gate 	startup_init();
714ab4a9bebSjohnlev #if defined(__xpv)
715ab4a9bebSjohnlev 	startup_xen_version();
716ab4a9bebSjohnlev #endif
7177c478bd9Sstevel@tonic-gate 	startup_memlist();
718ae115bc7Smrj 	startup_kmem();
71935b1ab99Sjosephb 	startup_vm();
720843e1988Sjohnlev #if !defined(__xpv)
7210db3240dSStephen Hanson 	/*
7220db3240dSStephen Hanson 	 * Note we need to do this even on fast reboot in order to access
7230db3240dSStephen Hanson 	 * the irq routing table (used for pci labels).
7240db3240dSStephen Hanson 	 */
72575bcd456Sjg 	startup_pci_bios();
726843e1988Sjohnlev #endif
727e4b86885SCheng Sean Ye #if defined(__xpv)
728e4b86885SCheng Sean Ye 	startup_xen_mca();
729e4b86885SCheng Sean Ye #endif
7307c478bd9Sstevel@tonic-gate 	startup_modules();
7318770118eSlipeng sang - Sun Microsystems - Beijing China 
7327c478bd9Sstevel@tonic-gate 	startup_end();
7337c478bd9Sstevel@tonic-gate }
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate static void
7367c478bd9Sstevel@tonic-gate startup_init()
7377c478bd9Sstevel@tonic-gate {
7387c478bd9Sstevel@tonic-gate 	PRM_POINT("startup_init() starting...");
7397c478bd9Sstevel@tonic-gate 
7407c478bd9Sstevel@tonic-gate 	/*
7417c478bd9Sstevel@tonic-gate 	 * Complete the extraction of cpuid data
7427c478bd9Sstevel@tonic-gate 	 */
7437c478bd9Sstevel@tonic-gate 	cpuid_pass2(CPU);
7447c478bd9Sstevel@tonic-gate 
7457c478bd9Sstevel@tonic-gate 	(void) check_boot_version(BOP_GETVERSION(bootops));
7467c478bd9Sstevel@tonic-gate 
7477c478bd9Sstevel@tonic-gate 	/*
7487c478bd9Sstevel@tonic-gate 	 * Check for prom_debug in boot environment
7497c478bd9Sstevel@tonic-gate 	 */
7507c478bd9Sstevel@tonic-gate 	if (BOP_GETPROPLEN(bootops, "prom_debug") >= 0) {
7517c478bd9Sstevel@tonic-gate 		++prom_debug;
7527c478bd9Sstevel@tonic-gate 		PRM_POINT("prom_debug found in boot enviroment");
7537c478bd9Sstevel@tonic-gate 	}
7547c478bd9Sstevel@tonic-gate 
7557c478bd9Sstevel@tonic-gate 	/*
7567c478bd9Sstevel@tonic-gate 	 * Collect node, cpu and memory configuration information.
7577c478bd9Sstevel@tonic-gate 	 */
7587c478bd9Sstevel@tonic-gate 	get_system_configuration();
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate 	/*
7617c478bd9Sstevel@tonic-gate 	 * Halt if this is an unsupported processor.
7627c478bd9Sstevel@tonic-gate 	 */
7637c478bd9Sstevel@tonic-gate 	if (x86_type == X86_TYPE_486 || x86_type == X86_TYPE_CYRIX_486) {
7647c478bd9Sstevel@tonic-gate 		printf("\n486 processor (\"%s\") detected.\n",
7657c478bd9Sstevel@tonic-gate 		    CPU->cpu_brandstr);
7667c478bd9Sstevel@tonic-gate 		halt("This processor is not supported by this release "
7677c478bd9Sstevel@tonic-gate 		    "of Solaris.");
7687c478bd9Sstevel@tonic-gate 	}
7697c478bd9Sstevel@tonic-gate 
7707c478bd9Sstevel@tonic-gate 	PRM_POINT("startup_init() done");
7717c478bd9Sstevel@tonic-gate }
7727c478bd9Sstevel@tonic-gate 
7737c478bd9Sstevel@tonic-gate /*
7747c478bd9Sstevel@tonic-gate  * Callback for copy_memlist_filter() to filter nucleus, kadb/kmdb, (ie.
7757c478bd9Sstevel@tonic-gate  * everything mapped above KERNEL_TEXT) pages from phys_avail. Note it
7767c478bd9Sstevel@tonic-gate  * also filters out physical page zero.  There is some reliance on the
7777c478bd9Sstevel@tonic-gate  * boot loader allocating only a few contiguous physical memory chunks.
7787c478bd9Sstevel@tonic-gate  */
7797c478bd9Sstevel@tonic-gate static void
7807c478bd9Sstevel@tonic-gate avail_filter(uint64_t *addr, uint64_t *size)
7817c478bd9Sstevel@tonic-gate {
7827c478bd9Sstevel@tonic-gate 	uintptr_t va;
7837c478bd9Sstevel@tonic-gate 	uintptr_t next_va;
7847c478bd9Sstevel@tonic-gate 	pfn_t pfn;
7857c478bd9Sstevel@tonic-gate 	uint64_t pfn_addr;
7867c478bd9Sstevel@tonic-gate 	uint64_t pfn_eaddr;
7877c478bd9Sstevel@tonic-gate 	uint_t prot;
7887c478bd9Sstevel@tonic-gate 	size_t len;
7897c478bd9Sstevel@tonic-gate 	uint_t change;
7907c478bd9Sstevel@tonic-gate 
7917c478bd9Sstevel@tonic-gate 	if (prom_debug)
7927c478bd9Sstevel@tonic-gate 		prom_printf("\tFilter: in: a=%" PRIx64 ", s=%" PRIx64 "\n",
7937c478bd9Sstevel@tonic-gate 		    *addr, *size);
7947c478bd9Sstevel@tonic-gate 
7957c478bd9Sstevel@tonic-gate 	/*
7967c478bd9Sstevel@tonic-gate 	 * page zero is required for BIOS.. never make it available
7977c478bd9Sstevel@tonic-gate 	 */
7987c478bd9Sstevel@tonic-gate 	if (*addr == 0) {
7997c478bd9Sstevel@tonic-gate 		*addr += MMU_PAGESIZE;
8007c478bd9Sstevel@tonic-gate 		*size -= MMU_PAGESIZE;
8017c478bd9Sstevel@tonic-gate 	}
8027c478bd9Sstevel@tonic-gate 
8037c478bd9Sstevel@tonic-gate 	/*
804ae115bc7Smrj 	 * First we trim from the front of the range. Since kbm_probe()
8057c478bd9Sstevel@tonic-gate 	 * walks ranges in virtual order, but addr/size are physical, we need
8067c478bd9Sstevel@tonic-gate 	 * to the list until no changes are seen.  This deals with the case
8077c478bd9Sstevel@tonic-gate 	 * where page "p" is mapped at v, page "p + PAGESIZE" is mapped at w
8087c478bd9Sstevel@tonic-gate 	 * but w < v.
8097c478bd9Sstevel@tonic-gate 	 */
8107c478bd9Sstevel@tonic-gate 	do {
8117c478bd9Sstevel@tonic-gate 		change = 0;
8127c478bd9Sstevel@tonic-gate 		for (va = KERNEL_TEXT;
813ae115bc7Smrj 		    *size > 0 && kbm_probe(&va, &len, &pfn, &prot) != 0;
8147c478bd9Sstevel@tonic-gate 		    va = next_va) {
8157c478bd9Sstevel@tonic-gate 
8167c478bd9Sstevel@tonic-gate 			next_va = va + len;
817ae115bc7Smrj 			pfn_addr = pfn_to_pa(pfn);
8187c478bd9Sstevel@tonic-gate 			pfn_eaddr = pfn_addr + len;
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate 			if (pfn_addr <= *addr && pfn_eaddr > *addr) {
8217c478bd9Sstevel@tonic-gate 				change = 1;
8227c478bd9Sstevel@tonic-gate 				while (*size > 0 && len > 0) {
8237c478bd9Sstevel@tonic-gate 					*addr += MMU_PAGESIZE;
8247c478bd9Sstevel@tonic-gate 					*size -= MMU_PAGESIZE;
8257c478bd9Sstevel@tonic-gate 					len -= MMU_PAGESIZE;
8267c478bd9Sstevel@tonic-gate 				}
8277c478bd9Sstevel@tonic-gate 			}
8287c478bd9Sstevel@tonic-gate 		}
8297c478bd9Sstevel@tonic-gate 		if (change && prom_debug)
8307c478bd9Sstevel@tonic-gate 			prom_printf("\t\ttrim: a=%" PRIx64 ", s=%" PRIx64 "\n",
8317c478bd9Sstevel@tonic-gate 			    *addr, *size);
8327c478bd9Sstevel@tonic-gate 	} while (change);
8337c478bd9Sstevel@tonic-gate 
8347c478bd9Sstevel@tonic-gate 	/*
8357c478bd9Sstevel@tonic-gate 	 * Trim pages from the end of the range.
8367c478bd9Sstevel@tonic-gate 	 */
8377c478bd9Sstevel@tonic-gate 	for (va = KERNEL_TEXT;
838ae115bc7Smrj 	    *size > 0 && kbm_probe(&va, &len, &pfn, &prot) != 0;
8397c478bd9Sstevel@tonic-gate 	    va = next_va) {
8407c478bd9Sstevel@tonic-gate 
8417c478bd9Sstevel@tonic-gate 		next_va = va + len;
842ae115bc7Smrj 		pfn_addr = pfn_to_pa(pfn);
8437c478bd9Sstevel@tonic-gate 
8447c478bd9Sstevel@tonic-gate 		if (pfn_addr >= *addr && pfn_addr < *addr + *size)
8457c478bd9Sstevel@tonic-gate 			*size = pfn_addr - *addr;
8467c478bd9Sstevel@tonic-gate 	}
8477c478bd9Sstevel@tonic-gate 
8487c478bd9Sstevel@tonic-gate 	if (prom_debug)
8497c478bd9Sstevel@tonic-gate 		prom_printf("\tFilter out: a=%" PRIx64 ", s=%" PRIx64 "\n",
8507c478bd9Sstevel@tonic-gate 		    *addr, *size);
8517c478bd9Sstevel@tonic-gate }
8527c478bd9Sstevel@tonic-gate 
8537c478bd9Sstevel@tonic-gate static void
8547c478bd9Sstevel@tonic-gate kpm_init()
8557c478bd9Sstevel@tonic-gate {
8567c478bd9Sstevel@tonic-gate 	struct segkpm_crargs b;
8577c478bd9Sstevel@tonic-gate 
8587c478bd9Sstevel@tonic-gate 	/*
8597c478bd9Sstevel@tonic-gate 	 * These variables were all designed for sfmmu in which segkpm is
8607c478bd9Sstevel@tonic-gate 	 * mapped using a single pagesize - either 8KB or 4MB.  On x86, we
8617c478bd9Sstevel@tonic-gate 	 * might use 2+ page sizes on a single machine, so none of these
8627c478bd9Sstevel@tonic-gate 	 * variables have a single correct value.  They are set up as if we
8637c478bd9Sstevel@tonic-gate 	 * always use a 4KB pagesize, which should do no harm.  In the long
8647c478bd9Sstevel@tonic-gate 	 * run, we should get rid of KPM's assumption that only a single
8657c478bd9Sstevel@tonic-gate 	 * pagesize is used.
8667c478bd9Sstevel@tonic-gate 	 */
8677c478bd9Sstevel@tonic-gate 	kpm_pgshft = MMU_PAGESHIFT;
8687c478bd9Sstevel@tonic-gate 	kpm_pgsz =  MMU_PAGESIZE;
8697c478bd9Sstevel@tonic-gate 	kpm_pgoff = MMU_PAGEOFFSET;
8707c478bd9Sstevel@tonic-gate 	kpmp2pshft = 0;
8717c478bd9Sstevel@tonic-gate 	kpmpnpgs = 1;
8727c478bd9Sstevel@tonic-gate 	ASSERT(((uintptr_t)kpm_vbase & (kpm_pgsz - 1)) == 0);
8737c478bd9Sstevel@tonic-gate 
8747c478bd9Sstevel@tonic-gate 	PRM_POINT("about to create segkpm");
8757c478bd9Sstevel@tonic-gate 	rw_enter(&kas.a_lock, RW_WRITER);
8767c478bd9Sstevel@tonic-gate 
8777c478bd9Sstevel@tonic-gate 	if (seg_attach(&kas, kpm_vbase, kpm_size, segkpm) < 0)
8787c478bd9Sstevel@tonic-gate 		panic("cannot attach segkpm");
8797c478bd9Sstevel@tonic-gate 
8807c478bd9Sstevel@tonic-gate 	b.prot = PROT_READ | PROT_WRITE;
8817c478bd9Sstevel@tonic-gate 	b.nvcolors = 1;
8827c478bd9Sstevel@tonic-gate 
8837c478bd9Sstevel@tonic-gate 	if (segkpm_create(segkpm, (caddr_t)&b) != 0)
8847c478bd9Sstevel@tonic-gate 		panic("segkpm_create segkpm");
8857c478bd9Sstevel@tonic-gate 
8867c478bd9Sstevel@tonic-gate 	rw_exit(&kas.a_lock);
887ae115bc7Smrj }
8887c478bd9Sstevel@tonic-gate 
8897c478bd9Sstevel@tonic-gate /*
890ae115bc7Smrj  * The debug info page provides enough information to allow external
891ae115bc7Smrj  * inspectors (e.g. when running under a hypervisor) to bootstrap
892ae115bc7Smrj  * themselves into allowing full-blown kernel debugging.
8937c478bd9Sstevel@tonic-gate  */
894ae115bc7Smrj static void
895ae115bc7Smrj init_debug_info(void)
896ae115bc7Smrj {
897ae115bc7Smrj 	caddr_t mem;
898ae115bc7Smrj 	debug_info_t *di;
899ae115bc7Smrj 
900ae115bc7Smrj #ifndef __lint
901ae115bc7Smrj 	ASSERT(sizeof (debug_info_t) < MMU_PAGESIZE);
902ae115bc7Smrj #endif
903ae115bc7Smrj 
904ae115bc7Smrj 	mem = BOP_ALLOC(bootops, (caddr_t)DEBUG_INFO_VA, MMU_PAGESIZE,
905ae115bc7Smrj 	    MMU_PAGESIZE);
906ae115bc7Smrj 
907ae115bc7Smrj 	if (mem != (caddr_t)DEBUG_INFO_VA)
908ae115bc7Smrj 		panic("BOP_ALLOC() failed");
909ae115bc7Smrj 	bzero(mem, MMU_PAGESIZE);
910ae115bc7Smrj 
911ae115bc7Smrj 	di = (debug_info_t *)mem;
912ae115bc7Smrj 
913ae115bc7Smrj 	di->di_magic = DEBUG_INFO_MAGIC;
914ae115bc7Smrj 	di->di_version = DEBUG_INFO_VERSION;
915843e1988Sjohnlev 	di->di_modules = (uintptr_t)&modules;
916843e1988Sjohnlev 	di->di_s_text = (uintptr_t)s_text;
917843e1988Sjohnlev 	di->di_e_text = (uintptr_t)e_text;
918843e1988Sjohnlev 	di->di_s_data = (uintptr_t)s_data;
919843e1988Sjohnlev 	di->di_e_data = (uintptr_t)e_data;
920843e1988Sjohnlev 	di->di_hat_htable_off = offsetof(hat_t, hat_htable);
921843e1988Sjohnlev 	di->di_ht_pfn_off = offsetof(htable_t, ht_pfn);
9227c478bd9Sstevel@tonic-gate }
9237c478bd9Sstevel@tonic-gate 
9247c478bd9Sstevel@tonic-gate /*
925ae115bc7Smrj  * Build the memlists and other kernel essential memory system data structures.
926ae115bc7Smrj  * This is everything at valloc_base.
9277c478bd9Sstevel@tonic-gate  */
9287c478bd9Sstevel@tonic-gate static void
9297c478bd9Sstevel@tonic-gate startup_memlist(void)
9307c478bd9Sstevel@tonic-gate {
9317c478bd9Sstevel@tonic-gate 	size_t memlist_sz;
9327c478bd9Sstevel@tonic-gate 	size_t memseg_sz;
9337c478bd9Sstevel@tonic-gate 	size_t pagehash_sz;
9347c478bd9Sstevel@tonic-gate 	size_t pp_sz;
9357c478bd9Sstevel@tonic-gate 	uintptr_t va;
9367c478bd9Sstevel@tonic-gate 	size_t len;
9377c478bd9Sstevel@tonic-gate 	uint_t prot;
9387c478bd9Sstevel@tonic-gate 	pfn_t pfn;
9397c478bd9Sstevel@tonic-gate 	int memblocks;
9401de082f7SVikram Hegde 	pfn_t rsvd_high_pfn;
9411de082f7SVikram Hegde 	pgcnt_t rsvd_pgcnt;
9421de082f7SVikram Hegde 	size_t rsvdmemlist_sz;
9431de082f7SVikram Hegde 	int rsvdmemblocks;
9447c478bd9Sstevel@tonic-gate 	caddr_t pagecolor_mem;
9457c478bd9Sstevel@tonic-gate 	size_t pagecolor_memsz;
9467c478bd9Sstevel@tonic-gate 	caddr_t page_ctrs_mem;
9477c478bd9Sstevel@tonic-gate 	size_t page_ctrs_size;
948d7d93655Sblakej 	size_t pse_table_alloc_size;
9497c478bd9Sstevel@tonic-gate 	struct memlist *current;
9507c478bd9Sstevel@tonic-gate 	extern void startup_build_mem_nodes(struct memlist *);
9517c478bd9Sstevel@tonic-gate 
9527c478bd9Sstevel@tonic-gate 	/* XX64 fix these - they should be in include files */
9537c478bd9Sstevel@tonic-gate 	extern size_t page_coloring_init(uint_t, int, int);
9547c478bd9Sstevel@tonic-gate 	extern void page_coloring_setup(caddr_t);
9557c478bd9Sstevel@tonic-gate 
9567c478bd9Sstevel@tonic-gate 	PRM_POINT("startup_memlist() starting...");
9577c478bd9Sstevel@tonic-gate 
9587c478bd9Sstevel@tonic-gate 	/*
9597c478bd9Sstevel@tonic-gate 	 * Use leftover large page nucleus text/data space for loadable modules.
9607c478bd9Sstevel@tonic-gate 	 * Use at most MODTEXT/MODDATA.
9617c478bd9Sstevel@tonic-gate 	 */
962ae115bc7Smrj 	len = kbm_nucleus_size;
963ae115bc7Smrj 	ASSERT(len > MMU_PAGESIZE);
9647c478bd9Sstevel@tonic-gate 
9657c478bd9Sstevel@tonic-gate 	moddata = (caddr_t)ROUND_UP_PAGE(e_data);
966ae115bc7Smrj 	e_moddata = (caddr_t)P2ROUNDUP((uintptr_t)e_data, (uintptr_t)len);
9677c478bd9Sstevel@tonic-gate 	if (e_moddata - moddata > MODDATA)
9687c478bd9Sstevel@tonic-gate 		e_moddata = moddata + MODDATA;
9697c478bd9Sstevel@tonic-gate 
9707c478bd9Sstevel@tonic-gate 	modtext = (caddr_t)ROUND_UP_PAGE(e_text);
971ae115bc7Smrj 	e_modtext = (caddr_t)P2ROUNDUP((uintptr_t)e_text, (uintptr_t)len);
9727c478bd9Sstevel@tonic-gate 	if (e_modtext - modtext > MODTEXT)
9737c478bd9Sstevel@tonic-gate 		e_modtext = modtext + MODTEXT;
9747c478bd9Sstevel@tonic-gate 
9757c478bd9Sstevel@tonic-gate 	econtig = e_moddata;
9767c478bd9Sstevel@tonic-gate 
9777c478bd9Sstevel@tonic-gate 	PRM_DEBUG(modtext);
9787c478bd9Sstevel@tonic-gate 	PRM_DEBUG(e_modtext);
9797c478bd9Sstevel@tonic-gate 	PRM_DEBUG(moddata);
9807c478bd9Sstevel@tonic-gate 	PRM_DEBUG(e_moddata);
9817c478bd9Sstevel@tonic-gate 	PRM_DEBUG(econtig);
9827c478bd9Sstevel@tonic-gate 
9837c478bd9Sstevel@tonic-gate 	/*
984ae115bc7Smrj 	 * Examine the boot loader physical memory map to find out:
9857c478bd9Sstevel@tonic-gate 	 * - total memory in system - physinstalled
9867c478bd9Sstevel@tonic-gate 	 * - the max physical address - physmax
987ae115bc7Smrj 	 * - the number of discontiguous segments of memory.
9887c478bd9Sstevel@tonic-gate 	 */
9897c478bd9Sstevel@tonic-gate 	if (prom_debug)
990ae115bc7Smrj 		print_memlist("boot physinstalled",
9917c478bd9Sstevel@tonic-gate 		    bootops->boot_mem->physinstalled);
992a3114836SGerry Liu 	installed_top_size_ex(bootops->boot_mem->physinstalled, &physmax,
9937c478bd9Sstevel@tonic-gate 	    &physinstalled, &memblocks);
9947c478bd9Sstevel@tonic-gate 	PRM_DEBUG(physmax);
9957c478bd9Sstevel@tonic-gate 	PRM_DEBUG(physinstalled);
9967c478bd9Sstevel@tonic-gate 	PRM_DEBUG(memblocks);
9977c478bd9Sstevel@tonic-gate 
9987c478bd9Sstevel@tonic-gate 	/*
999a3114836SGerry Liu 	 * Compute maximum physical address for memory DR operations.
1000a3114836SGerry Liu 	 * Memory DR operations are unsupported on xpv or 32bit OSes.
1001a3114836SGerry Liu 	 */
1002a3114836SGerry Liu #ifdef	__amd64
1003a3114836SGerry Liu 	if (plat_dr_support_memory()) {
1004a3114836SGerry Liu 		if (plat_dr_physmax == 0) {
1005a3114836SGerry Liu 			uint_t pabits = UINT_MAX;
1006a3114836SGerry Liu 
1007a3114836SGerry Liu 			cpuid_get_addrsize(CPU, &pabits, NULL);
1008a3114836SGerry Liu 			plat_dr_physmax = btop(1ULL << pabits);
1009a3114836SGerry Liu 		}
1010a3114836SGerry Liu 		if (plat_dr_physmax > PHYSMEM_MAX64)
1011a3114836SGerry Liu 			plat_dr_physmax = PHYSMEM_MAX64;
1012a3114836SGerry Liu 	} else
1013a3114836SGerry Liu #endif
1014a3114836SGerry Liu 		plat_dr_physmax = 0;
1015a3114836SGerry Liu 
1016a3114836SGerry Liu 	/*
10171de082f7SVikram Hegde 	 * Examine the bios reserved memory to find out:
10181de082f7SVikram Hegde 	 * - the number of discontiguous segments of memory.
10191de082f7SVikram Hegde 	 */
10201de082f7SVikram Hegde 	if (prom_debug)
10211de082f7SVikram Hegde 		print_memlist("boot reserved mem",
10221de082f7SVikram Hegde 		    bootops->boot_mem->rsvdmem);
1023a3114836SGerry Liu 	installed_top_size_ex(bootops->boot_mem->rsvdmem, &rsvd_high_pfn,
10241de082f7SVikram Hegde 	    &rsvd_pgcnt, &rsvdmemblocks);
10251de082f7SVikram Hegde 	PRM_DEBUG(rsvd_high_pfn);
10261de082f7SVikram Hegde 	PRM_DEBUG(rsvd_pgcnt);
10271de082f7SVikram Hegde 	PRM_DEBUG(rsvdmemblocks);
10281de082f7SVikram Hegde 
10291de082f7SVikram Hegde 	/*
10307c478bd9Sstevel@tonic-gate 	 * Initialize hat's mmu parameters.
10317c478bd9Sstevel@tonic-gate 	 * Check for enforce-prot-exec in boot environment. It's used to
10327c478bd9Sstevel@tonic-gate 	 * enable/disable support for the page table entry NX bit.
10337c478bd9Sstevel@tonic-gate 	 * The default is to enforce PROT_EXEC on processors that support NX.
10347c478bd9Sstevel@tonic-gate 	 * Boot seems to round up the "len", but 8 seems to be big enough.
10357c478bd9Sstevel@tonic-gate 	 */
10367c478bd9Sstevel@tonic-gate 	mmu_init();
10377c478bd9Sstevel@tonic-gate 
10387c478bd9Sstevel@tonic-gate #ifdef	__i386
10397c478bd9Sstevel@tonic-gate 	/*
10407c478bd9Sstevel@tonic-gate 	 * physmax is lowered if there is more memory than can be
10417c478bd9Sstevel@tonic-gate 	 * physically addressed in 32 bit (PAE/non-PAE) modes.
10427c478bd9Sstevel@tonic-gate 	 */
10437c478bd9Sstevel@tonic-gate 	if (mmu.pae_hat) {
10447c478bd9Sstevel@tonic-gate 		if (PFN_ABOVE64G(physmax)) {
10457c478bd9Sstevel@tonic-gate 			physinstalled -= (physmax - (PFN_64G - 1));
10467c478bd9Sstevel@tonic-gate 			physmax = PFN_64G - 1;
10477c478bd9Sstevel@tonic-gate 		}
10487c478bd9Sstevel@tonic-gate 	} else {
10497c478bd9Sstevel@tonic-gate 		if (PFN_ABOVE4G(physmax)) {
10507c478bd9Sstevel@tonic-gate 			physinstalled -= (physmax - (PFN_4G - 1));
10517c478bd9Sstevel@tonic-gate 			physmax = PFN_4G - 1;
10527c478bd9Sstevel@tonic-gate 		}
10537c478bd9Sstevel@tonic-gate 	}
10547c478bd9Sstevel@tonic-gate #endif
10557c478bd9Sstevel@tonic-gate 
10567c478bd9Sstevel@tonic-gate 	startup_build_mem_nodes(bootops->boot_mem->physinstalled);
10577c478bd9Sstevel@tonic-gate 
10587c478bd9Sstevel@tonic-gate 	if (BOP_GETPROPLEN(bootops, "enforce-prot-exec") >= 0) {
10597c478bd9Sstevel@tonic-gate 		int len = BOP_GETPROPLEN(bootops, "enforce-prot-exec");
10607c478bd9Sstevel@tonic-gate 		char value[8];
10617c478bd9Sstevel@tonic-gate 
10627c478bd9Sstevel@tonic-gate 		if (len < 8)
10637c478bd9Sstevel@tonic-gate 			(void) BOP_GETPROP(bootops, "enforce-prot-exec", value);
10647c478bd9Sstevel@tonic-gate 		else
10657c478bd9Sstevel@tonic-gate 			(void) strcpy(value, "");
10667c478bd9Sstevel@tonic-gate 		if (strcmp(value, "off") == 0)
10677c478bd9Sstevel@tonic-gate 			mmu.pt_nx = 0;
10687c478bd9Sstevel@tonic-gate 	}
10697c478bd9Sstevel@tonic-gate 	PRM_DEBUG(mmu.pt_nx);
10707c478bd9Sstevel@tonic-gate 
10717c478bd9Sstevel@tonic-gate 	/*
10727c478bd9Sstevel@tonic-gate 	 * We will need page_t's for every page in the system, except for
10737c478bd9Sstevel@tonic-gate 	 * memory mapped at or above above the start of the kernel text segment.
10747c478bd9Sstevel@tonic-gate 	 *
10757c478bd9Sstevel@tonic-gate 	 * pages above e_modtext are attributed to kernel debugger (obp_pages)
10767c478bd9Sstevel@tonic-gate 	 */
10777c478bd9Sstevel@tonic-gate 	npages = physinstalled - 1; /* avail_filter() skips page 0, so "- 1" */
10787c478bd9Sstevel@tonic-gate 	obp_pages = 0;
10797c478bd9Sstevel@tonic-gate 	va = KERNEL_TEXT;
1080ae115bc7Smrj 	while (kbm_probe(&va, &len, &pfn, &prot) != 0) {
10817c478bd9Sstevel@tonic-gate 		npages -= len >> MMU_PAGESHIFT;
10827c478bd9Sstevel@tonic-gate 		if (va >= (uintptr_t)e_moddata)
10837c478bd9Sstevel@tonic-gate 			obp_pages += len >> MMU_PAGESHIFT;
10847c478bd9Sstevel@tonic-gate 		va += len;
10857c478bd9Sstevel@tonic-gate 	}
10867c478bd9Sstevel@tonic-gate 	PRM_DEBUG(npages);
10877c478bd9Sstevel@tonic-gate 	PRM_DEBUG(obp_pages);
10887c478bd9Sstevel@tonic-gate 
10897c478bd9Sstevel@tonic-gate 	/*
109035b1ab99Sjosephb 	 * If physmem is patched to be non-zero, use it instead of the computed
109135b1ab99Sjosephb 	 * value unless it is larger than the actual amount of memory on hand.
10927c478bd9Sstevel@tonic-gate 	 */
10934944b02eSkchow 	if (physmem == 0 || physmem > npages) {
10947c478bd9Sstevel@tonic-gate 		physmem = npages;
10954944b02eSkchow 	} else if (physmem < npages) {
1096f53ad214Skchow 		orig_npages = npages;
10977c478bd9Sstevel@tonic-gate 		npages = physmem;
10984944b02eSkchow 	}
10997c478bd9Sstevel@tonic-gate 	PRM_DEBUG(physmem);
11007c478bd9Sstevel@tonic-gate 
11017c478bd9Sstevel@tonic-gate 	/*
11027c478bd9Sstevel@tonic-gate 	 * We now compute the sizes of all the  initial allocations for
11037c478bd9Sstevel@tonic-gate 	 * structures the kernel needs in order do kmem_alloc(). These
11047c478bd9Sstevel@tonic-gate 	 * include:
11057c478bd9Sstevel@tonic-gate 	 *	memsegs
11067c478bd9Sstevel@tonic-gate 	 *	memlists
11077c478bd9Sstevel@tonic-gate 	 *	page hash table
11087c478bd9Sstevel@tonic-gate 	 *	page_t's
11097c478bd9Sstevel@tonic-gate 	 *	page coloring data structs
11107c478bd9Sstevel@tonic-gate 	 */
11117c478bd9Sstevel@tonic-gate 	memseg_sz = sizeof (struct memseg) * (memblocks + POSS_NEW_FRAGMENTS);
11127c478bd9Sstevel@tonic-gate 	ADD_TO_ALLOCATIONS(memseg_base, memseg_sz);
11137c478bd9Sstevel@tonic-gate 	PRM_DEBUG(memseg_sz);
11147c478bd9Sstevel@tonic-gate 
11157c478bd9Sstevel@tonic-gate 	/*
1116ae115bc7Smrj 	 * Reserve space for memlists. There's no real good way to know exactly
1117ae115bc7Smrj 	 * how much room we'll need, but this should be a good upper bound.
11187c478bd9Sstevel@tonic-gate 	 */
11197c478bd9Sstevel@tonic-gate 	memlist_sz = ROUND_UP_PAGE(2 * sizeof (struct memlist) *
11207c478bd9Sstevel@tonic-gate 	    (memblocks + POSS_NEW_FRAGMENTS));
11217c478bd9Sstevel@tonic-gate 	ADD_TO_ALLOCATIONS(memlist, memlist_sz);
11227c478bd9Sstevel@tonic-gate 	PRM_DEBUG(memlist_sz);
11237c478bd9Sstevel@tonic-gate 
11247c478bd9Sstevel@tonic-gate 	/*
11251de082f7SVikram Hegde 	 * Reserve space for bios reserved memlists.
11261de082f7SVikram Hegde 	 */
11271de082f7SVikram Hegde 	rsvdmemlist_sz = ROUND_UP_PAGE(2 * sizeof (struct memlist) *
11281de082f7SVikram Hegde 	    (rsvdmemblocks + POSS_NEW_FRAGMENTS));
11291de082f7SVikram Hegde 	ADD_TO_ALLOCATIONS(bios_rsvd, rsvdmemlist_sz);
11301de082f7SVikram Hegde 	PRM_DEBUG(rsvdmemlist_sz);
11311de082f7SVikram Hegde 
1132cb15d5d9SPeter Rival 	/* LINTED */
1133cb15d5d9SPeter Rival 	ASSERT(P2SAMEHIGHBIT((1 << PP_SHIFT), sizeof (struct page)));
11341de082f7SVikram Hegde 	/*
11357c478bd9Sstevel@tonic-gate 	 * The page structure hash table size is a power of 2
11367c478bd9Sstevel@tonic-gate 	 * such that the average hash chain length is PAGE_HASHAVELEN.
11377c478bd9Sstevel@tonic-gate 	 */
11387c478bd9Sstevel@tonic-gate 	page_hashsz = npages / PAGE_HASHAVELEN;
1139cb15d5d9SPeter Rival 	page_hashsz_shift = highbit(page_hashsz);
1140cb15d5d9SPeter Rival 	page_hashsz = 1 << page_hashsz_shift;
11417c478bd9Sstevel@tonic-gate 	pagehash_sz = sizeof (struct page *) * page_hashsz;
11427c478bd9Sstevel@tonic-gate 	ADD_TO_ALLOCATIONS(page_hash, pagehash_sz);
11437c478bd9Sstevel@tonic-gate 	PRM_DEBUG(pagehash_sz);
11447c478bd9Sstevel@tonic-gate 
11457c478bd9Sstevel@tonic-gate 	/*
1146ae115bc7Smrj 	 * Set aside room for the page structures themselves.
11477c478bd9Sstevel@tonic-gate 	 */
1148ae115bc7Smrj 	PRM_DEBUG(npages);
1149ae115bc7Smrj 	pp_sz = sizeof (struct page) * npages;
11507c478bd9Sstevel@tonic-gate 	ADD_TO_ALLOCATIONS(pp_base, pp_sz);
11517c478bd9Sstevel@tonic-gate 	PRM_DEBUG(pp_sz);
11527c478bd9Sstevel@tonic-gate 
11537c478bd9Sstevel@tonic-gate 	/*
11547c478bd9Sstevel@tonic-gate 	 * determine l2 cache info and memory size for page coloring
11557c478bd9Sstevel@tonic-gate 	 */
11567c478bd9Sstevel@tonic-gate 	(void) getl2cacheinfo(CPU,
11577c478bd9Sstevel@tonic-gate 	    &l2cache_sz, &l2cache_linesz, &l2cache_assoc);
11587c478bd9Sstevel@tonic-gate 	pagecolor_memsz =
11597c478bd9Sstevel@tonic-gate 	    page_coloring_init(l2cache_sz, l2cache_linesz, l2cache_assoc);
11607c478bd9Sstevel@tonic-gate 	ADD_TO_ALLOCATIONS(pagecolor_mem, pagecolor_memsz);
11617c478bd9Sstevel@tonic-gate 	PRM_DEBUG(pagecolor_memsz);
11627c478bd9Sstevel@tonic-gate 
11637c478bd9Sstevel@tonic-gate 	page_ctrs_size = page_ctrs_sz();
11647c478bd9Sstevel@tonic-gate 	ADD_TO_ALLOCATIONS(page_ctrs_mem, page_ctrs_size);
11657c478bd9Sstevel@tonic-gate 	PRM_DEBUG(page_ctrs_size);
11667c478bd9Sstevel@tonic-gate 
1167d7d93655Sblakej 	/*
1168d7d93655Sblakej 	 * Allocate the array that protects pp->p_selock.
1169d7d93655Sblakej 	 */
1170d7d93655Sblakej 	pse_shift = size_pse_array(physmem, max_ncpus);
1171d7d93655Sblakej 	pse_table_size = 1 << pse_shift;
1172d7d93655Sblakej 	pse_table_alloc_size = pse_table_size * sizeof (pad_mutex_t);
1173d7d93655Sblakej 	ADD_TO_ALLOCATIONS(pse_mutex, pse_table_alloc_size);
1174d7d93655Sblakej 
1175ae115bc7Smrj #if defined(__amd64)
11767c478bd9Sstevel@tonic-gate 	valloc_sz = ROUND_UP_LPAGE(valloc_sz);
1177ae115bc7Smrj 	valloc_base = VALLOC_BASE;
117835b1ab99Sjosephb 
117935b1ab99Sjosephb 	/*
118035b1ab99Sjosephb 	 * The default values of VALLOC_BASE and SEGKPM_BASE should work
118135b1ab99Sjosephb 	 * for values of physmax up to 1 Terabyte. They need adjusting when
11826c8c89eaSKit Chow 	 * memory is at addresses above 1 TB. When adjusted, segkpm_base must
11836c8c89eaSKit Chow 	 * be aligned on KERNEL_REDZONE_SIZE boundary (span of top level pte).
118435b1ab99Sjosephb 	 */
1185a3114836SGerry Liu 	if (physmax + 1 > mmu_btop(TERABYTE) ||
1186a3114836SGerry Liu 	    plat_dr_physmax > mmu_btop(TERABYTE)) {
118735b1ab99Sjosephb 		uint64_t kpm_resv_amount = mmu_ptob(physmax + 1);
118835b1ab99Sjosephb 
1189a3114836SGerry Liu 		if (kpm_resv_amount < mmu_ptob(plat_dr_physmax)) {
1190a3114836SGerry Liu 			kpm_resv_amount = mmu_ptob(plat_dr_physmax);
1191a3114836SGerry Liu 		}
1192a3114836SGerry Liu 
11936c8c89eaSKit Chow 		segkpm_base = -(P2ROUNDUP((2 * kpm_resv_amount),
11946c8c89eaSKit Chow 		    KERNEL_REDZONE_SIZE));	/* down from top VA */
119535b1ab99Sjosephb 
119635b1ab99Sjosephb 		/* make sure we leave some space for user apps above hole */
119735b1ab99Sjosephb 		segkpm_base = MAX(segkpm_base, AMD64_VA_HOLE_END + TERABYTE);
119835b1ab99Sjosephb 		if (segkpm_base > SEGKPM_BASE)
119935b1ab99Sjosephb 			segkpm_base = SEGKPM_BASE;
120035b1ab99Sjosephb 		PRM_DEBUG(segkpm_base);
120135b1ab99Sjosephb 
12026c8c89eaSKit Chow 		valloc_base = segkpm_base + P2ROUNDUP(kpm_resv_amount, ONE_GIG);
12036c8c89eaSKit Chow 		if (valloc_base < segkpm_base)
12046c8c89eaSKit Chow 			panic("not enough kernel VA to support memory size");
120535b1ab99Sjosephb 		PRM_DEBUG(valloc_base);
120635b1ab99Sjosephb 	}
1207ae115bc7Smrj #else	/* __i386 */
1208ae115bc7Smrj 	valloc_base = (uintptr_t)(MISC_VA_BASE - valloc_sz);
1209ae115bc7Smrj 	valloc_base = P2ALIGN(valloc_base, mmu.level_size[1]);
12107c478bd9Sstevel@tonic-gate 	PRM_DEBUG(valloc_base);
121135b1ab99Sjosephb #endif	/* __i386 */
1212ae115bc7Smrj 
1213ae115bc7Smrj 	/*
1214ae115bc7Smrj 	 * do all the initial allocations
1215ae115bc7Smrj 	 */
1216ae115bc7Smrj 	perform_allocations();
1217ae115bc7Smrj 
1218ae115bc7Smrj 	/*
1219ae115bc7Smrj 	 * Build phys_install and phys_avail in kernel memspace.
1220ae115bc7Smrj 	 * - phys_install should be all memory in the system.
1221ae115bc7Smrj 	 * - phys_avail is phys_install minus any memory mapped before this
1222ae115bc7Smrj 	 *    point above KERNEL_TEXT.
1223ae115bc7Smrj 	 */
1224ae115bc7Smrj 	current = phys_install = memlist;
1225ae115bc7Smrj 	copy_memlist_filter(bootops->boot_mem->physinstalled, &current, NULL);
1226ae115bc7Smrj 	if ((caddr_t)current > (caddr_t)memlist + memlist_sz)
1227ae115bc7Smrj 		panic("physinstalled was too big!");
1228ae115bc7Smrj 	if (prom_debug)
1229ae115bc7Smrj 		print_memlist("phys_install", phys_install);
1230ae115bc7Smrj 
1231ae115bc7Smrj 	phys_avail = current;
1232ae115bc7Smrj 	PRM_POINT("Building phys_avail:\n");
1233ae115bc7Smrj 	copy_memlist_filter(bootops->boot_mem->physinstalled, &current,
1234ae115bc7Smrj 	    avail_filter);
1235ae115bc7Smrj 	if ((caddr_t)current > (caddr_t)memlist + memlist_sz)
1236ae115bc7Smrj 		panic("physavail was too big!");
1237ae115bc7Smrj 	if (prom_debug)
1238ae115bc7Smrj 		print_memlist("phys_avail", phys_avail);
1239a3114836SGerry Liu #ifndef	__xpv
1240a3114836SGerry Liu 	/*
1241a3114836SGerry Liu 	 * Free unused memlist items, which may be used by memory DR driver
1242a3114836SGerry Liu 	 * at runtime.
1243a3114836SGerry Liu 	 */
1244a3114836SGerry Liu 	if ((caddr_t)current < (caddr_t)memlist + memlist_sz) {
1245a3114836SGerry Liu 		memlist_free_block((caddr_t)current,
1246a3114836SGerry Liu 		    (caddr_t)memlist + memlist_sz - (caddr_t)current);
1247a3114836SGerry Liu 	}
1248a3114836SGerry Liu #endif
1249ae115bc7Smrj 
1250ae115bc7Smrj 	/*
12511de082f7SVikram Hegde 	 * Build bios reserved memspace
12521de082f7SVikram Hegde 	 */
12531de082f7SVikram Hegde 	current = bios_rsvd;
12541de082f7SVikram Hegde 	copy_memlist_filter(bootops->boot_mem->rsvdmem, &current, NULL);
12551de082f7SVikram Hegde 	if ((caddr_t)current > (caddr_t)bios_rsvd + rsvdmemlist_sz)
12561de082f7SVikram Hegde 		panic("bios_rsvd was too big!");
12571de082f7SVikram Hegde 	if (prom_debug)
12581de082f7SVikram Hegde 		print_memlist("bios_rsvd", bios_rsvd);
1259a3114836SGerry Liu #ifndef	__xpv
1260a3114836SGerry Liu 	/*
1261a3114836SGerry Liu 	 * Free unused memlist items, which may be used by memory DR driver
1262a3114836SGerry Liu 	 * at runtime.
1263a3114836SGerry Liu 	 */
1264a3114836SGerry Liu 	if ((caddr_t)current < (caddr_t)bios_rsvd + rsvdmemlist_sz) {
1265a3114836SGerry Liu 		memlist_free_block((caddr_t)current,
1266a3114836SGerry Liu 		    (caddr_t)bios_rsvd + rsvdmemlist_sz - (caddr_t)current);
1267a3114836SGerry Liu 	}
1268a3114836SGerry Liu #endif
12691de082f7SVikram Hegde 
12701de082f7SVikram Hegde 	/*
1271ae115bc7Smrj 	 * setup page coloring
1272ae115bc7Smrj 	 */
1273ae115bc7Smrj 	page_coloring_setup(pagecolor_mem);
1274ae115bc7Smrj 	page_lock_init();	/* currently a no-op */
1275ae115bc7Smrj 
1276ae115bc7Smrj 	/*
1277ae115bc7Smrj 	 * free page list counters
1278ae115bc7Smrj 	 */
1279ae115bc7Smrj 	(void) page_ctrs_alloc(page_ctrs_mem);
1280ae115bc7Smrj 
1281ae115bc7Smrj 	/*
128206fb6a36Sdv142724 	 * Size the pcf array based on the number of cpus in the box at
128306fb6a36Sdv142724 	 * boot time.
128406fb6a36Sdv142724 	 */
128506fb6a36Sdv142724 
128606fb6a36Sdv142724 	pcf_init();
128706fb6a36Sdv142724 
128806fb6a36Sdv142724 	/*
1289ae115bc7Smrj 	 * Initialize the page structures from the memory lists.
1290ae115bc7Smrj 	 */
1291ae115bc7Smrj 	availrmem_initial = availrmem = freemem = 0;
1292ae115bc7Smrj 	PRM_POINT("Calling kphysm_init()...");
1293ae115bc7Smrj 	npages = kphysm_init(pp_base, npages);
1294ae115bc7Smrj 	PRM_POINT("kphysm_init() done");
1295ae115bc7Smrj 	PRM_DEBUG(npages);
1296ae115bc7Smrj 
1297ae115bc7Smrj 	init_debug_info();
1298ae115bc7Smrj 
1299ae115bc7Smrj 	/*
1300ae115bc7Smrj 	 * Now that page_t's have been initialized, remove all the
1301ae115bc7Smrj 	 * initial allocation pages from the kernel free page lists.
1302ae115bc7Smrj 	 */
1303ae115bc7Smrj 	boot_mapin((caddr_t)valloc_base, valloc_sz);
13040cfdb603Sjosephb 	boot_mapin((caddr_t)MISC_VA_BASE, MISC_VA_SIZE);
1305ae115bc7Smrj 	PRM_POINT("startup_memlist() done");
1306ae115bc7Smrj 
1307ae115bc7Smrj 	PRM_DEBUG(valloc_sz);
13082cb27123Saguzovsk 
1309567d55e1Saguzovsk #if defined(__amd64)
1310567d55e1Saguzovsk 	if ((availrmem >> (30 - MMU_PAGESHIFT)) >=
1311567d55e1Saguzovsk 	    textrepl_min_gb && l2cache_sz <= 2 << 20) {
1312567d55e1Saguzovsk 		extern size_t textrepl_size_thresh;
13132cb27123Saguzovsk 		textrepl_size_thresh = (16 << 20) - 1;
13142cb27123Saguzovsk 	}
1315567d55e1Saguzovsk #endif
1316ae115bc7Smrj }
1317ae115bc7Smrj 
1318ae115bc7Smrj /*
1319ae115bc7Smrj  * Layout the kernel's part of address space and initialize kmem allocator.
1320ae115bc7Smrj  */
1321ae115bc7Smrj static void
1322ae115bc7Smrj startup_kmem(void)
1323ae115bc7Smrj {
1324932dc8e5Sdp78419 	extern void page_set_colorequiv_arr(void);
1325932dc8e5Sdp78419 
1326ae115bc7Smrj 	PRM_POINT("startup_kmem() starting...");
13277c478bd9Sstevel@tonic-gate 
13287c478bd9Sstevel@tonic-gate #if defined(__amd64)
13297c478bd9Sstevel@tonic-gate 	if (eprom_kernelbase && eprom_kernelbase != KERNELBASE)
13307c478bd9Sstevel@tonic-gate 		cmn_err(CE_NOTE, "!kernelbase cannot be changed on 64-bit "
13317c478bd9Sstevel@tonic-gate 		    "systems.");
133235b1ab99Sjosephb 	kernelbase = segkpm_base - KERNEL_REDZONE_SIZE;
13337c478bd9Sstevel@tonic-gate 	core_base = (uintptr_t)COREHEAP_BASE;
1334ae115bc7Smrj 	core_size = (size_t)MISC_VA_BASE - COREHEAP_BASE;
13357c478bd9Sstevel@tonic-gate #else	/* __i386 */
13367c478bd9Sstevel@tonic-gate 	/*
13377c478bd9Sstevel@tonic-gate 	 * We configure kernelbase based on:
13387c478bd9Sstevel@tonic-gate 	 *
13397c478bd9Sstevel@tonic-gate 	 * 1. user specified kernelbase via eeprom command. Value cannot exceed
13407c478bd9Sstevel@tonic-gate 	 *    KERNELBASE_MAX. we large page align eprom_kernelbase
13417c478bd9Sstevel@tonic-gate 	 *
13427c478bd9Sstevel@tonic-gate 	 * 2. Default to KERNELBASE and adjust to 2X less the size for page_t.
13437c478bd9Sstevel@tonic-gate 	 *    On large memory systems we must lower kernelbase to allow
13447c478bd9Sstevel@tonic-gate 	 *    enough room for page_t's for all of memory.
13457c478bd9Sstevel@tonic-gate 	 *
13467c478bd9Sstevel@tonic-gate 	 * The value set here, might be changed a little later.
13477c478bd9Sstevel@tonic-gate 	 */
13487c478bd9Sstevel@tonic-gate 	if (eprom_kernelbase) {
13497c478bd9Sstevel@tonic-gate 		kernelbase = eprom_kernelbase & mmu.level_mask[1];
13507c478bd9Sstevel@tonic-gate 		if (kernelbase > KERNELBASE_MAX)
13517c478bd9Sstevel@tonic-gate 			kernelbase = KERNELBASE_MAX;
13527c478bd9Sstevel@tonic-gate 	} else {
13537c478bd9Sstevel@tonic-gate 		kernelbase = (uintptr_t)KERNELBASE;
13547c478bd9Sstevel@tonic-gate 		kernelbase -= ROUND_UP_4MEG(2 * valloc_sz);
13557c478bd9Sstevel@tonic-gate 	}
13567c478bd9Sstevel@tonic-gate 	ASSERT((kernelbase & mmu.level_offset[1]) == 0);
1357ae115bc7Smrj 	core_base = valloc_base;
13587c478bd9Sstevel@tonic-gate 	core_size = 0;
1359ae115bc7Smrj #endif	/* __i386 */
13607c478bd9Sstevel@tonic-gate 
13617c478bd9Sstevel@tonic-gate 	PRM_DEBUG(core_base);
13627c478bd9Sstevel@tonic-gate 	PRM_DEBUG(core_size);
1363ae115bc7Smrj 	PRM_DEBUG(kernelbase);
13647c478bd9Sstevel@tonic-gate 
136535b1ab99Sjosephb #if defined(__i386)
13667c478bd9Sstevel@tonic-gate 	segkp_fromheap = 1;
1367ae115bc7Smrj #endif	/* __i386 */
136835b1ab99Sjosephb 
13697c478bd9Sstevel@tonic-gate 	ekernelheap = (char *)core_base;
1370ae115bc7Smrj 	PRM_DEBUG(ekernelheap);
13717c478bd9Sstevel@tonic-gate 
13727c478bd9Sstevel@tonic-gate 	/*
13737c478bd9Sstevel@tonic-gate 	 * Now that we know the real value of kernelbase,
13747c478bd9Sstevel@tonic-gate 	 * update variables that were initialized with a value of
13757c478bd9Sstevel@tonic-gate 	 * KERNELBASE (in common/conf/param.c).
13767c478bd9Sstevel@tonic-gate 	 *
13777c478bd9Sstevel@tonic-gate 	 * XXX	The problem with this sort of hackery is that the
13787c478bd9Sstevel@tonic-gate 	 *	compiler just may feel like putting the const declarations
13797c478bd9Sstevel@tonic-gate 	 *	(in param.c) into the .text section.  Perhaps they should
13807c478bd9Sstevel@tonic-gate 	 *	just be declared as variables there?
13817c478bd9Sstevel@tonic-gate 	 */
13827c478bd9Sstevel@tonic-gate 
13837c478bd9Sstevel@tonic-gate 	*(uintptr_t *)&_kernelbase = kernelbase;
13847c478bd9Sstevel@tonic-gate 	*(uintptr_t *)&_userlimit = kernelbase;
1385ccbaea4fSjosephb #if defined(__amd64)
1386ccbaea4fSjosephb 	*(uintptr_t *)&_userlimit -= KERNELBASE - USERLIMIT;
1387ccbaea4fSjosephb #else
13887c478bd9Sstevel@tonic-gate 	*(uintptr_t *)&_userlimit32 = _userlimit;
13897c478bd9Sstevel@tonic-gate #endif
13907c478bd9Sstevel@tonic-gate 	PRM_DEBUG(_kernelbase);
13917c478bd9Sstevel@tonic-gate 	PRM_DEBUG(_userlimit);
13927c478bd9Sstevel@tonic-gate 	PRM_DEBUG(_userlimit32);
13937c478bd9Sstevel@tonic-gate 
139435b1ab99Sjosephb 	layout_kernel_va();
139535b1ab99Sjosephb 
139635b1ab99Sjosephb #if defined(__i386)
139735b1ab99Sjosephb 	/*
139835b1ab99Sjosephb 	 * If segmap is too large we can push the bottom of the kernel heap
139935b1ab99Sjosephb 	 * higher than the base.  Or worse, it could exceed the top of the
140035b1ab99Sjosephb 	 * VA space entirely, causing it to wrap around.
140135b1ab99Sjosephb 	 */
140235b1ab99Sjosephb 	if (kernelheap >= ekernelheap || (uintptr_t)kernelheap < kernelbase)
140335b1ab99Sjosephb 		panic("too little address space available for kernelheap,"
140435b1ab99Sjosephb 		    " use eeprom for lower kernelbase or smaller segmapsize");
140535b1ab99Sjosephb #endif	/* __i386 */
140635b1ab99Sjosephb 
14077c478bd9Sstevel@tonic-gate 	/*
14087c478bd9Sstevel@tonic-gate 	 * Initialize the kernel heap. Note 3rd argument must be > 1st.
14097c478bd9Sstevel@tonic-gate 	 */
141035b1ab99Sjosephb 	kernelheap_init(kernelheap, ekernelheap,
141135b1ab99Sjosephb 	    kernelheap + MMU_PAGESIZE,
1412ae115bc7Smrj 	    (void *)core_base, (void *)(core_base + core_size));
14137c478bd9Sstevel@tonic-gate 
1414843e1988Sjohnlev #if defined(__xpv)
1415843e1988Sjohnlev 	/*
1416843e1988Sjohnlev 	 * Link pending events struct into cpu struct
1417843e1988Sjohnlev 	 */
1418843e1988Sjohnlev 	CPU->cpu_m.mcpu_evt_pend = &cpu0_evt_data;
1419843e1988Sjohnlev #endif
14207c478bd9Sstevel@tonic-gate 	/*
14217c478bd9Sstevel@tonic-gate 	 * Initialize kernel memory allocator.
14227c478bd9Sstevel@tonic-gate 	 */
14237c478bd9Sstevel@tonic-gate 	kmem_init();
14247c478bd9Sstevel@tonic-gate 
14257c478bd9Sstevel@tonic-gate 	/*
1426932dc8e5Sdp78419 	 * Factor in colorequiv to check additional 'equivalent' bins
1427932dc8e5Sdp78419 	 */
1428932dc8e5Sdp78419 	page_set_colorequiv_arr();
1429932dc8e5Sdp78419 
1430932dc8e5Sdp78419 	/*
14317c478bd9Sstevel@tonic-gate 	 * print this out early so that we know what's going on
14327c478bd9Sstevel@tonic-gate 	 */
14337417cfdeSKuriakose Kuruvilla 	print_x86_featureset(x86_featureset);
14347c478bd9Sstevel@tonic-gate 
14357c478bd9Sstevel@tonic-gate 	/*
14367c478bd9Sstevel@tonic-gate 	 * Initialize bp_mapin().
14377c478bd9Sstevel@tonic-gate 	 */
14387c478bd9Sstevel@tonic-gate 	bp_init(MMU_PAGESIZE, HAT_STORECACHING_OK);
14397c478bd9Sstevel@tonic-gate 
1440f53ad214Skchow 	/*
1441f53ad214Skchow 	 * orig_npages is non-zero if physmem has been configured for less
1442f53ad214Skchow 	 * than the available memory.
1443f53ad214Skchow 	 */
1444f53ad214Skchow 	if (orig_npages) {
144535b1ab99Sjosephb 		cmn_err(CE_WARN, "!%slimiting physmem to 0x%lx of 0x%lx pages",
144635b1ab99Sjosephb 		    (npages == PHYSMEM ? "Due to virtual address space " : ""),
1447f53ad214Skchow 		    npages, orig_npages);
1448f53ad214Skchow 	}
14497c478bd9Sstevel@tonic-gate #if defined(__i386)
14507c478bd9Sstevel@tonic-gate 	if (eprom_kernelbase && (eprom_kernelbase != kernelbase))
14517c478bd9Sstevel@tonic-gate 		cmn_err(CE_WARN, "kernelbase value, User specified 0x%lx, "
14527c478bd9Sstevel@tonic-gate 		    "System using 0x%lx",
14537c478bd9Sstevel@tonic-gate 		    (uintptr_t)eprom_kernelbase, (uintptr_t)kernelbase);
14547c478bd9Sstevel@tonic-gate #endif
14557c478bd9Sstevel@tonic-gate 
14567c478bd9Sstevel@tonic-gate #ifdef	KERNELBASE_ABI_MIN
14577c478bd9Sstevel@tonic-gate 	if (kernelbase < (uintptr_t)KERNELBASE_ABI_MIN) {
14587c478bd9Sstevel@tonic-gate 		cmn_err(CE_NOTE, "!kernelbase set to 0x%lx, system is not "
14597c478bd9Sstevel@tonic-gate 		    "i386 ABI compliant.", (uintptr_t)kernelbase);
14607c478bd9Sstevel@tonic-gate 	}
14617c478bd9Sstevel@tonic-gate #endif
14627c478bd9Sstevel@tonic-gate 
1463a3114836SGerry Liu #ifndef __xpv
1464a3114836SGerry Liu 	if (plat_dr_support_memory()) {
1465a3114836SGerry Liu 		mem_config_init();
1466a3114836SGerry Liu 	}
1467a3114836SGerry Liu #else	/* __xpv */
1468843e1988Sjohnlev 	/*
1469843e1988Sjohnlev 	 * Some of the xen start information has to be relocated up
1470843e1988Sjohnlev 	 * into the kernel's permanent address space.
1471843e1988Sjohnlev 	 */
1472843e1988Sjohnlev 	PRM_POINT("calling xen_relocate_start_info()");
1473843e1988Sjohnlev 	xen_relocate_start_info();
1474843e1988Sjohnlev 	PRM_POINT("xen_relocate_start_info() done");
1475843e1988Sjohnlev 
1476843e1988Sjohnlev 	/*
1477843e1988Sjohnlev 	 * (Update the vcpu pointer in our cpu structure to point into
1478843e1988Sjohnlev 	 * the relocated shared info.)
1479843e1988Sjohnlev 	 */
1480843e1988Sjohnlev 	CPU->cpu_m.mcpu_vcpu_info =
1481843e1988Sjohnlev 	    &HYPERVISOR_shared_info->vcpu_info[CPU->cpu_id];
1482a3114836SGerry Liu #endif	/* __xpv */
1483843e1988Sjohnlev 
1484ae115bc7Smrj 	PRM_POINT("startup_kmem() done");
14857c478bd9Sstevel@tonic-gate }
14867c478bd9Sstevel@tonic-gate 
1487551bc2a6Smrj #ifndef __xpv
1488551bc2a6Smrj /*
1489551bc2a6Smrj  * If we have detected that we are running in an HVM environment, we need
1490551bc2a6Smrj  * to prepend the PV driver directory to the module search path.
1491551bc2a6Smrj  */
1492551bc2a6Smrj #define	HVM_MOD_DIR "/platform/i86hvm/kernel"
1493551bc2a6Smrj static void
1494551bc2a6Smrj update_default_path()
1495551bc2a6Smrj {
1496551bc2a6Smrj 	char *current, *newpath;
1497551bc2a6Smrj 	int newlen;
1498551bc2a6Smrj 
1499551bc2a6Smrj 	/*
1500551bc2a6Smrj 	 * We are about to resync with krtld.  krtld will reset its
1501551bc2a6Smrj 	 * internal module search path iff Solaris has set default_path.
1502551bc2a6Smrj 	 * We want to be sure we're prepending this new directory to the
1503551bc2a6Smrj 	 * right search path.
1504551bc2a6Smrj 	 */
1505551bc2a6Smrj 	current = (default_path == NULL) ? kobj_module_path : default_path;
1506551bc2a6Smrj 
1507b6611e3bSStuart Maybee 	newlen = strlen(HVM_MOD_DIR) + strlen(current) + 2;
1508551bc2a6Smrj 	newpath = kmem_alloc(newlen, KM_SLEEP);
1509551bc2a6Smrj 	(void) strcpy(newpath, HVM_MOD_DIR);
1510551bc2a6Smrj 	(void) strcat(newpath, " ");
1511551bc2a6Smrj 	(void) strcat(newpath, current);
1512551bc2a6Smrj 
1513551bc2a6Smrj 	default_path = newpath;
1514551bc2a6Smrj }
1515551bc2a6Smrj #endif
1516551bc2a6Smrj 
15177c478bd9Sstevel@tonic-gate static void
15187c478bd9Sstevel@tonic-gate startup_modules(void)
15197c478bd9Sstevel@tonic-gate {
1520ed5289f9SKen Erickson 	int cnt;
15217c478bd9Sstevel@tonic-gate 	extern void prom_setup(void);
1522ed5289f9SKen Erickson 	int32_t v, h;
1523ed5289f9SKen Erickson 	char d[11];
1524ed5289f9SKen Erickson 	char *cp;
1525e4b86885SCheng Sean Ye 	cmi_hdl_t hdl;
15267c478bd9Sstevel@tonic-gate 
15277c478bd9Sstevel@tonic-gate 	PRM_POINT("startup_modules() starting...");
1528843e1988Sjohnlev 
1529843e1988Sjohnlev #ifndef __xpv
15307c478bd9Sstevel@tonic-gate 	/*
15317c478bd9Sstevel@tonic-gate 	 * Initialize ten-micro second timer so that drivers will
15327c478bd9Sstevel@tonic-gate 	 * not get short changed in their init phase. This was
15337c478bd9Sstevel@tonic-gate 	 * not getting called until clkinit which, on fast cpu's
15347c478bd9Sstevel@tonic-gate 	 * caused the drv_usecwait to be way too short.
15357c478bd9Sstevel@tonic-gate 	 */
15367c478bd9Sstevel@tonic-gate 	microfind();
1537551bc2a6Smrj 
1538*79ec9da8SYuri Pankov 	if ((get_hwenv() & HW_XEN_HVM) != 0)
1539551bc2a6Smrj 		update_default_path();
1540843e1988Sjohnlev #endif
15417c478bd9Sstevel@tonic-gate 
15427c478bd9Sstevel@tonic-gate 	/*
15437c478bd9Sstevel@tonic-gate 	 * Read the GMT lag from /etc/rtc_config.
15447c478bd9Sstevel@tonic-gate 	 */
1545ae115bc7Smrj 	sgmtl(process_rtc_config_file());
15467c478bd9Sstevel@tonic-gate 
15477c478bd9Sstevel@tonic-gate 	/*
15487c478bd9Sstevel@tonic-gate 	 * Calculate default settings of system parameters based upon
15497c478bd9Sstevel@tonic-gate 	 * maxusers, yet allow to be overridden via the /etc/system file.
15507c478bd9Sstevel@tonic-gate 	 */
15517c478bd9Sstevel@tonic-gate 	param_calc(0);
15527c478bd9Sstevel@tonic-gate 
15537c478bd9Sstevel@tonic-gate 	mod_setup();
15547c478bd9Sstevel@tonic-gate 
15557c478bd9Sstevel@tonic-gate 	/*
15567c478bd9Sstevel@tonic-gate 	 * Initialize system parameters.
15577c478bd9Sstevel@tonic-gate 	 */
15587c478bd9Sstevel@tonic-gate 	param_init();
15597c478bd9Sstevel@tonic-gate 
15607c478bd9Sstevel@tonic-gate 	/*
15619acbbeafSnn35248 	 * Initialize the default brands
15629acbbeafSnn35248 	 */
15639acbbeafSnn35248 	brand_init();
15649acbbeafSnn35248 
15659acbbeafSnn35248 	/*
15667c478bd9Sstevel@tonic-gate 	 * maxmem is the amount of physical memory we're playing with.
15677c478bd9Sstevel@tonic-gate 	 */
15687c478bd9Sstevel@tonic-gate 	maxmem = physmem;
15697c478bd9Sstevel@tonic-gate 
15707c478bd9Sstevel@tonic-gate 	/*
15717c478bd9Sstevel@tonic-gate 	 * Initialize segment management stuff.
15727c478bd9Sstevel@tonic-gate 	 */
15737c478bd9Sstevel@tonic-gate 	seg_init();
15747c478bd9Sstevel@tonic-gate 
15757c478bd9Sstevel@tonic-gate 	if (modload("fs", "specfs") == -1)
15767c478bd9Sstevel@tonic-gate 		halt("Can't load specfs");
15777c478bd9Sstevel@tonic-gate 
15787c478bd9Sstevel@tonic-gate 	if (modload("fs", "devfs") == -1)
15797c478bd9Sstevel@tonic-gate 		halt("Can't load devfs");
15807c478bd9Sstevel@tonic-gate 
1581facf4a8dSllai1 	if (modload("fs", "dev") == -1)
1582facf4a8dSllai1 		halt("Can't load dev");
1583facf4a8dSllai1 
158435a5a358SJonathan Adams 	if (modload("fs", "procfs") == -1)
158535a5a358SJonathan Adams 		halt("Can't load procfs");
158635a5a358SJonathan Adams 
158745916cd2Sjpk 	(void) modloadonly("sys", "lbl_edition");
158845916cd2Sjpk 
15897c478bd9Sstevel@tonic-gate 	dispinit();
15907c478bd9Sstevel@tonic-gate 
15917c478bd9Sstevel@tonic-gate 	/* Read cluster configuration data. */
15927c478bd9Sstevel@tonic-gate 	clconf_init();
15937c478bd9Sstevel@tonic-gate 
1594843e1988Sjohnlev #if defined(__xpv)
1595349b53ddSStuart Maybee 	(void) ec_init();
1596843e1988Sjohnlev 	gnttab_init();
1597843e1988Sjohnlev 	(void) xs_early_init();
1598843e1988Sjohnlev #endif /* __xpv */
1599843e1988Sjohnlev 
16007c478bd9Sstevel@tonic-gate 	/*
16017c478bd9Sstevel@tonic-gate 	 * Create a kernel device tree. First, create rootnex and
16027c478bd9Sstevel@tonic-gate 	 * then invoke bus specific code to probe devices.
16037c478bd9Sstevel@tonic-gate 	 */
16047c478bd9Sstevel@tonic-gate 	setup_ddi();
16057aec1d6eScindi 
1606074bb90dSTom Pothier #ifdef __xpv
1607074bb90dSTom Pothier 	if (DOMAIN_IS_INITDOMAIN(xen_info))
1608074bb90dSTom Pothier #endif
1609074bb90dSTom Pothier 	{
1610074bb90dSTom Pothier 		/*
1611074bb90dSTom Pothier 		 * Load the System Management BIOS into the global ksmbios
1612074bb90dSTom Pothier 		 * handle, if an SMBIOS is present on this system.
1613074bb90dSTom Pothier 		 */
1614074bb90dSTom Pothier 		ksmbios = smbios_open(NULL, SMB_VERSION, ksmbios_flags, NULL);
1615074bb90dSTom Pothier 	}
1616074bb90dSTom Pothier 
1617074bb90dSTom Pothier 
16187aec1d6eScindi 	/*
16199e3e4df2SGarrett D'Amore 	 * Originally clconf_init() apparently needed the hostid.  But
16209e3e4df2SGarrett D'Amore 	 * this no longer appears to be true - it uses its own nodeid.
16219e3e4df2SGarrett D'Amore 	 * By placing the hostid logic here, we are able to make use of
16229e3e4df2SGarrett D'Amore 	 * the SMBIOS UUID.
16239e3e4df2SGarrett D'Amore 	 */
16249e3e4df2SGarrett D'Amore 	if ((h = set_soft_hostid()) == HW_INVALID_HOSTID) {
16259e3e4df2SGarrett D'Amore 		cmn_err(CE_WARN, "Unable to set hostid");
16269e3e4df2SGarrett D'Amore 	} else {
16279e3e4df2SGarrett D'Amore 		for (v = h, cnt = 0; cnt < 10; cnt++) {
16289e3e4df2SGarrett D'Amore 			d[cnt] = (char)(v % 10);
16299e3e4df2SGarrett D'Amore 			v /= 10;
16309e3e4df2SGarrett D'Amore 			if (v == 0)
16319e3e4df2SGarrett D'Amore 				break;
16329e3e4df2SGarrett D'Amore 		}
16339e3e4df2SGarrett D'Amore 		for (cp = hw_serial; cnt >= 0; cnt--)
16349e3e4df2SGarrett D'Amore 			*cp++ = d[cnt] + '0';
16359e3e4df2SGarrett D'Amore 		*cp = 0;
16369e3e4df2SGarrett D'Amore 	}
16379e3e4df2SGarrett D'Amore 
16389e3e4df2SGarrett D'Amore 	/*
1639e4b86885SCheng Sean Ye 	 * Set up the CPU module subsystem for the boot cpu in the native
1640e4b86885SCheng Sean Ye 	 * case, and all physical cpu resource in the xpv dom0 case.
1641e4b86885SCheng Sean Ye 	 * Modifies the device tree, so this must be done after
1642e4b86885SCheng Sean Ye 	 * setup_ddi().
16437aec1d6eScindi 	 */
1644e4b86885SCheng Sean Ye #ifdef __xpv
1645e4b86885SCheng Sean Ye 	/*
1646e4b86885SCheng Sean Ye 	 * If paravirtualized and on dom0 then we initialize all physical
1647e4b86885SCheng Sean Ye 	 * cpu handles now;  if paravirtualized on a domU then do not
1648e4b86885SCheng Sean Ye 	 * initialize.
1649e4b86885SCheng Sean Ye 	 */
1650e4b86885SCheng Sean Ye 	if (DOMAIN_IS_INITDOMAIN(xen_info)) {
1651e4b86885SCheng Sean Ye 		xen_mc_lcpu_cookie_t cpi;
16527aec1d6eScindi 
1653e4b86885SCheng Sean Ye 		for (cpi = xen_physcpu_next(NULL); cpi != NULL;
1654e4b86885SCheng Sean Ye 		    cpi = xen_physcpu_next(cpi)) {
1655e4b86885SCheng Sean Ye 			if ((hdl = cmi_init(CMI_HDL_SOLARIS_xVM_MCA,
1656e4b86885SCheng Sean Ye 			    xen_physcpu_chipid(cpi), xen_physcpu_coreid(cpi),
1657e4b86885SCheng Sean Ye 			    xen_physcpu_strandid(cpi))) != NULL &&
16587417cfdeSKuriakose Kuruvilla 			    is_x86_feature(x86_featureset, X86FSET_MCA))
165920c794b3Sgavinm 				cmi_mca_init(hdl);
166020c794b3Sgavinm 		}
166120c794b3Sgavinm 	}
1662e4b86885SCheng Sean Ye #else
1663e4b86885SCheng Sean Ye 	/*
1664e4b86885SCheng Sean Ye 	 * Initialize a handle for the boot cpu - others will initialize
1665e4b86885SCheng Sean Ye 	 * as they startup.  Do not do this if we know we are in an HVM domU.
1666e4b86885SCheng Sean Ye 	 */
1667*79ec9da8SYuri Pankov 	if ((get_hwenv() & HW_XEN_HVM) == 0 &&
1668e4b86885SCheng Sean Ye 	    (hdl = cmi_init(CMI_HDL_NATIVE, cmi_ntv_hwchipid(CPU),
1669e4b86885SCheng Sean Ye 	    cmi_ntv_hwcoreid(CPU), cmi_ntv_hwstrandid(CPU))) != NULL &&
16707417cfdeSKuriakose Kuruvilla 	    is_x86_feature(x86_featureset, X86FSET_MCA)) {
1671e4b86885SCheng Sean Ye 			cmi_mca_init(hdl);
1672a3114836SGerry Liu 			CPU->cpu_m.mcpu_cmi_hdl = hdl;
1673a3114836SGerry Liu 	}
167420c794b3Sgavinm #endif	/* __xpv */
16757aec1d6eScindi 
16767c478bd9Sstevel@tonic-gate 	/*
16777c478bd9Sstevel@tonic-gate 	 * Fake a prom tree such that /dev/openprom continues to work
16787c478bd9Sstevel@tonic-gate 	 */
1679ae115bc7Smrj 	PRM_POINT("startup_modules: calling prom_setup...");
16807c478bd9Sstevel@tonic-gate 	prom_setup();
1681ae115bc7Smrj 	PRM_POINT("startup_modules: done");
16827c478bd9Sstevel@tonic-gate 
16837c478bd9Sstevel@tonic-gate 	/*
16847c478bd9Sstevel@tonic-gate 	 * Load all platform specific modules
16857c478bd9Sstevel@tonic-gate 	 */
1686ae115bc7Smrj 	PRM_POINT("startup_modules: calling psm_modload...");
16877c478bd9Sstevel@tonic-gate 	psm_modload();
16887c478bd9Sstevel@tonic-gate 
16897c478bd9Sstevel@tonic-gate 	PRM_POINT("startup_modules() done");
16907c478bd9Sstevel@tonic-gate }
16917c478bd9Sstevel@tonic-gate 
1692ae115bc7Smrj /*
1693ae115bc7Smrj  * claim a "setaside" boot page for use in the kernel
1694ae115bc7Smrj  */
1695ae115bc7Smrj page_t *
1696ae115bc7Smrj boot_claim_page(pfn_t pfn)
16977c478bd9Sstevel@tonic-gate {
1698ae115bc7Smrj 	page_t *pp;
16997c478bd9Sstevel@tonic-gate 
1700ae115bc7Smrj 	pp = page_numtopp_nolock(pfn);
1701ae115bc7Smrj 	ASSERT(pp != NULL);
17027c478bd9Sstevel@tonic-gate 
1703ae115bc7Smrj 	if (PP_ISBOOTPAGES(pp)) {
1704ae115bc7Smrj 		if (pp->p_next != NULL)
1705ae115bc7Smrj 			pp->p_next->p_prev = pp->p_prev;
1706ae115bc7Smrj 		if (pp->p_prev == NULL)
1707ae115bc7Smrj 			bootpages = pp->p_next;
1708ae115bc7Smrj 		else
1709ae115bc7Smrj 			pp->p_prev->p_next = pp->p_next;
1710ae115bc7Smrj 	} else {
17117c478bd9Sstevel@tonic-gate 		/*
1712ae115bc7Smrj 		 * htable_attach() expects a base pagesize page
17137c478bd9Sstevel@tonic-gate 		 */
1714ae115bc7Smrj 		if (pp->p_szc != 0)
1715ae115bc7Smrj 			page_boot_demote(pp);
1716ae115bc7Smrj 		pp = page_numtopp(pfn, SE_EXCL);
1717ae115bc7Smrj 	}
1718ae115bc7Smrj 	return (pp);
17197c478bd9Sstevel@tonic-gate }
17207c478bd9Sstevel@tonic-gate 
17217c478bd9Sstevel@tonic-gate /*
17227c478bd9Sstevel@tonic-gate  * Walk through the pagetables looking for pages mapped in by boot.  If the
17237c478bd9Sstevel@tonic-gate  * setaside flag is set the pages are expected to be returned to the
17247c478bd9Sstevel@tonic-gate  * kernel later in boot, so we add them to the bootpages list.
17257c478bd9Sstevel@tonic-gate  */
17267c478bd9Sstevel@tonic-gate static void
17277c478bd9Sstevel@tonic-gate protect_boot_range(uintptr_t low, uintptr_t high, int setaside)
17287c478bd9Sstevel@tonic-gate {
17297c478bd9Sstevel@tonic-gate 	uintptr_t va = low;
17307c478bd9Sstevel@tonic-gate 	size_t len;
17317c478bd9Sstevel@tonic-gate 	uint_t prot;
17327c478bd9Sstevel@tonic-gate 	pfn_t pfn;
17337c478bd9Sstevel@tonic-gate 	page_t *pp;
17347c478bd9Sstevel@tonic-gate 	pgcnt_t boot_protect_cnt = 0;
17357c478bd9Sstevel@tonic-gate 
1736ae115bc7Smrj 	while (kbm_probe(&va, &len, &pfn, &prot) != 0 && va < high) {
17377c478bd9Sstevel@tonic-gate 		if (va + len >= high)
17387c478bd9Sstevel@tonic-gate 			panic("0x%lx byte mapping at 0x%p exceeds boot's "
17397c478bd9Sstevel@tonic-gate 			    "legal range.", len, (void *)va);
17407c478bd9Sstevel@tonic-gate 
17417c478bd9Sstevel@tonic-gate 		while (len > 0) {
17427c478bd9Sstevel@tonic-gate 			pp = page_numtopp_alloc(pfn);
17437c478bd9Sstevel@tonic-gate 			if (pp != NULL) {
17447c478bd9Sstevel@tonic-gate 				if (setaside == 0)
17457c478bd9Sstevel@tonic-gate 					panic("Unexpected mapping by boot.  "
17467c478bd9Sstevel@tonic-gate 					    "addr=%p pfn=%lx\n",
17477c478bd9Sstevel@tonic-gate 					    (void *)va, pfn);
17487c478bd9Sstevel@tonic-gate 
17497c478bd9Sstevel@tonic-gate 				pp->p_next = bootpages;
1750ae115bc7Smrj 				pp->p_prev = NULL;
1751ae115bc7Smrj 				PP_SETBOOTPAGES(pp);
1752ae115bc7Smrj 				if (bootpages != NULL) {
1753ae115bc7Smrj 					bootpages->p_prev = pp;
1754ae115bc7Smrj 				}
17557c478bd9Sstevel@tonic-gate 				bootpages = pp;
17567c478bd9Sstevel@tonic-gate 				++boot_protect_cnt;
17577c478bd9Sstevel@tonic-gate 			}
17587c478bd9Sstevel@tonic-gate 
17597c478bd9Sstevel@tonic-gate 			++pfn;
17607c478bd9Sstevel@tonic-gate 			len -= MMU_PAGESIZE;
17617c478bd9Sstevel@tonic-gate 			va += MMU_PAGESIZE;
17627c478bd9Sstevel@tonic-gate 		}
17637c478bd9Sstevel@tonic-gate 	}
17647c478bd9Sstevel@tonic-gate 	PRM_DEBUG(boot_protect_cnt);
17657c478bd9Sstevel@tonic-gate }
17667c478bd9Sstevel@tonic-gate 
1767ae115bc7Smrj /*
176835b1ab99Sjosephb  *
1769ae115bc7Smrj  */
17707c478bd9Sstevel@tonic-gate static void
177135b1ab99Sjosephb layout_kernel_va(void)
17727c478bd9Sstevel@tonic-gate {
177335b1ab99Sjosephb 	PRM_POINT("layout_kernel_va() starting...");
17747c478bd9Sstevel@tonic-gate 	/*
1775ae115bc7Smrj 	 * Establish the final size of the kernel's heap, size of segmap,
1776ae115bc7Smrj 	 * segkp, etc.
17777c478bd9Sstevel@tonic-gate 	 */
17787c478bd9Sstevel@tonic-gate 
17797c478bd9Sstevel@tonic-gate #if defined(__amd64)
17807c478bd9Sstevel@tonic-gate 
178135b1ab99Sjosephb 	kpm_vbase = (caddr_t)segkpm_base;
1782a3114836SGerry Liu 	if (physmax + 1 < plat_dr_physmax) {
1783a3114836SGerry Liu 		kpm_size = ROUND_UP_LPAGE(mmu_ptob(plat_dr_physmax));
1784a3114836SGerry Liu 	} else {
1785ae115bc7Smrj 		kpm_size = ROUND_UP_LPAGE(mmu_ptob(physmax + 1));
1786a3114836SGerry Liu 	}
178735b1ab99Sjosephb 	if ((uintptr_t)kpm_vbase + kpm_size > (uintptr_t)valloc_base)
178835b1ab99Sjosephb 		panic("not enough room for kpm!");
1789ae115bc7Smrj 	PRM_DEBUG(kpm_size);
1790ae115bc7Smrj 	PRM_DEBUG(kpm_vbase);
1791ae115bc7Smrj 
1792ae115bc7Smrj 	/*
1793ae115bc7Smrj 	 * By default we create a seg_kp in 64 bit kernels, it's a little
1794ae115bc7Smrj 	 * faster to access than embedding it in the heap.
1795ae115bc7Smrj 	 */
1796ae115bc7Smrj 	segkp_base = (caddr_t)valloc_base + valloc_sz;
17977c478bd9Sstevel@tonic-gate 	if (!segkp_fromheap) {
17987c478bd9Sstevel@tonic-gate 		size_t sz = mmu_ptob(segkpsize);
17997c478bd9Sstevel@tonic-gate 
18007c478bd9Sstevel@tonic-gate 		/*
1801ae115bc7Smrj 		 * determine size of segkp
18027c478bd9Sstevel@tonic-gate 		 */
18037c478bd9Sstevel@tonic-gate 		if (sz < SEGKPMINSIZE || sz > SEGKPMAXSIZE) {
18047c478bd9Sstevel@tonic-gate 			sz = SEGKPDEFSIZE;
18057c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN, "!Illegal value for segkpsize. "
18067c478bd9Sstevel@tonic-gate 			    "segkpsize has been reset to %ld pages",
18077c478bd9Sstevel@tonic-gate 			    mmu_btop(sz));
18087c478bd9Sstevel@tonic-gate 		}
18097c478bd9Sstevel@tonic-gate 		sz = MIN(sz, MAX(SEGKPMINSIZE, mmu_ptob(physmem)));
18107c478bd9Sstevel@tonic-gate 
18117c478bd9Sstevel@tonic-gate 		segkpsize = mmu_btop(ROUND_UP_LPAGE(sz));
18127c478bd9Sstevel@tonic-gate 	}
1813ae115bc7Smrj 	PRM_DEBUG(segkp_base);
1814ae115bc7Smrj 	PRM_DEBUG(segkpsize);
18157c478bd9Sstevel@tonic-gate 
181635b1ab99Sjosephb 	/*
181735b1ab99Sjosephb 	 * segzio is used for ZFS cached data. It uses a distinct VA
181835b1ab99Sjosephb 	 * segment (from kernel heap) so that we can easily tell not to
181935b1ab99Sjosephb 	 * include it in kernel crash dumps on 64 bit kernels. The trick is
182035b1ab99Sjosephb 	 * to give it lots of VA, but not constrain the kernel heap.
182135b1ab99Sjosephb 	 * We scale the size of segzio linearly with physmem up to
182235b1ab99Sjosephb 	 * SEGZIOMAXSIZE. Above that amount it scales at 50% of physmem.
182335b1ab99Sjosephb 	 */
1824ae115bc7Smrj 	segzio_base = segkp_base + mmu_ptob(segkpsize);
1825ae115bc7Smrj 	if (segzio_fromheap) {
1826ae115bc7Smrj 		segziosize = 0;
1827ae115bc7Smrj 	} else {
182835b1ab99Sjosephb 		size_t physmem_size = mmu_ptob(physmem);
182935b1ab99Sjosephb 		size_t size = (segziosize == 0) ?
183035b1ab99Sjosephb 		    physmem_size : mmu_ptob(segziosize);
1831ad23a2dbSjohansen 
183235b1ab99Sjosephb 		if (size < SEGZIOMINSIZE)
1833ad23a2dbSjohansen 			size = SEGZIOMINSIZE;
183435b1ab99Sjosephb 		if (size > SEGZIOMAXSIZE) {
1835a778305aSjohansen 			size = SEGZIOMAXSIZE;
183635b1ab99Sjosephb 			if (physmem_size > size)
183735b1ab99Sjosephb 				size += (physmem_size - size) / 2;
1838ad23a2dbSjohansen 		}
1839ad23a2dbSjohansen 		segziosize = mmu_btop(ROUND_UP_LPAGE(size));
1840ae115bc7Smrj 	}
1841ad23a2dbSjohansen 	PRM_DEBUG(segziosize);
1842ad23a2dbSjohansen 	PRM_DEBUG(segzio_base);
1843ad23a2dbSjohansen 
18447c478bd9Sstevel@tonic-gate 	/*
1845ae115bc7Smrj 	 * Put the range of VA for device mappings next, kmdb knows to not
1846ae115bc7Smrj 	 * grep in this range of addresses.
18477c478bd9Sstevel@tonic-gate 	 */
1848ae115bc7Smrj 	toxic_addr =
1849ae115bc7Smrj 	    ROUND_UP_LPAGE((uintptr_t)segzio_base + mmu_ptob(segziosize));
18507c478bd9Sstevel@tonic-gate 	PRM_DEBUG(toxic_addr);
1851ae115bc7Smrj 	segmap_start = ROUND_UP_LPAGE(toxic_addr + toxic_size);
1852ae115bc7Smrj #else /* __i386 */
1853ae115bc7Smrj 	segmap_start = ROUND_UP_LPAGE(kernelbase);
1854ae115bc7Smrj #endif /* __i386 */
1855ae115bc7Smrj 	PRM_DEBUG(segmap_start);
18567c478bd9Sstevel@tonic-gate 
18577c478bd9Sstevel@tonic-gate 	/*
185852eef812SAmrita Sadhukhan 	 * Users can change segmapsize through eeprom. If the variable
185952eef812SAmrita Sadhukhan 	 * is tuned through eeprom, there is no upper bound on the
186052eef812SAmrita Sadhukhan 	 * size of segmap.
18617c478bd9Sstevel@tonic-gate 	 */
18627c478bd9Sstevel@tonic-gate 	segmapsize = MAX(ROUND_UP_LPAGE(segmapsize), SEGMAPDEFAULT);
18637c478bd9Sstevel@tonic-gate 
18647c478bd9Sstevel@tonic-gate #if defined(__i386)
18657c478bd9Sstevel@tonic-gate 	/*
18667c478bd9Sstevel@tonic-gate 	 * 32-bit systems don't have segkpm or segkp, so segmap appears at
18677c478bd9Sstevel@tonic-gate 	 * the bottom of the kernel's address range.  Set aside space for a
1868ae115bc7Smrj 	 * small red zone just below the start of segmap.
18697c478bd9Sstevel@tonic-gate 	 */
1870ae115bc7Smrj 	segmap_start += KERNEL_REDZONE_SIZE;
18717c478bd9Sstevel@tonic-gate 	segmapsize -= KERNEL_REDZONE_SIZE;
18727c478bd9Sstevel@tonic-gate #endif
18737c478bd9Sstevel@tonic-gate 
1874ae115bc7Smrj 	PRM_DEBUG(segmap_start);
18757c478bd9Sstevel@tonic-gate 	PRM_DEBUG(segmapsize);
187635b1ab99Sjosephb 	kernelheap = (caddr_t)ROUND_UP_LPAGE(segmap_start + segmapsize);
187735b1ab99Sjosephb 	PRM_DEBUG(kernelheap);
187835b1ab99Sjosephb 	PRM_POINT("layout_kernel_va() done...");
187935b1ab99Sjosephb }
188035b1ab99Sjosephb 
188135b1ab99Sjosephb /*
188235b1ab99Sjosephb  * Finish initializing the VM system, now that we are no longer
188335b1ab99Sjosephb  * relying on the boot time memory allocators.
188435b1ab99Sjosephb  */
188535b1ab99Sjosephb static void
188635b1ab99Sjosephb startup_vm(void)
188735b1ab99Sjosephb {
188835b1ab99Sjosephb 	struct segmap_crargs a;
188935b1ab99Sjosephb 
189035b1ab99Sjosephb 	extern int use_brk_lpg, use_stk_lpg;
189135b1ab99Sjosephb 
189235b1ab99Sjosephb 	PRM_POINT("startup_vm() starting...");
189335b1ab99Sjosephb 
189435b1ab99Sjosephb 	/*
189535b1ab99Sjosephb 	 * Initialize the hat layer.
189635b1ab99Sjosephb 	 */
189735b1ab99Sjosephb 	hat_init();
18987c478bd9Sstevel@tonic-gate 
18997c478bd9Sstevel@tonic-gate 	/*
1900ae115bc7Smrj 	 * Do final allocations of HAT data structures that need to
1901ae115bc7Smrj 	 * be allocated before quiescing the boot loader.
1902ae115bc7Smrj 	 */
1903ae115bc7Smrj 	PRM_POINT("Calling hat_kern_alloc()...");
1904ae115bc7Smrj 	hat_kern_alloc((caddr_t)segmap_start, segmapsize, ekernelheap);
1905ae115bc7Smrj 	PRM_POINT("hat_kern_alloc() done");
1906ae115bc7Smrj 
1907843e1988Sjohnlev #ifndef __xpv
1908ae115bc7Smrj 	/*
19091d03c31eSjohnlev 	 * Setup Page Attribute Table
1910ae115bc7Smrj 	 */
19111d03c31eSjohnlev 	pat_sync();
1912843e1988Sjohnlev #endif
1913ae115bc7Smrj 
1914ae115bc7Smrj 	/*
1915ae115bc7Smrj 	 * The next two loops are done in distinct steps in order
1916ae115bc7Smrj 	 * to be sure that any page that is doubly mapped (both above
1917ae115bc7Smrj 	 * KERNEL_TEXT and below kernelbase) is dealt with correctly.
1918ae115bc7Smrj 	 * Note this may never happen, but it might someday.
1919ae115bc7Smrj 	 */
1920ae115bc7Smrj 	bootpages = NULL;
1921ae115bc7Smrj 	PRM_POINT("Protecting boot pages");
1922ae115bc7Smrj 
1923ae115bc7Smrj 	/*
1924ae115bc7Smrj 	 * Protect any pages mapped above KERNEL_TEXT that somehow have
1925ae115bc7Smrj 	 * page_t's. This can only happen if something weird allocated
1926ae115bc7Smrj 	 * in this range (like kadb/kmdb).
1927ae115bc7Smrj 	 */
1928ae115bc7Smrj 	protect_boot_range(KERNEL_TEXT, (uintptr_t)-1, 0);
1929ae115bc7Smrj 
1930ae115bc7Smrj 	/*
1931ae115bc7Smrj 	 * Before we can take over memory allocation/mapping from the boot
1932ae115bc7Smrj 	 * loader we must remove from our free page lists any boot allocated
1933ae115bc7Smrj 	 * pages that stay mapped until release_bootstrap().
1934ae115bc7Smrj 	 */
1935ae115bc7Smrj 	protect_boot_range(0, kernelbase, 1);
1936ae115bc7Smrj 
1937843e1988Sjohnlev 
1938ae115bc7Smrj 	/*
1939ae115bc7Smrj 	 * Switch to running on regular HAT (not boot_mmu)
1940ae115bc7Smrj 	 */
1941ae115bc7Smrj 	PRM_POINT("Calling hat_kern_setup()...");
1942ae115bc7Smrj 	hat_kern_setup();
1943ae115bc7Smrj 
1944ae115bc7Smrj 	/*
1945ae115bc7Smrj 	 * It is no longer safe to call BOP_ALLOC(), so make sure we don't.
1946ae115bc7Smrj 	 */
1947ae115bc7Smrj 	bop_no_more_mem();
1948ae115bc7Smrj 
1949ae115bc7Smrj 	PRM_POINT("hat_kern_setup() done");
1950ae115bc7Smrj 
1951ae115bc7Smrj 	hat_cpu_online(CPU);
1952ae115bc7Smrj 
1953ae115bc7Smrj 	/*
19547c478bd9Sstevel@tonic-gate 	 * Initialize VM system
19557c478bd9Sstevel@tonic-gate 	 */
19567c478bd9Sstevel@tonic-gate 	PRM_POINT("Calling kvm_init()...");
19577c478bd9Sstevel@tonic-gate 	kvm_init();
19587c478bd9Sstevel@tonic-gate 	PRM_POINT("kvm_init() done");
19597c478bd9Sstevel@tonic-gate 
19607c478bd9Sstevel@tonic-gate 	/*
19617c478bd9Sstevel@tonic-gate 	 * Tell kmdb that the VM system is now working
19627c478bd9Sstevel@tonic-gate 	 */
19637c478bd9Sstevel@tonic-gate 	if (boothowto & RB_DEBUG)
19647c478bd9Sstevel@tonic-gate 		kdi_dvec_vmready();
19657c478bd9Sstevel@tonic-gate 
1966843e1988Sjohnlev #if defined(__xpv)
1967843e1988Sjohnlev 	/*
1968843e1988Sjohnlev 	 * Populate the I/O pool on domain 0
1969843e1988Sjohnlev 	 */
1970843e1988Sjohnlev 	if (DOMAIN_IS_INITDOMAIN(xen_info)) {
1971843e1988Sjohnlev 		extern long populate_io_pool(void);
1972843e1988Sjohnlev 		long init_io_pool_cnt;
1973843e1988Sjohnlev 
1974843e1988Sjohnlev 		PRM_POINT("Populating reserve I/O page pool");
1975843e1988Sjohnlev 		init_io_pool_cnt = populate_io_pool();
1976843e1988Sjohnlev 		PRM_DEBUG(init_io_pool_cnt);
1977843e1988Sjohnlev 	}
1978843e1988Sjohnlev #endif
19797c478bd9Sstevel@tonic-gate 	/*
19807c478bd9Sstevel@tonic-gate 	 * Mangle the brand string etc.
19817c478bd9Sstevel@tonic-gate 	 */
19827c478bd9Sstevel@tonic-gate 	cpuid_pass3(CPU);
19837c478bd9Sstevel@tonic-gate 
19847c478bd9Sstevel@tonic-gate #if defined(__amd64)
19857c478bd9Sstevel@tonic-gate 
19867c478bd9Sstevel@tonic-gate 	/*
19877c478bd9Sstevel@tonic-gate 	 * Create the device arena for toxic (to dtrace/kmdb) mappings.
19887c478bd9Sstevel@tonic-gate 	 */
19897c478bd9Sstevel@tonic-gate 	device_arena = vmem_create("device", (void *)toxic_addr,
19907c478bd9Sstevel@tonic-gate 	    toxic_size, MMU_PAGESIZE, NULL, NULL, NULL, 0, VM_SLEEP);
19917c478bd9Sstevel@tonic-gate 
19927c478bd9Sstevel@tonic-gate #else	/* __i386 */
19937c478bd9Sstevel@tonic-gate 
19947c478bd9Sstevel@tonic-gate 	/*
19957c478bd9Sstevel@tonic-gate 	 * allocate the bit map that tracks toxic pages
19967c478bd9Sstevel@tonic-gate 	 */
1997ae115bc7Smrj 	toxic_bit_map_len = btop((ulong_t)(valloc_base - kernelbase));
19987c478bd9Sstevel@tonic-gate 	PRM_DEBUG(toxic_bit_map_len);
19997c478bd9Sstevel@tonic-gate 	toxic_bit_map =
20007c478bd9Sstevel@tonic-gate 	    kmem_zalloc(BT_SIZEOFMAP(toxic_bit_map_len), KM_NOSLEEP);
20017c478bd9Sstevel@tonic-gate 	ASSERT(toxic_bit_map != NULL);
20027c478bd9Sstevel@tonic-gate 	PRM_DEBUG(toxic_bit_map);
20037c478bd9Sstevel@tonic-gate 
20047c478bd9Sstevel@tonic-gate #endif	/* __i386 */
20057c478bd9Sstevel@tonic-gate 
20067c478bd9Sstevel@tonic-gate 
20077c478bd9Sstevel@tonic-gate 	/*
20087c478bd9Sstevel@tonic-gate 	 * Now that we've got more VA, as well as the ability to allocate from
20097c478bd9Sstevel@tonic-gate 	 * it, tell the debugger.
20107c478bd9Sstevel@tonic-gate 	 */
20117c478bd9Sstevel@tonic-gate 	if (boothowto & RB_DEBUG)
20127c478bd9Sstevel@tonic-gate 		kdi_dvec_memavail();
20137c478bd9Sstevel@tonic-gate 
20147c478bd9Sstevel@tonic-gate 	/*
20157c478bd9Sstevel@tonic-gate 	 * The following code installs a special page fault handler (#pf)
20167c478bd9Sstevel@tonic-gate 	 * to work around a pentium bug.
20177c478bd9Sstevel@tonic-gate 	 */
2018843e1988Sjohnlev #if !defined(__amd64) && !defined(__xpv)
20197c478bd9Sstevel@tonic-gate 	if (x86_type == X86_TYPE_P5) {
2020ae115bc7Smrj 		desctbr_t idtr;
20217c478bd9Sstevel@tonic-gate 		gate_desc_t *newidt;
20227c478bd9Sstevel@tonic-gate 
20237c478bd9Sstevel@tonic-gate 		if ((newidt = kmem_zalloc(MMU_PAGESIZE, KM_NOSLEEP)) == NULL)
20247c478bd9Sstevel@tonic-gate 			panic("failed to install pentium_pftrap");
20257c478bd9Sstevel@tonic-gate 
20260cfdb603Sjosephb 		bcopy(idt0, newidt, NIDT * sizeof (*idt0));
20277c478bd9Sstevel@tonic-gate 		set_gatesegd(&newidt[T_PGFLT], &pentium_pftrap,
20289844da31SSeth Goldberg 		    KCS_SEL, SDT_SYSIGT, TRP_KPL, 0);
20297c478bd9Sstevel@tonic-gate 
20307c478bd9Sstevel@tonic-gate 		(void) as_setprot(&kas, (caddr_t)newidt, MMU_PAGESIZE,
20317c478bd9Sstevel@tonic-gate 		    PROT_READ | PROT_EXEC);
20327c478bd9Sstevel@tonic-gate 
20330cfdb603Sjosephb 		CPU->cpu_idt = newidt;
20340cfdb603Sjosephb 		idtr.dtr_base = (uintptr_t)CPU->cpu_idt;
20350cfdb603Sjosephb 		idtr.dtr_limit = (NIDT * sizeof (*idt0)) - 1;
2036ae115bc7Smrj 		wr_idtr(&idtr);
20377c478bd9Sstevel@tonic-gate 	}
20387c478bd9Sstevel@tonic-gate #endif	/* !__amd64 */
20397c478bd9Sstevel@tonic-gate 
2040843e1988Sjohnlev #if !defined(__xpv)
20417c478bd9Sstevel@tonic-gate 	/*
20427c478bd9Sstevel@tonic-gate 	 * Map page pfn=0 for drivers, such as kd, that need to pick up
20437c478bd9Sstevel@tonic-gate 	 * parameters left there by controllers/BIOS.
20447c478bd9Sstevel@tonic-gate 	 */
20457c478bd9Sstevel@tonic-gate 	PRM_POINT("setup up p0_va");
20467c478bd9Sstevel@tonic-gate 	p0_va = i86devmap(0, 1, PROT_READ);
20477c478bd9Sstevel@tonic-gate 	PRM_DEBUG(p0_va);
2048843e1988Sjohnlev #endif
20497c478bd9Sstevel@tonic-gate 
20507c478bd9Sstevel@tonic-gate 	cmn_err(CE_CONT, "?mem = %luK (0x%lx)\n",
20517c478bd9Sstevel@tonic-gate 	    physinstalled << (MMU_PAGESHIFT - 10), ptob(physinstalled));
20527c478bd9Sstevel@tonic-gate 
205383f9b804Skchow 	/*
205483f9b804Skchow 	 * disable automatic large pages for small memory systems or
205583f9b804Skchow 	 * when the disable flag is set.
205602bc52beSkchow 	 *
205702bc52beSkchow 	 * Do not yet consider page sizes larger than 2m/4m.
205883f9b804Skchow 	 */
2059ec25b48fSsusans 	if (!auto_lpg_disable && mmu.max_page_level > 0) {
2060ec25b48fSsusans 		max_uheap_lpsize = LEVEL_SIZE(1);
2061ec25b48fSsusans 		max_ustack_lpsize = LEVEL_SIZE(1);
2062ec25b48fSsusans 		max_privmap_lpsize = LEVEL_SIZE(1);
2063ec25b48fSsusans 		max_uidata_lpsize = LEVEL_SIZE(1);
2064ec25b48fSsusans 		max_utext_lpsize = LEVEL_SIZE(1);
2065ec25b48fSsusans 		max_shm_lpsize = LEVEL_SIZE(1);
2066ec25b48fSsusans 	}
2067ec25b48fSsusans 	if (physmem < privm_lpg_min_physmem || mmu.max_page_level == 0 ||
2068ec25b48fSsusans 	    auto_lpg_disable) {
2069beb1bda0Sdavemq 		use_brk_lpg = 0;
2070beb1bda0Sdavemq 		use_stk_lpg = 0;
2071ec25b48fSsusans 	}
207202bc52beSkchow 	mcntl0_lpsize = LEVEL_SIZE(mmu.umax_page_level);
2073beb1bda0Sdavemq 
20747c478bd9Sstevel@tonic-gate 	PRM_POINT("Calling hat_init_finish()...");
20757c478bd9Sstevel@tonic-gate 	hat_init_finish();
20767c478bd9Sstevel@tonic-gate 	PRM_POINT("hat_init_finish() done");
20777c478bd9Sstevel@tonic-gate 
20787c478bd9Sstevel@tonic-gate 	/*
20797c478bd9Sstevel@tonic-gate 	 * Initialize the segkp segment type.
20807c478bd9Sstevel@tonic-gate 	 */
20817c478bd9Sstevel@tonic-gate 	rw_enter(&kas.a_lock, RW_WRITER);
2082ae115bc7Smrj 	PRM_POINT("Attaching segkp");
2083ae115bc7Smrj 	if (segkp_fromheap) {
2084ae115bc7Smrj 		segkp->s_as = &kas;
2085ae115bc7Smrj 	} else if (seg_attach(&kas, (caddr_t)segkp_base, mmu_ptob(segkpsize),
20867c478bd9Sstevel@tonic-gate 	    segkp) < 0) {
20877c478bd9Sstevel@tonic-gate 		panic("startup: cannot attach segkp");
20887c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
20897c478bd9Sstevel@tonic-gate 	}
2090ae115bc7Smrj 	PRM_POINT("Doing segkp_create()");
20917c478bd9Sstevel@tonic-gate 	if (segkp_create(segkp) != 0) {
20927c478bd9Sstevel@tonic-gate 		panic("startup: segkp_create failed");
20937c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
20947c478bd9Sstevel@tonic-gate 	}
20957c478bd9Sstevel@tonic-gate 	PRM_DEBUG(segkp);
20967c478bd9Sstevel@tonic-gate 	rw_exit(&kas.a_lock);
20977c478bd9Sstevel@tonic-gate 
20987c478bd9Sstevel@tonic-gate 	/*
20997c478bd9Sstevel@tonic-gate 	 * kpm segment
21007c478bd9Sstevel@tonic-gate 	 */
21017c478bd9Sstevel@tonic-gate 	segmap_kpm = 0;
21027c478bd9Sstevel@tonic-gate 	if (kpm_desired) {
21037c478bd9Sstevel@tonic-gate 		kpm_init();
21047c478bd9Sstevel@tonic-gate 		kpm_enable = 1;
21057c478bd9Sstevel@tonic-gate 	}
21067c478bd9Sstevel@tonic-gate 
21077c478bd9Sstevel@tonic-gate 	/*
21087c478bd9Sstevel@tonic-gate 	 * Now create segmap segment.
21097c478bd9Sstevel@tonic-gate 	 */
21107c478bd9Sstevel@tonic-gate 	rw_enter(&kas.a_lock, RW_WRITER);
2111ae115bc7Smrj 	if (seg_attach(&kas, (caddr_t)segmap_start, segmapsize, segmap) < 0) {
2112ae115bc7Smrj 		panic("cannot attach segmap");
21137c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
21147c478bd9Sstevel@tonic-gate 	}
2115ae115bc7Smrj 	PRM_DEBUG(segmap);
21167c478bd9Sstevel@tonic-gate 
21177c478bd9Sstevel@tonic-gate 	a.prot = PROT_READ | PROT_WRITE;
21187c478bd9Sstevel@tonic-gate 	a.shmsize = 0;
21197c478bd9Sstevel@tonic-gate 	a.nfreelist = segmapfreelists;
21207c478bd9Sstevel@tonic-gate 
2121ae115bc7Smrj 	if (segmap_create(segmap, (caddr_t)&a) != 0)
2122ae115bc7Smrj 		panic("segmap_create segmap");
21237c478bd9Sstevel@tonic-gate 	rw_exit(&kas.a_lock);
21247c478bd9Sstevel@tonic-gate 
21257c478bd9Sstevel@tonic-gate 	setup_vaddr_for_ppcopy(CPU);
21267c478bd9Sstevel@tonic-gate 
21277c478bd9Sstevel@tonic-gate 	segdev_init();
2128843e1988Sjohnlev #if defined(__xpv)
2129843e1988Sjohnlev 	if (DOMAIN_IS_INITDOMAIN(xen_info))
2130843e1988Sjohnlev #endif
21317c478bd9Sstevel@tonic-gate 		pmem_init();
2132ae115bc7Smrj 
21337c478bd9Sstevel@tonic-gate 	PRM_POINT("startup_vm() done");
21347c478bd9Sstevel@tonic-gate }
21357c478bd9Sstevel@tonic-gate 
2136ae115bc7Smrj /*
2137ae115bc7Smrj  * Load a tod module for the non-standard tod part found on this system.
2138ae115bc7Smrj  */
2139ae115bc7Smrj static void
2140ae115bc7Smrj load_tod_module(char *todmod)
2141ae115bc7Smrj {
2142ae115bc7Smrj 	if (modload("tod", todmod) == -1)
2143ae115bc7Smrj 		halt("Can't load TOD module");
2144ae115bc7Smrj }
2145ae115bc7Smrj 
21467c478bd9Sstevel@tonic-gate static void
21477c478bd9Sstevel@tonic-gate startup_end(void)
21487c478bd9Sstevel@tonic-gate {
2149dd4eeefdSeota 	int i;
21507c478bd9Sstevel@tonic-gate 	extern void setx86isalist(void);
2151fb2caebeSRandy Fishel 	extern void cpu_event_init(void);
21527c478bd9Sstevel@tonic-gate 
21537c478bd9Sstevel@tonic-gate 	PRM_POINT("startup_end() starting...");
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate 	/*
21567c478bd9Sstevel@tonic-gate 	 * Perform tasks that get done after most of the VM
21577c478bd9Sstevel@tonic-gate 	 * initialization has been done but before the clock
21587c478bd9Sstevel@tonic-gate 	 * and other devices get started.
21597c478bd9Sstevel@tonic-gate 	 */
21607c478bd9Sstevel@tonic-gate 	kern_setup1();
21617c478bd9Sstevel@tonic-gate 
21627c478bd9Sstevel@tonic-gate 	/*
21637c478bd9Sstevel@tonic-gate 	 * Perform CPC initialization for this CPU.
21647c478bd9Sstevel@tonic-gate 	 */
21657c478bd9Sstevel@tonic-gate 	kcpc_hw_init(CPU);
21667c478bd9Sstevel@tonic-gate 
2167fb2caebeSRandy Fishel 	/*
2168fb2caebeSRandy Fishel 	 * Initialize cpu event framework.
2169fb2caebeSRandy Fishel 	 */
2170fb2caebeSRandy Fishel 	cpu_event_init();
2171fb2caebeSRandy Fishel 
2172ee88d2b9Skchow #if defined(OPTERON_WORKAROUND_6323525)
2173ee88d2b9Skchow 	if (opteron_workaround_6323525)
2174ee88d2b9Skchow 		patch_workaround_6323525();
2175ee88d2b9Skchow #endif
21767c478bd9Sstevel@tonic-gate 	/*
2177ae115bc7Smrj 	 * If needed, load TOD module now so that ddi_get_time(9F) etc. work
2178ae115bc7Smrj 	 * (For now, "needed" is defined as set tod_module_name in /etc/system)
2179ae115bc7Smrj 	 */
2180ae115bc7Smrj 	if (tod_module_name != NULL) {
2181ae115bc7Smrj 		PRM_POINT("load_tod_module()");
2182ae115bc7Smrj 		load_tod_module(tod_module_name);
2183ae115bc7Smrj 	}
2184ae115bc7Smrj 
2185843e1988Sjohnlev #if defined(__xpv)
2186843e1988Sjohnlev 	/*
2187843e1988Sjohnlev 	 * Forceload interposing TOD module for the hypervisor.
2188843e1988Sjohnlev 	 */
2189843e1988Sjohnlev 	PRM_POINT("load_tod_module()");
2190843e1988Sjohnlev 	load_tod_module("xpvtod");
2191843e1988Sjohnlev #endif
2192843e1988Sjohnlev 
2193ae115bc7Smrj 	/*
21947c478bd9Sstevel@tonic-gate 	 * Configure the system.
21957c478bd9Sstevel@tonic-gate 	 */
21967c478bd9Sstevel@tonic-gate 	PRM_POINT("Calling configure()...");
21977c478bd9Sstevel@tonic-gate 	configure();		/* set up devices */
21987c478bd9Sstevel@tonic-gate 	PRM_POINT("configure() done");
21997c478bd9Sstevel@tonic-gate 
22007c478bd9Sstevel@tonic-gate 	/*
22017af88ac7SKuriakose Kuruvilla 	 * We can now setup for XSAVE because fpu_probe is done in configure().
22027af88ac7SKuriakose Kuruvilla 	 */
22037af88ac7SKuriakose Kuruvilla 	if (fp_save_mech == FP_XSAVE) {
22047af88ac7SKuriakose Kuruvilla 		xsave_setup_msr(CPU);
22057af88ac7SKuriakose Kuruvilla 	}
22067af88ac7SKuriakose Kuruvilla 
22077af88ac7SKuriakose Kuruvilla 	/*
22087c478bd9Sstevel@tonic-gate 	 * Set the isa_list string to the defined instruction sets we
22097c478bd9Sstevel@tonic-gate 	 * support.
22107c478bd9Sstevel@tonic-gate 	 */
22117c478bd9Sstevel@tonic-gate 	setx86isalist();
2212100b72f4Sandrei 	cpu_intr_alloc(CPU, NINTR_THREADS);
22137c478bd9Sstevel@tonic-gate 	psm_install();
22147c478bd9Sstevel@tonic-gate 
22157c478bd9Sstevel@tonic-gate 	/*
22167c478bd9Sstevel@tonic-gate 	 * We're done with bootops.  We don't unmap the bootstrap yet because
22177c478bd9Sstevel@tonic-gate 	 * we're still using bootsvcs.
22187c478bd9Sstevel@tonic-gate 	 */
2219ae115bc7Smrj 	PRM_POINT("NULLing out bootops");
2220ae115bc7Smrj 	*bootopsp = (struct bootops *)NULL;
22217c478bd9Sstevel@tonic-gate 	bootops = (struct bootops *)NULL;
22227c478bd9Sstevel@tonic-gate 
2223843e1988Sjohnlev #if defined(__xpv)
2224843e1988Sjohnlev 	ec_init_debug_irq();
2225843e1988Sjohnlev 	xs_domu_init();
2226843e1988Sjohnlev #endif
22271de082f7SVikram Hegde 
22283a634bfcSVikram Hegde #if defined(__amd64) && !defined(__xpv)
22293a634bfcSVikram Hegde 	/*
22303a634bfcSVikram Hegde 	 * Intel IOMMU has been setup/initialized in ddi_impl.c
22313a634bfcSVikram Hegde 	 * Start it up now.
22323a634bfcSVikram Hegde 	 */
22333a634bfcSVikram Hegde 	immu_startup();
22341de082f7SVikram Hegde #endif
22353a634bfcSVikram Hegde 
22367c478bd9Sstevel@tonic-gate 	PRM_POINT("Enabling interrupts");
22377c478bd9Sstevel@tonic-gate 	(*picinitf)();
22387c478bd9Sstevel@tonic-gate 	sti();
2239843e1988Sjohnlev #if defined(__xpv)
2240843e1988Sjohnlev 	ASSERT(CPU->cpu_m.mcpu_vcpu_info->evtchn_upcall_mask == 0);
2241843e1988Sjohnlev 	xen_late_startup();
2242843e1988Sjohnlev #endif
22437c478bd9Sstevel@tonic-gate 
22447c478bd9Sstevel@tonic-gate 	(void) add_avsoftintr((void *)&softlevel1_hdl, 1, softlevel1,
22457c478bd9Sstevel@tonic-gate 	    "softlevel1", NULL, NULL); /* XXX to be moved later */
22467c478bd9Sstevel@tonic-gate 
2247dd4eeefdSeota 	/*
2248dd4eeefdSeota 	 * Register these software interrupts for ddi timer.
2249dd4eeefdSeota 	 * Software interrupts up to the level 10 are supported.
2250dd4eeefdSeota 	 */
2251dd4eeefdSeota 	for (i = DDI_IPL_1; i <= DDI_IPL_10; i++) {
2252dd4eeefdSeota 		char name[sizeof ("timer_softintr") + 2];
2253dd4eeefdSeota 		(void) sprintf(name, "timer_softintr%02d", i);
2254dd4eeefdSeota 		(void) add_avsoftintr((void *)&softlevel_hdl[i-1], i,
2255dd4eeefdSeota 		    (avfunc)timer_softintr, name, (caddr_t)(uintptr_t)i, NULL);
2256dd4eeefdSeota 	}
2257dd4eeefdSeota 
22587125fcbdSVikram Hegde #if !defined(__xpv)
22597125fcbdSVikram Hegde 	if (modload("drv", "amd_iommu") < 0) {
22607125fcbdSVikram Hegde 		PRM_POINT("No AMD IOMMU present\n");
226194f1124eSVikram Hegde 	} else if (ddi_hold_installed_driver(ddi_name_to_major(
226294f1124eSVikram Hegde 	    "amd_iommu")) == NULL) {
22637125fcbdSVikram Hegde 		prom_printf("ERROR: failed to attach AMD IOMMU\n");
22647125fcbdSVikram Hegde 	}
22657125fcbdSVikram Hegde #endif
2266e774b42bSBill Holler 	post_startup_cpu_fixups();
22677125fcbdSVikram Hegde 
22687c478bd9Sstevel@tonic-gate 	PRM_POINT("startup_end() done");
22697c478bd9Sstevel@tonic-gate }
22707c478bd9Sstevel@tonic-gate 
227196d008c2SKen Erickson /*
227296d008c2SKen Erickson  * Don't remove the following 2 variables.  They are necessary
227396d008c2SKen Erickson  * for reading the hostid from the legacy file (/kernel/misc/sysinit).
227496d008c2SKen Erickson  */
22757c478bd9Sstevel@tonic-gate char *_hs1107 = hw_serial;
22767c478bd9Sstevel@tonic-gate ulong_t  _bdhs34;
22777c478bd9Sstevel@tonic-gate 
22787c478bd9Sstevel@tonic-gate void
22797c478bd9Sstevel@tonic-gate post_startup(void)
22807c478bd9Sstevel@tonic-gate {
22810e751525SEric Saxe 	extern void cpupm_init(cpu_t *);
2282fb2caebeSRandy Fishel 	extern void cpu_event_init_cpu(cpu_t *);
22830e751525SEric Saxe 
22847c478bd9Sstevel@tonic-gate 	/*
22857c478bd9Sstevel@tonic-gate 	 * Set the system wide, processor-specific flags to be passed
22867c478bd9Sstevel@tonic-gate 	 * to userland via the aux vector for performance hints and
22877c478bd9Sstevel@tonic-gate 	 * instruction set extensions.
22887c478bd9Sstevel@tonic-gate 	 */
22897c478bd9Sstevel@tonic-gate 	bind_hwcap();
22907c478bd9Sstevel@tonic-gate 
2291843e1988Sjohnlev #ifdef __xpv
2292843e1988Sjohnlev 	if (DOMAIN_IS_INITDOMAIN(xen_info))
2293843e1988Sjohnlev #endif
2294843e1988Sjohnlev 	{
2295843e1988Sjohnlev #if defined(__xpv)
2296843e1988Sjohnlev 		xpv_panic_init();
2297843e1988Sjohnlev #else
229884ab085aSmws 		/*
2299ae115bc7Smrj 		 * Startup the memory scrubber.
2300843e1988Sjohnlev 		 * XXPV	This should be running somewhere ..
23017c478bd9Sstevel@tonic-gate 		 */
2302*79ec9da8SYuri Pankov 		if ((get_hwenv() & HW_VIRTUAL) == 0)
230384ab085aSmws 			memscrub_init();
2304843e1988Sjohnlev #endif
2305843e1988Sjohnlev 	}
23067c478bd9Sstevel@tonic-gate 
23077c478bd9Sstevel@tonic-gate 	/*
23087aec1d6eScindi 	 * Complete CPU module initialization
23097aec1d6eScindi 	 */
231020c794b3Sgavinm 	cmi_post_startup();
23117aec1d6eScindi 
23127aec1d6eScindi 	/*
23137c478bd9Sstevel@tonic-gate 	 * Perform forceloading tasks for /etc/system.
23147c478bd9Sstevel@tonic-gate 	 */
23157c478bd9Sstevel@tonic-gate 	(void) mod_sysctl(SYS_FORCELOAD, NULL);
23167c478bd9Sstevel@tonic-gate 
23177c478bd9Sstevel@tonic-gate 	/*
23187c478bd9Sstevel@tonic-gate 	 * ON4.0: Force /proc module in until clock interrupt handle fixed
23197c478bd9Sstevel@tonic-gate 	 * ON4.0: This must be fixed or restated in /etc/systems.
23207c478bd9Sstevel@tonic-gate 	 */
23217c478bd9Sstevel@tonic-gate 	(void) modload("fs", "procfs");
23227c478bd9Sstevel@tonic-gate 
2323c35aa225Smarx 	(void) i_ddi_attach_hw_nodes("pit_beep");
2324c35aa225Smarx 
23257c478bd9Sstevel@tonic-gate #if defined(__i386)
23267c478bd9Sstevel@tonic-gate 	/*
23277c478bd9Sstevel@tonic-gate 	 * Check for required functional Floating Point hardware,
23287c478bd9Sstevel@tonic-gate 	 * unless FP hardware explicitly disabled.
23297c478bd9Sstevel@tonic-gate 	 */
23307c478bd9Sstevel@tonic-gate 	if (fpu_exists && (fpu_pentium_fdivbug || fp_kind == FP_NO))
23317c478bd9Sstevel@tonic-gate 		halt("No working FP hardware found");
23327c478bd9Sstevel@tonic-gate #endif
23337c478bd9Sstevel@tonic-gate 
23347c478bd9Sstevel@tonic-gate 	maxmem = freemem;
23357c478bd9Sstevel@tonic-gate 
2336fb2caebeSRandy Fishel 	cpu_event_init_cpu(CPU);
23370e751525SEric Saxe 	cpupm_init(CPU);
2338fa96bd91SMichael Corcoran 	(void) mach_cpu_create_device_node(CPU, NULL);
23390e751525SEric Saxe 
23400e751525SEric Saxe 	pg_init();
23417c478bd9Sstevel@tonic-gate }
23427c478bd9Sstevel@tonic-gate 
23437c478bd9Sstevel@tonic-gate static int
234419397407SSherry Moore pp_in_range(page_t *pp, uint64_t low_addr, uint64_t high_addr)
23457c478bd9Sstevel@tonic-gate {
234619397407SSherry Moore 	return ((pp->p_pagenum >= btop(low_addr)) &&
234719397407SSherry Moore 	    (pp->p_pagenum < btopr(high_addr)));
23487c478bd9Sstevel@tonic-gate }
23497c478bd9Sstevel@tonic-gate 
23507c478bd9Sstevel@tonic-gate void
23517c478bd9Sstevel@tonic-gate release_bootstrap(void)
23527c478bd9Sstevel@tonic-gate {
23537c478bd9Sstevel@tonic-gate 	int root_is_ramdisk;
23547c478bd9Sstevel@tonic-gate 	page_t *pp;
23557c478bd9Sstevel@tonic-gate 	extern void kobj_boot_unmountroot(void);
23567c478bd9Sstevel@tonic-gate 	extern dev_t rootdev;
235755d507a9SSeth Goldberg #if !defined(__xpv)
235855d507a9SSeth Goldberg 	pfn_t	pfn;
235955d507a9SSeth Goldberg #endif
23607c478bd9Sstevel@tonic-gate 
23617c478bd9Sstevel@tonic-gate 	/* unmount boot ramdisk and release kmem usage */
23627c478bd9Sstevel@tonic-gate 	kobj_boot_unmountroot();
23637c478bd9Sstevel@tonic-gate 
23647c478bd9Sstevel@tonic-gate 	/*
23657c478bd9Sstevel@tonic-gate 	 * We're finished using the boot loader so free its pages.
23667c478bd9Sstevel@tonic-gate 	 */
23677c478bd9Sstevel@tonic-gate 	PRM_POINT("Unmapping lower boot pages");
236819397407SSherry Moore 
2369ae115bc7Smrj 	clear_boot_mappings(0, _userlimit);
237019397407SSherry Moore 
2371ae115bc7Smrj 	postbootkernelbase = kernelbase;
23727c478bd9Sstevel@tonic-gate 
23737c478bd9Sstevel@tonic-gate 	/*
23747c478bd9Sstevel@tonic-gate 	 * If root isn't on ramdisk, destroy the hardcoded
23757c478bd9Sstevel@tonic-gate 	 * ramdisk node now and release the memory. Else,
23767c478bd9Sstevel@tonic-gate 	 * ramdisk memory is kept in rd_pages.
23777c478bd9Sstevel@tonic-gate 	 */
23787c478bd9Sstevel@tonic-gate 	root_is_ramdisk = (getmajor(rootdev) == ddi_name_to_major("ramdisk"));
23797c478bd9Sstevel@tonic-gate 	if (!root_is_ramdisk) {
23807c478bd9Sstevel@tonic-gate 		dev_info_t *dip = ddi_find_devinfo("ramdisk", -1, 0);
23817c478bd9Sstevel@tonic-gate 		ASSERT(dip && ddi_get_parent(dip) == ddi_root_node());
23827c478bd9Sstevel@tonic-gate 		ndi_rele_devi(dip);	/* held from ddi_find_devinfo */
23837c478bd9Sstevel@tonic-gate 		(void) ddi_remove_child(dip, 0);
23847c478bd9Sstevel@tonic-gate 	}
23857c478bd9Sstevel@tonic-gate 
23867c478bd9Sstevel@tonic-gate 	PRM_POINT("Releasing boot pages");
23877c478bd9Sstevel@tonic-gate 	while (bootpages) {
238819397407SSherry Moore 		extern uint64_t ramdisk_start, ramdisk_end;
23897c478bd9Sstevel@tonic-gate 		pp = bootpages;
23907c478bd9Sstevel@tonic-gate 		bootpages = pp->p_next;
239119397407SSherry Moore 
239219397407SSherry Moore 
239319397407SSherry Moore 		/* Keep pages for the lower 64K */
239419397407SSherry Moore 		if (pp_in_range(pp, 0, 0x40000)) {
239519397407SSherry Moore 			pp->p_next = lower_pages;
239619397407SSherry Moore 			lower_pages = pp;
239719397407SSherry Moore 			lower_pages_count++;
239819397407SSherry Moore 			continue;
239919397407SSherry Moore 		}
240019397407SSherry Moore 
240119397407SSherry Moore 
240219397407SSherry Moore 		if (root_is_ramdisk && pp_in_range(pp, ramdisk_start,
240319397407SSherry Moore 		    ramdisk_end)) {
24047c478bd9Sstevel@tonic-gate 			pp->p_next = rd_pages;
24057c478bd9Sstevel@tonic-gate 			rd_pages = pp;
24067c478bd9Sstevel@tonic-gate 			continue;
24077c478bd9Sstevel@tonic-gate 		}
24087c478bd9Sstevel@tonic-gate 		pp->p_next = (struct page *)0;
2409ae115bc7Smrj 		pp->p_prev = (struct page *)0;
2410ae115bc7Smrj 		PP_CLRBOOTPAGES(pp);
24117c478bd9Sstevel@tonic-gate 		page_free(pp, 1);
24127c478bd9Sstevel@tonic-gate 	}
2413ae115bc7Smrj 	PRM_POINT("Boot pages released");
24147c478bd9Sstevel@tonic-gate 
2415843e1988Sjohnlev #if !defined(__xpv)
2416843e1988Sjohnlev /* XXPV -- note this following bunch of code needs to be revisited in Xen 3.0 */
24177c478bd9Sstevel@tonic-gate 	/*
241855d507a9SSeth Goldberg 	 * Find 1 page below 1 MB so that other processors can boot up or
241955d507a9SSeth Goldberg 	 * so that any processor can resume.
24207c478bd9Sstevel@tonic-gate 	 * Make sure it has a kernel VA as well as a 1:1 mapping.
24217c478bd9Sstevel@tonic-gate 	 * We should have just free'd one up.
24227c478bd9Sstevel@tonic-gate 	 */
242319397407SSherry Moore 
242419397407SSherry Moore 	/*
242519397407SSherry Moore 	 * 0x10 pages is 64K.  Leave the bottom 64K alone
242619397407SSherry Moore 	 * for BIOS.
242719397407SSherry Moore 	 */
242819397407SSherry Moore 	for (pfn = 0x10; pfn < btop(1*1024*1024); pfn++) {
24297c478bd9Sstevel@tonic-gate 		if (page_numtopp_alloc(pfn) == NULL)
24307c478bd9Sstevel@tonic-gate 			continue;
24317c478bd9Sstevel@tonic-gate 		rm_platter_va = i86devmap(pfn, 1,
24327c478bd9Sstevel@tonic-gate 		    PROT_READ | PROT_WRITE | PROT_EXEC);
24337c478bd9Sstevel@tonic-gate 		rm_platter_pa = ptob(pfn);
24347c478bd9Sstevel@tonic-gate 		break;
24357c478bd9Sstevel@tonic-gate 	}
243655d507a9SSeth Goldberg 	if (pfn == btop(1*1024*1024) && use_mp)
243755d507a9SSeth Goldberg 		panic("No page below 1M available for starting "
243855d507a9SSeth Goldberg 		    "other processors or for resuming from system-suspend");
2439843e1988Sjohnlev #endif	/* !__xpv */
24407c478bd9Sstevel@tonic-gate }
24417c478bd9Sstevel@tonic-gate 
24427c478bd9Sstevel@tonic-gate /*
24437c478bd9Sstevel@tonic-gate  * Initialize the platform-specific parts of a page_t.
24447c478bd9Sstevel@tonic-gate  */
24457c478bd9Sstevel@tonic-gate void
24467c478bd9Sstevel@tonic-gate add_physmem_cb(page_t *pp, pfn_t pnum)
24477c478bd9Sstevel@tonic-gate {
24487c478bd9Sstevel@tonic-gate 	pp->p_pagenum = pnum;
24497c478bd9Sstevel@tonic-gate 	pp->p_mapping = NULL;
24507c478bd9Sstevel@tonic-gate 	pp->p_embed = 0;
24517c478bd9Sstevel@tonic-gate 	pp->p_share = 0;
24527c478bd9Sstevel@tonic-gate 	pp->p_mlentry = 0;
24537c478bd9Sstevel@tonic-gate }
24547c478bd9Sstevel@tonic-gate 
24557c478bd9Sstevel@tonic-gate /*
24567c478bd9Sstevel@tonic-gate  * kphysm_init() initializes physical memory.
24577c478bd9Sstevel@tonic-gate  */
24587c478bd9Sstevel@tonic-gate static pgcnt_t
24597c478bd9Sstevel@tonic-gate kphysm_init(
2460ae115bc7Smrj 	page_t *pp,
24617c478bd9Sstevel@tonic-gate 	pgcnt_t npages)
24627c478bd9Sstevel@tonic-gate {
24637c478bd9Sstevel@tonic-gate 	struct memlist	*pmem;
24647c478bd9Sstevel@tonic-gate 	struct memseg	*cur_memseg;
24657c478bd9Sstevel@tonic-gate 	pfn_t		base_pfn;
246618968004SKit Chow 	pfn_t		end_pfn;
24677c478bd9Sstevel@tonic-gate 	pgcnt_t		num;
24687c478bd9Sstevel@tonic-gate 	pgcnt_t		pages_done = 0;
24697c478bd9Sstevel@tonic-gate 	uint64_t	addr;
24707c478bd9Sstevel@tonic-gate 	uint64_t	size;
24717c478bd9Sstevel@tonic-gate 	extern pfn_t	ddiphysmin;
247218968004SKit Chow 	extern int	mnode_xwa;
247318968004SKit Chow 	int		ms = 0, me = 0;
24747c478bd9Sstevel@tonic-gate 
24757c478bd9Sstevel@tonic-gate 	ASSERT(page_hash != NULL && page_hashsz != 0);
24767c478bd9Sstevel@tonic-gate 
2477ae115bc7Smrj 	cur_memseg = memseg_base;
247856f33205SJonathan Adams 	for (pmem = phys_avail; pmem && npages; pmem = pmem->ml_next) {
24797c478bd9Sstevel@tonic-gate 		/*
24807c478bd9Sstevel@tonic-gate 		 * In a 32 bit kernel can't use higher memory if we're
24817c478bd9Sstevel@tonic-gate 		 * not booting in PAE mode. This check takes care of that.
24827c478bd9Sstevel@tonic-gate 		 */
248356f33205SJonathan Adams 		addr = pmem->ml_address;
248456f33205SJonathan Adams 		size = pmem->ml_size;
24857c478bd9Sstevel@tonic-gate 		if (btop(addr) > physmax)
24867c478bd9Sstevel@tonic-gate 			continue;
24877c478bd9Sstevel@tonic-gate 
24887c478bd9Sstevel@tonic-gate 		/*
24897c478bd9Sstevel@tonic-gate 		 * align addr and size - they may not be at page boundaries
24907c478bd9Sstevel@tonic-gate 		 */
24917c478bd9Sstevel@tonic-gate 		if ((addr & MMU_PAGEOFFSET) != 0) {
24927c478bd9Sstevel@tonic-gate 			addr += MMU_PAGEOFFSET;
24937c478bd9Sstevel@tonic-gate 			addr &= ~(uint64_t)MMU_PAGEOFFSET;
249456f33205SJonathan Adams 			size -= addr - pmem->ml_address;
24957c478bd9Sstevel@tonic-gate 		}
24967c478bd9Sstevel@tonic-gate 
24976bb54764Skchow 		/* only process pages below or equal to physmax */
24986bb54764Skchow 		if ((btop(addr + size) - 1) > physmax)
24996bb54764Skchow 			size = ptob(physmax - btop(addr) + 1);
25007c478bd9Sstevel@tonic-gate 
25017c478bd9Sstevel@tonic-gate 		num = btop(size);
25027c478bd9Sstevel@tonic-gate 		if (num == 0)
25037c478bd9Sstevel@tonic-gate 			continue;
25047c478bd9Sstevel@tonic-gate 
25057c478bd9Sstevel@tonic-gate 		if (num > npages)
25067c478bd9Sstevel@tonic-gate 			num = npages;
25077c478bd9Sstevel@tonic-gate 
25087c478bd9Sstevel@tonic-gate 		npages -= num;
25097c478bd9Sstevel@tonic-gate 		pages_done += num;
25107c478bd9Sstevel@tonic-gate 		base_pfn = btop(addr);
25117c478bd9Sstevel@tonic-gate 
25127c478bd9Sstevel@tonic-gate 		if (prom_debug)
25137c478bd9Sstevel@tonic-gate 			prom_printf("MEMSEG addr=0x%" PRIx64
25147c478bd9Sstevel@tonic-gate 			    " pgs=0x%lx pfn 0x%lx-0x%lx\n",
25157c478bd9Sstevel@tonic-gate 			    addr, num, base_pfn, base_pfn + num);
25167c478bd9Sstevel@tonic-gate 
25177c478bd9Sstevel@tonic-gate 		/*
2518ae115bc7Smrj 		 * Ignore pages below ddiphysmin to simplify ddi memory
25197c478bd9Sstevel@tonic-gate 		 * allocation with non-zero addr_lo requests.
25207c478bd9Sstevel@tonic-gate 		 */
25217c478bd9Sstevel@tonic-gate 		if (base_pfn < ddiphysmin) {
2522ae115bc7Smrj 			if (base_pfn + num <= ddiphysmin)
25237c478bd9Sstevel@tonic-gate 				continue;
25247c478bd9Sstevel@tonic-gate 			pp += (ddiphysmin - base_pfn);
25257c478bd9Sstevel@tonic-gate 			num -= (ddiphysmin - base_pfn);
25267c478bd9Sstevel@tonic-gate 			base_pfn = ddiphysmin;
25277c478bd9Sstevel@tonic-gate 		}
2528ae115bc7Smrj 
25297c478bd9Sstevel@tonic-gate 		/*
253018968004SKit Chow 		 * mnode_xwa is greater than 1 when large pages regions can
253118968004SKit Chow 		 * cross memory node boundaries. To prevent the formation
253218968004SKit Chow 		 * of these large pages, configure the memsegs based on the
253318968004SKit Chow 		 * memory node ranges which had been made non-contiguous.
253418968004SKit Chow 		 */
253518968004SKit Chow 		if (mnode_xwa > 1) {
253618968004SKit Chow 
253718968004SKit Chow 			end_pfn = base_pfn + num - 1;
253818968004SKit Chow 			ms = PFN_2_MEM_NODE(base_pfn);
253918968004SKit Chow 			me = PFN_2_MEM_NODE(end_pfn);
254018968004SKit Chow 
254118968004SKit Chow 			if (ms != me) {
254218968004SKit Chow 				/*
254318968004SKit Chow 				 * current range spans more than 1 memory node.
254418968004SKit Chow 				 * Set num to only the pfn range in the start
254518968004SKit Chow 				 * memory node.
254618968004SKit Chow 				 */
254718968004SKit Chow 				num = mem_node_config[ms].physmax - base_pfn
254818968004SKit Chow 				    + 1;
254918968004SKit Chow 				ASSERT(end_pfn > mem_node_config[ms].physmax);
255018968004SKit Chow 			}
255118968004SKit Chow 		}
255218968004SKit Chow 
255318968004SKit Chow 		for (;;) {
255418968004SKit Chow 			/*
25557c478bd9Sstevel@tonic-gate 			 * Build the memsegs entry
25567c478bd9Sstevel@tonic-gate 			 */
25577c478bd9Sstevel@tonic-gate 			cur_memseg->pages = pp;
25587c478bd9Sstevel@tonic-gate 			cur_memseg->epages = pp + num;
25597c478bd9Sstevel@tonic-gate 			cur_memseg->pages_base = base_pfn;
25607c478bd9Sstevel@tonic-gate 			cur_memseg->pages_end = base_pfn + num;
25617c478bd9Sstevel@tonic-gate 
25627c478bd9Sstevel@tonic-gate 			/*
256318968004SKit Chow 			 * Insert into memseg list in decreasing pfn range
256418968004SKit Chow 			 * order. Low memory is typically more fragmented such
256518968004SKit Chow 			 * that this ordering keeps the larger ranges at the
256618968004SKit Chow 			 * front of the list for code that searches memseg.
256718968004SKit Chow 			 * This ASSERTS that the memsegs coming in from boot
256818968004SKit Chow 			 * are in increasing physical address order and not
256918968004SKit Chow 			 * contiguous.
25707c478bd9Sstevel@tonic-gate 			 */
2571ae115bc7Smrj 			if (memsegs != NULL) {
257218968004SKit Chow 				ASSERT(cur_memseg->pages_base >=
257318968004SKit Chow 				    memsegs->pages_end);
2574ae115bc7Smrj 				cur_memseg->next = memsegs;
2575ae115bc7Smrj 			}
25767c478bd9Sstevel@tonic-gate 			memsegs = cur_memseg;
25777c478bd9Sstevel@tonic-gate 
25787c478bd9Sstevel@tonic-gate 			/*
25797c478bd9Sstevel@tonic-gate 			 * add_physmem() initializes the PSM part of the page
25807c478bd9Sstevel@tonic-gate 			 * struct by calling the PSM back with add_physmem_cb().
25817c478bd9Sstevel@tonic-gate 			 * In addition it coalesces pages into larger pages as
25827c478bd9Sstevel@tonic-gate 			 * it initializes them.
25837c478bd9Sstevel@tonic-gate 			 */
25847c478bd9Sstevel@tonic-gate 			add_physmem(pp, num, base_pfn);
25857c478bd9Sstevel@tonic-gate 			cur_memseg++;
25867c478bd9Sstevel@tonic-gate 			availrmem_initial += num;
25877c478bd9Sstevel@tonic-gate 			availrmem += num;
25887c478bd9Sstevel@tonic-gate 
2589ae115bc7Smrj 			pp += num;
259018968004SKit Chow 			if (ms >= me)
259118968004SKit Chow 				break;
259218968004SKit Chow 
259318968004SKit Chow 			/* process next memory node range */
259418968004SKit Chow 			ms++;
259518968004SKit Chow 			base_pfn = mem_node_config[ms].physbase;
259618968004SKit Chow 			num = MIN(mem_node_config[ms].physmax,
259718968004SKit Chow 			    end_pfn) - base_pfn + 1;
259818968004SKit Chow 		}
25997c478bd9Sstevel@tonic-gate 	}
26007c478bd9Sstevel@tonic-gate 
26017c478bd9Sstevel@tonic-gate 	PRM_DEBUG(availrmem_initial);
26027c478bd9Sstevel@tonic-gate 	PRM_DEBUG(availrmem);
26037c478bd9Sstevel@tonic-gate 	PRM_DEBUG(freemem);
26047c478bd9Sstevel@tonic-gate 	build_pfn_hash();
26057c478bd9Sstevel@tonic-gate 	return (pages_done);
26067c478bd9Sstevel@tonic-gate }
26077c478bd9Sstevel@tonic-gate 
26087c478bd9Sstevel@tonic-gate /*
26097c478bd9Sstevel@tonic-gate  * Kernel VM initialization.
26107c478bd9Sstevel@tonic-gate  */
26117c478bd9Sstevel@tonic-gate static void
26127c478bd9Sstevel@tonic-gate kvm_init(void)
26137c478bd9Sstevel@tonic-gate {
26147c478bd9Sstevel@tonic-gate 	ASSERT((((uintptr_t)s_text) & MMU_PAGEOFFSET) == 0);
26157c478bd9Sstevel@tonic-gate 
26167c478bd9Sstevel@tonic-gate 	/*
26177c478bd9Sstevel@tonic-gate 	 * Put the kernel segments in kernel address space.
26187c478bd9Sstevel@tonic-gate 	 */
26197c478bd9Sstevel@tonic-gate 	rw_enter(&kas.a_lock, RW_WRITER);
26207c478bd9Sstevel@tonic-gate 	as_avlinit(&kas);
26217c478bd9Sstevel@tonic-gate 
26227c478bd9Sstevel@tonic-gate 	(void) seg_attach(&kas, s_text, e_moddata - s_text, &ktextseg);
26237c478bd9Sstevel@tonic-gate 	(void) segkmem_create(&ktextseg);
26247c478bd9Sstevel@tonic-gate 
26257c478bd9Sstevel@tonic-gate 	(void) seg_attach(&kas, (caddr_t)valloc_base, valloc_sz, &kvalloc);
26267c478bd9Sstevel@tonic-gate 	(void) segkmem_create(&kvalloc);
26277c478bd9Sstevel@tonic-gate 
262835b1ab99Sjosephb 	(void) seg_attach(&kas, kernelheap,
262935b1ab99Sjosephb 	    ekernelheap - kernelheap, &kvseg);
26307c478bd9Sstevel@tonic-gate 	(void) segkmem_create(&kvseg);
26317c478bd9Sstevel@tonic-gate 
2632ae115bc7Smrj 	if (core_size > 0) {
2633ae115bc7Smrj 		PRM_POINT("attaching kvseg_core");
2634ae115bc7Smrj 		(void) seg_attach(&kas, (caddr_t)core_base, core_size,
2635ae115bc7Smrj 		    &kvseg_core);
26367c478bd9Sstevel@tonic-gate 		(void) segkmem_create(&kvseg_core);
2637ae115bc7Smrj 	}
2638ad23a2dbSjohansen 
2639ae115bc7Smrj 	if (segziosize > 0) {
2640ae115bc7Smrj 		PRM_POINT("attaching segzio");
2641ad23a2dbSjohansen 		(void) seg_attach(&kas, segzio_base, mmu_ptob(segziosize),
2642ad23a2dbSjohansen 		    &kzioseg);
2643ad23a2dbSjohansen 		(void) segkmem_zio_create(&kzioseg);
2644ad23a2dbSjohansen 
2645ad23a2dbSjohansen 		/* create zio area covering new segment */
2646ad23a2dbSjohansen 		segkmem_zio_init(segzio_base, mmu_ptob(segziosize));
2647ad23a2dbSjohansen 	}
26487c478bd9Sstevel@tonic-gate 
2649ae115bc7Smrj 	(void) seg_attach(&kas, kdi_segdebugbase, kdi_segdebugsize, &kdebugseg);
26507c478bd9Sstevel@tonic-gate 	(void) segkmem_create(&kdebugseg);
26517c478bd9Sstevel@tonic-gate 
26527c478bd9Sstevel@tonic-gate 	rw_exit(&kas.a_lock);
26537c478bd9Sstevel@tonic-gate 
26547c478bd9Sstevel@tonic-gate 	/*
26557c478bd9Sstevel@tonic-gate 	 * Ensure that the red zone at kernelbase is never accessible.
26567c478bd9Sstevel@tonic-gate 	 */
2657ae115bc7Smrj 	PRM_POINT("protecting redzone");
26587c478bd9Sstevel@tonic-gate 	(void) as_setprot(&kas, (caddr_t)kernelbase, KERNEL_REDZONE_SIZE, 0);
26597c478bd9Sstevel@tonic-gate 
26607c478bd9Sstevel@tonic-gate 	/*
26617c478bd9Sstevel@tonic-gate 	 * Make the text writable so that it can be hot patched by DTrace.
26627c478bd9Sstevel@tonic-gate 	 */
26637c478bd9Sstevel@tonic-gate 	(void) as_setprot(&kas, s_text, e_modtext - s_text,
26647c478bd9Sstevel@tonic-gate 	    PROT_READ | PROT_WRITE | PROT_EXEC);
26657c478bd9Sstevel@tonic-gate 
26667c478bd9Sstevel@tonic-gate 	/*
26677c478bd9Sstevel@tonic-gate 	 * Make data writable until end.
26687c478bd9Sstevel@tonic-gate 	 */
26697c478bd9Sstevel@tonic-gate 	(void) as_setprot(&kas, s_data, e_moddata - s_data,
26707c478bd9Sstevel@tonic-gate 	    PROT_READ | PROT_WRITE | PROT_EXEC);
26717c478bd9Sstevel@tonic-gate }
26727c478bd9Sstevel@tonic-gate 
2673843e1988Sjohnlev #ifndef __xpv
26747c478bd9Sstevel@tonic-gate /*
26751d03c31eSjohnlev  * Solaris adds an entry for Write Combining caching to the PAT
26767c478bd9Sstevel@tonic-gate  */
26771d03c31eSjohnlev static uint64_t pat_attr_reg = PAT_DEFAULT_ATTRIBUTE;
26787c478bd9Sstevel@tonic-gate 
26797c478bd9Sstevel@tonic-gate void
26801d03c31eSjohnlev pat_sync(void)
26817c478bd9Sstevel@tonic-gate {
26821d03c31eSjohnlev 	ulong_t	cr0, cr0_orig, cr4;
26837c478bd9Sstevel@tonic-gate 
26847417cfdeSKuriakose Kuruvilla 	if (!is_x86_feature(x86_featureset, X86FSET_PAT))
26857c478bd9Sstevel@tonic-gate 		return;
26861d03c31eSjohnlev 	cr0_orig = cr0 = getcr0();
26871d03c31eSjohnlev 	cr4 = getcr4();
26887c478bd9Sstevel@tonic-gate 
26891d03c31eSjohnlev 	/* disable caching and flush all caches and TLBs */
26901d03c31eSjohnlev 	cr0 |= CR0_CD;
26911d03c31eSjohnlev 	cr0 &= ~CR0_NW;
26921d03c31eSjohnlev 	setcr0(cr0);
26937c478bd9Sstevel@tonic-gate 	invalidate_cache();
26941d03c31eSjohnlev 	if (cr4 & CR4_PGE) {
26951d03c31eSjohnlev 		setcr4(cr4 & ~(ulong_t)CR4_PGE);
26961d03c31eSjohnlev 		setcr4(cr4);
26971d03c31eSjohnlev 	} else {
2698ae115bc7Smrj 		reload_cr3();
26997c478bd9Sstevel@tonic-gate 	}
2700ae115bc7Smrj 
27011d03c31eSjohnlev 	/* add our entry to the PAT */
27021d03c31eSjohnlev 	wrmsr(REG_PAT, pat_attr_reg);
27031d03c31eSjohnlev 
27041d03c31eSjohnlev 	/* flush TLBs and cache again, then reenable cr0 caching */
27051d03c31eSjohnlev 	if (cr4 & CR4_PGE) {
27061d03c31eSjohnlev 		setcr4(cr4 & ~(ulong_t)CR4_PGE);
27071d03c31eSjohnlev 		setcr4(cr4);
27081d03c31eSjohnlev 	} else {
2709ae115bc7Smrj 		reload_cr3();
27101d03c31eSjohnlev 	}
27117c478bd9Sstevel@tonic-gate 	invalidate_cache();
27127c478bd9Sstevel@tonic-gate 	setcr0(cr0_orig);
27137c478bd9Sstevel@tonic-gate }
27147c478bd9Sstevel@tonic-gate 
27151d03c31eSjohnlev #endif /* !__xpv */
27167c478bd9Sstevel@tonic-gate 
2717ed5289f9SKen Erickson #if defined(_SOFT_HOSTID)
2718ed5289f9SKen Erickson /*
2719ed5289f9SKen Erickson  * On platforms that do not have a hardware serial number, attempt
2720ed5289f9SKen Erickson  * to set one based on the contents of /etc/hostid.  If this file does
2721ed5289f9SKen Erickson  * not exist, assume that we are to generate a new hostid and set
2722ed5289f9SKen Erickson  * it in the kernel, for subsequent saving by a userland process
2723ed5289f9SKen Erickson  * once the system is up and the root filesystem is mounted r/w.
2724ed5289f9SKen Erickson  *
272596d008c2SKen Erickson  * In order to gracefully support upgrade on OpenSolaris, if
272696d008c2SKen Erickson  * /etc/hostid does not exist, we will attempt to get a serial number
272796d008c2SKen Erickson  * using the legacy method (/kernel/misc/sysinit).
272896d008c2SKen Erickson  *
27299e3e4df2SGarrett D'Amore  * If that isn't present, we attempt to use an SMBIOS UUID, which is
27309e3e4df2SGarrett D'Amore  * a hardware serial number.  Note that we don't automatically trust
27319e3e4df2SGarrett D'Amore  * all SMBIOS UUIDs (some older platforms are defective and ship duplicate
27329e3e4df2SGarrett D'Amore  * UUIDs in violation of the standard), we check against a blacklist.
27339e3e4df2SGarrett D'Amore  *
2734ed5289f9SKen Erickson  * In an attempt to make the hostid less prone to abuse
2735ed5289f9SKen Erickson  * (for license circumvention, etc), we store it in /etc/hostid
2736ed5289f9SKen Erickson  * in rot47 format.
2737ed5289f9SKen Erickson  */
2738ed5289f9SKen Erickson extern volatile unsigned long tenmicrodata;
273996d008c2SKen Erickson static int atoi(char *);
2740ed5289f9SKen Erickson 
27419e3e4df2SGarrett D'Amore /*
27429e3e4df2SGarrett D'Amore  * Set this to non-zero in /etc/system if you think your SMBIOS returns a
27439e3e4df2SGarrett D'Amore  * UUID that is not unique. (Also report it so that the smbios_uuid_blacklist
27449e3e4df2SGarrett D'Amore  * array can be updated.)
27459e3e4df2SGarrett D'Amore  */
27469e3e4df2SGarrett D'Amore int smbios_broken_uuid = 0;
27479e3e4df2SGarrett D'Amore 
27489e3e4df2SGarrett D'Amore /*
27499e3e4df2SGarrett D'Amore  * List of known bad UUIDs.  This is just the lower 32-bit values, since
27509e3e4df2SGarrett D'Amore  * that's what we use for the host id.  If your hostid falls here, you need
27519e3e4df2SGarrett D'Amore  * to contact your hardware OEM for a fix for your BIOS.
27529e3e4df2SGarrett D'Amore  */
27539e3e4df2SGarrett D'Amore static unsigned char
27549e3e4df2SGarrett D'Amore smbios_uuid_blacklist[][16] = {
27559e3e4df2SGarrett D'Amore 
27569e3e4df2SGarrett D'Amore 	{	/* Reported bad UUID (Google search) */
27579e3e4df2SGarrett D'Amore 		0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05,
27589e3e4df2SGarrett D'Amore 		0x00, 0x06, 0x00, 0x07, 0x00, 0x08, 0x00, 0x09,
27599e3e4df2SGarrett D'Amore 	},
27609e3e4df2SGarrett D'Amore 	{	/* Known bad DELL UUID */
27619e3e4df2SGarrett D'Amore 		0x4C, 0x4C, 0x45, 0x44, 0x00, 0x00, 0x20, 0x10,
27629e3e4df2SGarrett D'Amore 		0x80, 0x20, 0x80, 0xC0, 0x4F, 0x20, 0x20, 0x20,
27639e3e4df2SGarrett D'Amore 	},
27649e3e4df2SGarrett D'Amore 	{	/* Uninitialized flash */
27659e3e4df2SGarrett D'Amore 		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
27669e3e4df2SGarrett D'Amore 		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
27679e3e4df2SGarrett D'Amore 	},
27689e3e4df2SGarrett D'Amore 	{	/* All zeros */
27699e3e4df2SGarrett D'Amore 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
27709e3e4df2SGarrett D'Amore 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
27719e3e4df2SGarrett D'Amore 	},
27729e3e4df2SGarrett D'Amore };
27739e3e4df2SGarrett D'Amore 
27749e3e4df2SGarrett D'Amore static int32_t
27759e3e4df2SGarrett D'Amore uuid_to_hostid(const uint8_t *uuid)
27769e3e4df2SGarrett D'Amore {
27779e3e4df2SGarrett D'Amore 	/*
27789e3e4df2SGarrett D'Amore 	 * Although the UUIDs are 128-bits, they may not distribute entropy
27799e3e4df2SGarrett D'Amore 	 * evenly.  We would like to use SHA or MD5, but those are located
27809e3e4df2SGarrett D'Amore 	 * in loadable modules and not available this early in boot.  As we
27819e3e4df2SGarrett D'Amore 	 * don't need the values to be cryptographically strong, we just
27829e3e4df2SGarrett D'Amore 	 * generate 32-bit vaue by xor'ing the various sequences together,
27839e3e4df2SGarrett D'Amore 	 * which ensures that the enire UUID contributes to the hostid.
27849e3e4df2SGarrett D'Amore 	 */
27859e3e4df2SGarrett D'Amore 	int32_t	id = 0;
27869e3e4df2SGarrett D'Amore 
27879e3e4df2SGarrett D'Amore 	/* first check against the blacklist */
27889e3e4df2SGarrett D'Amore 	for (int i = 0; i < (sizeof (smbios_uuid_blacklist) / 16); i++) {
27899e3e4df2SGarrett D'Amore 		if (bcmp(smbios_uuid_blacklist[0], uuid, 16) == 0) {
27909e3e4df2SGarrett D'Amore 			cmn_err(CE_CONT, "?Broken SMBIOS UUID. "
27919e3e4df2SGarrett D'Amore 			    "Contact BIOS manufacturer for repair.\n");
27929e3e4df2SGarrett D'Amore 			return ((int32_t)HW_INVALID_HOSTID);
27939e3e4df2SGarrett D'Amore 		}
27949e3e4df2SGarrett D'Amore 	}
27959e3e4df2SGarrett D'Amore 
27969e3e4df2SGarrett D'Amore 	for (int i = 0; i < 16; i++)
27979e3e4df2SGarrett D'Amore 		id ^= ((uuid[i]) << (8 * (i % sizeof (id))));
27989e3e4df2SGarrett D'Amore 
27999e3e4df2SGarrett D'Amore 	return (id);
28009e3e4df2SGarrett D'Amore }
28019e3e4df2SGarrett D'Amore 
2802ed5289f9SKen Erickson static int32_t
2803ed5289f9SKen Erickson set_soft_hostid(void)
2804ed5289f9SKen Erickson {
2805ed5289f9SKen Erickson 	struct _buf *file;
2806ed5289f9SKen Erickson 	char tokbuf[MAXNAMELEN];
2807ed5289f9SKen Erickson 	token_t token;
2808ed5289f9SKen Erickson 	int done = 0;
2809ed5289f9SKen Erickson 	u_longlong_t tmp;
281096d008c2SKen Erickson 	int i;
28115679c89fSjv227347 	int32_t hostid = (int32_t)HW_INVALID_HOSTID;
2812ed5289f9SKen Erickson 	unsigned char *c;
2813ed5289f9SKen Erickson 	hrtime_t tsc;
28149e3e4df2SGarrett D'Amore 	smbios_system_t smsys;
2815ed5289f9SKen Erickson 
2816ed5289f9SKen Erickson 	/*
2817ed5289f9SKen Erickson 	 * If /etc/hostid file not found, we'd like to get a pseudo
2818ed5289f9SKen Erickson 	 * random number to use at the hostid.  A nice way to do this
2819ed5289f9SKen Erickson 	 * is to read the real time clock.  To remain xen-compatible,
2820ed5289f9SKen Erickson 	 * we can't poke the real hardware, so we use tsc_read() to
2821ed5289f9SKen Erickson 	 * read the real time clock.  However, there is an ominous
2822ed5289f9SKen Erickson 	 * warning in tsc_read that says it can return zero, so we
2823ed5289f9SKen Erickson 	 * deal with that possibility by falling back to using the
2824ed5289f9SKen Erickson 	 * (hopefully random enough) value in tenmicrodata.
2825ed5289f9SKen Erickson 	 */
2826ed5289f9SKen Erickson 
2827ed5289f9SKen Erickson 	if ((file = kobj_open_file(hostid_file)) == (struct _buf *)-1) {
282896d008c2SKen Erickson 		/*
282996d008c2SKen Erickson 		 * hostid file not found - try to load sysinit module
283096d008c2SKen Erickson 		 * and see if it has a nonzero hostid value...use that
283196d008c2SKen Erickson 		 * instead of generating a new hostid here if so.
283296d008c2SKen Erickson 		 */
283396d008c2SKen Erickson 		if ((i = modload("misc", "sysinit")) != -1) {
283496d008c2SKen Erickson 			if (strlen(hw_serial) > 0)
283596d008c2SKen Erickson 				hostid = (int32_t)atoi(hw_serial);
283696d008c2SKen Erickson 			(void) modunload(i);
283796d008c2SKen Erickson 		}
28389e3e4df2SGarrett D'Amore 
28399e3e4df2SGarrett D'Amore 		/*
28409e3e4df2SGarrett D'Amore 		 * We try to use the SMBIOS UUID. But not if it is blacklisted
28419e3e4df2SGarrett D'Amore 		 * in /etc/system.
28429e3e4df2SGarrett D'Amore 		 */
28439e3e4df2SGarrett D'Amore 		if ((hostid == HW_INVALID_HOSTID) &&
28449e3e4df2SGarrett D'Amore 		    (smbios_broken_uuid == 0) &&
28459e3e4df2SGarrett D'Amore 		    (ksmbios != NULL) &&
28469e3e4df2SGarrett D'Amore 		    (smbios_info_system(ksmbios, &smsys) != SMB_ERR) &&
28479e3e4df2SGarrett D'Amore 		    (smsys.smbs_uuidlen >= 16)) {
28489e3e4df2SGarrett D'Amore 			hostid = uuid_to_hostid(smsys.smbs_uuid);
28499e3e4df2SGarrett D'Amore 		}
28509e3e4df2SGarrett D'Amore 
28519e3e4df2SGarrett D'Amore 		/*
28529e3e4df2SGarrett D'Amore 		 * Generate a "random" hostid using the clock.  These
28539e3e4df2SGarrett D'Amore 		 * hostids will change on each boot if the value is not
28549e3e4df2SGarrett D'Amore 		 * saved to a persistent /etc/hostid file.
28559e3e4df2SGarrett D'Amore 		 */
28565679c89fSjv227347 		if (hostid == HW_INVALID_HOSTID) {
2857ed5289f9SKen Erickson 			tsc = tsc_read();
2858ed5289f9SKen Erickson 			if (tsc == 0)	/* tsc_read can return zero sometimes */
2859ed5289f9SKen Erickson 				hostid = (int32_t)tenmicrodata & 0x0CFFFFF;
2860ed5289f9SKen Erickson 			else
2861ed5289f9SKen Erickson 				hostid = (int32_t)tsc & 0x0CFFFFF;
286296d008c2SKen Erickson 		}
2863ed5289f9SKen Erickson 	} else {
2864ed5289f9SKen Erickson 		/* hostid file found */
2865ed5289f9SKen Erickson 		while (!done) {
2866ed5289f9SKen Erickson 			token = kobj_lex(file, tokbuf, sizeof (tokbuf));
2867ed5289f9SKen Erickson 
2868ed5289f9SKen Erickson 			switch (token) {
2869ed5289f9SKen Erickson 			case POUND:
2870ed5289f9SKen Erickson 				/*
2871ed5289f9SKen Erickson 				 * skip comments
2872ed5289f9SKen Erickson 				 */
2873ed5289f9SKen Erickson 				kobj_find_eol(file);
2874ed5289f9SKen Erickson 				break;
2875ed5289f9SKen Erickson 			case STRING:
2876ed5289f9SKen Erickson 				/*
2877ed5289f9SKen Erickson 				 * un-rot47 - obviously this
2878ed5289f9SKen Erickson 				 * nonsense is ascii-specific
2879ed5289f9SKen Erickson 				 */
2880ed5289f9SKen Erickson 				for (c = (unsigned char *)tokbuf;
2881ed5289f9SKen Erickson 				    *c != '\0'; c++) {
2882ed5289f9SKen Erickson 					*c += 47;
2883ed5289f9SKen Erickson 					if (*c > '~')
2884ed5289f9SKen Erickson 						*c -= 94;
2885ed5289f9SKen Erickson 					else if (*c < '!')
2886ed5289f9SKen Erickson 						*c += 94;
2887ed5289f9SKen Erickson 				}
2888ed5289f9SKen Erickson 				/*
2889ed5289f9SKen Erickson 				 * now we should have a real number
2890ed5289f9SKen Erickson 				 */
2891ed5289f9SKen Erickson 
2892ed5289f9SKen Erickson 				if (kobj_getvalue(tokbuf, &tmp) != 0)
2893ed5289f9SKen Erickson 					kobj_file_err(CE_WARN, file,
2894ed5289f9SKen Erickson 					    "Bad value %s for hostid",
2895ed5289f9SKen Erickson 					    tokbuf);
2896ed5289f9SKen Erickson 				else
2897ed5289f9SKen Erickson 					hostid = (int32_t)tmp;
2898ed5289f9SKen Erickson 
2899ed5289f9SKen Erickson 				break;
2900ed5289f9SKen Erickson 			case EOF:
2901ed5289f9SKen Erickson 				done = 1;
2902ed5289f9SKen Erickson 				/* FALLTHROUGH */
2903ed5289f9SKen Erickson 			case NEWLINE:
2904ed5289f9SKen Erickson 				kobj_newline(file);
2905ed5289f9SKen Erickson 				break;
2906ed5289f9SKen Erickson 			default:
2907ed5289f9SKen Erickson 				break;
2908ed5289f9SKen Erickson 
2909ed5289f9SKen Erickson 			}
2910ed5289f9SKen Erickson 		}
29115679c89fSjv227347 		if (hostid == HW_INVALID_HOSTID) /* didn't find a hostid */
2912ed5289f9SKen Erickson 			kobj_file_err(CE_WARN, file,
2913ed5289f9SKen Erickson 			    "hostid missing or corrupt");
2914ed5289f9SKen Erickson 
2915ed5289f9SKen Erickson 		kobj_close_file(file);
2916ed5289f9SKen Erickson 	}
2917ed5289f9SKen Erickson 	/*
2918ed5289f9SKen Erickson 	 * hostid is now the value read from /etc/hostid, or the
29195679c89fSjv227347 	 * new hostid we generated in this routine or HW_INVALID_HOSTID if not
29205679c89fSjv227347 	 * set.
2921ed5289f9SKen Erickson 	 */
2922ed5289f9SKen Erickson 	return (hostid);
2923ed5289f9SKen Erickson }
292496d008c2SKen Erickson 
292596d008c2SKen Erickson static int
292696d008c2SKen Erickson atoi(char *p)
292796d008c2SKen Erickson {
292896d008c2SKen Erickson 	int i = 0;
292996d008c2SKen Erickson 
293096d008c2SKen Erickson 	while (*p != '\0')
293196d008c2SKen Erickson 		i = 10 * i + (*p++ - '0');
293296d008c2SKen Erickson 
293396d008c2SKen Erickson 	return (i);
293496d008c2SKen Erickson }
293596d008c2SKen Erickson 
2936ed5289f9SKen Erickson #endif /* _SOFT_HOSTID */
2937ed5289f9SKen Erickson 
29387c478bd9Sstevel@tonic-gate void
293945916cd2Sjpk get_system_configuration(void)
29407c478bd9Sstevel@tonic-gate {
29417c478bd9Sstevel@tonic-gate 	char	prop[32];
29427c478bd9Sstevel@tonic-gate 	u_longlong_t nodes_ll, cpus_pernode_ll, lvalue;
29437c478bd9Sstevel@tonic-gate 
294435b1ab99Sjosephb 	if (BOP_GETPROPLEN(bootops, "nodes") > sizeof (prop) ||
294535b1ab99Sjosephb 	    BOP_GETPROP(bootops, "nodes", prop) < 0 ||
294635b1ab99Sjosephb 	    kobj_getvalue(prop, &nodes_ll) == -1 ||
294735b1ab99Sjosephb 	    nodes_ll > MAXNODES ||
294835b1ab99Sjosephb 	    BOP_GETPROPLEN(bootops, "cpus_pernode") > sizeof (prop) ||
294935b1ab99Sjosephb 	    BOP_GETPROP(bootops, "cpus_pernode", prop) < 0 ||
295035b1ab99Sjosephb 	    kobj_getvalue(prop, &cpus_pernode_ll) == -1) {
29517c478bd9Sstevel@tonic-gate 		system_hardware.hd_nodes = 1;
29527c478bd9Sstevel@tonic-gate 		system_hardware.hd_cpus_per_node = 0;
29537c478bd9Sstevel@tonic-gate 	} else {
29547c478bd9Sstevel@tonic-gate 		system_hardware.hd_nodes = (int)nodes_ll;
29557c478bd9Sstevel@tonic-gate 		system_hardware.hd_cpus_per_node = (int)cpus_pernode_ll;
29567c478bd9Sstevel@tonic-gate 	}
295735b1ab99Sjosephb 
295835b1ab99Sjosephb 	if (BOP_GETPROPLEN(bootops, "kernelbase") > sizeof (prop) ||
295935b1ab99Sjosephb 	    BOP_GETPROP(bootops, "kernelbase", prop) < 0 ||
296035b1ab99Sjosephb 	    kobj_getvalue(prop, &lvalue) == -1)
29617c478bd9Sstevel@tonic-gate 		eprom_kernelbase = NULL;
29627c478bd9Sstevel@tonic-gate 	else
29637c478bd9Sstevel@tonic-gate 		eprom_kernelbase = (uintptr_t)lvalue;
29647c478bd9Sstevel@tonic-gate 
296535b1ab99Sjosephb 	if (BOP_GETPROPLEN(bootops, "segmapsize") > sizeof (prop) ||
296635b1ab99Sjosephb 	    BOP_GETPROP(bootops, "segmapsize", prop) < 0 ||
296735b1ab99Sjosephb 	    kobj_getvalue(prop, &lvalue) == -1)
29687c478bd9Sstevel@tonic-gate 		segmapsize = SEGMAPDEFAULT;
296935b1ab99Sjosephb 	else
29707c478bd9Sstevel@tonic-gate 		segmapsize = (uintptr_t)lvalue;
29717c478bd9Sstevel@tonic-gate 
297235b1ab99Sjosephb 	if (BOP_GETPROPLEN(bootops, "segmapfreelists") > sizeof (prop) ||
297335b1ab99Sjosephb 	    BOP_GETPROP(bootops, "segmapfreelists", prop) < 0 ||
297435b1ab99Sjosephb 	    kobj_getvalue(prop, &lvalue) == -1)
29757c478bd9Sstevel@tonic-gate 		segmapfreelists = 0;	/* use segmap driver default */
297635b1ab99Sjosephb 	else
29777c478bd9Sstevel@tonic-gate 		segmapfreelists = (int)lvalue;
29784944b02eSkchow 
2979aac11643Sjosephb 	/* physmem used to be here, but moved much earlier to fakebop.c */
29807c478bd9Sstevel@tonic-gate }
29817c478bd9Sstevel@tonic-gate 
29827c478bd9Sstevel@tonic-gate /*
29837c478bd9Sstevel@tonic-gate  * Add to a memory list.
29847c478bd9Sstevel@tonic-gate  * start = start of new memory segment
29857c478bd9Sstevel@tonic-gate  * len = length of new memory segment in bytes
29867c478bd9Sstevel@tonic-gate  * new = pointer to a new struct memlist
29877c478bd9Sstevel@tonic-gate  * memlistp = memory list to which to add segment.
29887c478bd9Sstevel@tonic-gate  */
2989ae115bc7Smrj void
29907c478bd9Sstevel@tonic-gate memlist_add(
29917c478bd9Sstevel@tonic-gate 	uint64_t start,
29927c478bd9Sstevel@tonic-gate 	uint64_t len,
29937c478bd9Sstevel@tonic-gate 	struct memlist *new,
29947c478bd9Sstevel@tonic-gate 	struct memlist **memlistp)
29957c478bd9Sstevel@tonic-gate {
29967c478bd9Sstevel@tonic-gate 	struct memlist *cur;
29977c478bd9Sstevel@tonic-gate 	uint64_t end = start + len;
29987c478bd9Sstevel@tonic-gate 
299956f33205SJonathan Adams 	new->ml_address = start;
300056f33205SJonathan Adams 	new->ml_size = len;
30017c478bd9Sstevel@tonic-gate 
30027c478bd9Sstevel@tonic-gate 	cur = *memlistp;
30037c478bd9Sstevel@tonic-gate 
30047c478bd9Sstevel@tonic-gate 	while (cur) {
300556f33205SJonathan Adams 		if (cur->ml_address >= end) {
300656f33205SJonathan Adams 			new->ml_next = cur;
30077c478bd9Sstevel@tonic-gate 			*memlistp = new;
300856f33205SJonathan Adams 			new->ml_prev = cur->ml_prev;
300956f33205SJonathan Adams 			cur->ml_prev = new;
30107c478bd9Sstevel@tonic-gate 			return;
30117c478bd9Sstevel@tonic-gate 		}
301256f33205SJonathan Adams 		ASSERT(cur->ml_address + cur->ml_size <= start);
301356f33205SJonathan Adams 		if (cur->ml_next == NULL) {
301456f33205SJonathan Adams 			cur->ml_next = new;
301556f33205SJonathan Adams 			new->ml_prev = cur;
301656f33205SJonathan Adams 			new->ml_next = NULL;
30177c478bd9Sstevel@tonic-gate 			return;
30187c478bd9Sstevel@tonic-gate 		}
301956f33205SJonathan Adams 		memlistp = &cur->ml_next;
302056f33205SJonathan Adams 		cur = cur->ml_next;
30217c478bd9Sstevel@tonic-gate 	}
30227c478bd9Sstevel@tonic-gate }
30237c478bd9Sstevel@tonic-gate 
30247c478bd9Sstevel@tonic-gate void
30257c478bd9Sstevel@tonic-gate kobj_vmem_init(vmem_t **text_arena, vmem_t **data_arena)
30267c478bd9Sstevel@tonic-gate {
30277c478bd9Sstevel@tonic-gate 	size_t tsize = e_modtext - modtext;
30287c478bd9Sstevel@tonic-gate 	size_t dsize = e_moddata - moddata;
30297c478bd9Sstevel@tonic-gate 
30307c478bd9Sstevel@tonic-gate 	*text_arena = vmem_create("module_text", tsize ? modtext : NULL, tsize,
30317c478bd9Sstevel@tonic-gate 	    1, segkmem_alloc, segkmem_free, heaptext_arena, 0, VM_SLEEP);
30327c478bd9Sstevel@tonic-gate 	*data_arena = vmem_create("module_data", dsize ? moddata : NULL, dsize,
30337c478bd9Sstevel@tonic-gate 	    1, segkmem_alloc, segkmem_free, heap32_arena, 0, VM_SLEEP);
30347c478bd9Sstevel@tonic-gate }
30357c478bd9Sstevel@tonic-gate 
30367c478bd9Sstevel@tonic-gate caddr_t
30377c478bd9Sstevel@tonic-gate kobj_text_alloc(vmem_t *arena, size_t size)
30387c478bd9Sstevel@tonic-gate {
30397c478bd9Sstevel@tonic-gate 	return (vmem_alloc(arena, size, VM_SLEEP | VM_BESTFIT));
30407c478bd9Sstevel@tonic-gate }
30417c478bd9Sstevel@tonic-gate 
30427c478bd9Sstevel@tonic-gate /*ARGSUSED*/
30437c478bd9Sstevel@tonic-gate caddr_t
30447c478bd9Sstevel@tonic-gate kobj_texthole_alloc(caddr_t addr, size_t size)
30457c478bd9Sstevel@tonic-gate {
30467c478bd9Sstevel@tonic-gate 	panic("unexpected call to kobj_texthole_alloc()");
30477c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
30487c478bd9Sstevel@tonic-gate 	return (0);
30497c478bd9Sstevel@tonic-gate }
30507c478bd9Sstevel@tonic-gate 
30517c478bd9Sstevel@tonic-gate /*ARGSUSED*/
30527c478bd9Sstevel@tonic-gate void
30537c478bd9Sstevel@tonic-gate kobj_texthole_free(caddr_t addr, size_t size)
30547c478bd9Sstevel@tonic-gate {
30557c478bd9Sstevel@tonic-gate 	panic("unexpected call to kobj_texthole_free()");
30567c478bd9Sstevel@tonic-gate }
30577c478bd9Sstevel@tonic-gate 
30587c478bd9Sstevel@tonic-gate /*
30597c478bd9Sstevel@tonic-gate  * This is called just after configure() in startup().
30607c478bd9Sstevel@tonic-gate  *
30617c478bd9Sstevel@tonic-gate  * The ISALIST concept is a bit hopeless on Intel, because
30627c478bd9Sstevel@tonic-gate  * there's no guarantee of an ever-more-capable processor
30637c478bd9Sstevel@tonic-gate  * given that various parts of the instruction set may appear
30647c478bd9Sstevel@tonic-gate  * and disappear between different implementations.
30657c478bd9Sstevel@tonic-gate  *
30667c478bd9Sstevel@tonic-gate  * While it would be possible to correct it and even enhance
30677c478bd9Sstevel@tonic-gate  * it somewhat, the explicit hardware capability bitmask allows
30687c478bd9Sstevel@tonic-gate  * more flexibility.
30697c478bd9Sstevel@tonic-gate  *
30707c478bd9Sstevel@tonic-gate  * So, we just leave this alone.
30717c478bd9Sstevel@tonic-gate  */
30727c478bd9Sstevel@tonic-gate void
30737c478bd9Sstevel@tonic-gate setx86isalist(void)
30747c478bd9Sstevel@tonic-gate {
30757c478bd9Sstevel@tonic-gate 	char *tp;
30767c478bd9Sstevel@tonic-gate 	size_t len;
30777c478bd9Sstevel@tonic-gate 	extern char *isa_list;
30787c478bd9Sstevel@tonic-gate 
30797c478bd9Sstevel@tonic-gate #define	TBUFSIZE	1024
30807c478bd9Sstevel@tonic-gate 
30817c478bd9Sstevel@tonic-gate 	tp = kmem_alloc(TBUFSIZE, KM_SLEEP);
30827c478bd9Sstevel@tonic-gate 	*tp = '\0';
30837c478bd9Sstevel@tonic-gate 
30847c478bd9Sstevel@tonic-gate #if defined(__amd64)
30857c478bd9Sstevel@tonic-gate 	(void) strcpy(tp, "amd64 ");
30867c478bd9Sstevel@tonic-gate #endif
30877c478bd9Sstevel@tonic-gate 
30887c478bd9Sstevel@tonic-gate 	switch (x86_vendor) {
30897c478bd9Sstevel@tonic-gate 	case X86_VENDOR_Intel:
30907c478bd9Sstevel@tonic-gate 	case X86_VENDOR_AMD:
30917c478bd9Sstevel@tonic-gate 	case X86_VENDOR_TM:
30927417cfdeSKuriakose Kuruvilla 		if (is_x86_feature(x86_featureset, X86FSET_CMOV)) {
30937c478bd9Sstevel@tonic-gate 			/*
30947c478bd9Sstevel@tonic-gate 			 * Pentium Pro or later
30957c478bd9Sstevel@tonic-gate 			 */
30967c478bd9Sstevel@tonic-gate 			(void) strcat(tp, "pentium_pro");
30977417cfdeSKuriakose Kuruvilla 			(void) strcat(tp,
30987417cfdeSKuriakose Kuruvilla 			    is_x86_feature(x86_featureset, X86FSET_MMX) ?
30997c478bd9Sstevel@tonic-gate 			    "+mmx pentium_pro " : " ");
31007c478bd9Sstevel@tonic-gate 		}
31017c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
31027c478bd9Sstevel@tonic-gate 	case X86_VENDOR_Cyrix:
31037c478bd9Sstevel@tonic-gate 		/*
31047c478bd9Sstevel@tonic-gate 		 * The Cyrix 6x86 does not have any Pentium features
31057c478bd9Sstevel@tonic-gate 		 * accessible while not at privilege level 0.
31067c478bd9Sstevel@tonic-gate 		 */
31077417cfdeSKuriakose Kuruvilla 		if (is_x86_feature(x86_featureset, X86FSET_CPUID)) {
31087c478bd9Sstevel@tonic-gate 			(void) strcat(tp, "pentium");
31097417cfdeSKuriakose Kuruvilla 			(void) strcat(tp,
31107417cfdeSKuriakose Kuruvilla 			    is_x86_feature(x86_featureset, X86FSET_MMX) ?
31117c478bd9Sstevel@tonic-gate 			    "+mmx pentium " : " ");
31127c478bd9Sstevel@tonic-gate 		}
31137c478bd9Sstevel@tonic-gate 		break;
31147c478bd9Sstevel@tonic-gate 	default:
31157c478bd9Sstevel@tonic-gate 		break;
31167c478bd9Sstevel@tonic-gate 	}
31177c478bd9Sstevel@tonic-gate 	(void) strcat(tp, "i486 i386 i86");
31187c478bd9Sstevel@tonic-gate 	len = strlen(tp) + 1;   /* account for NULL at end of string */
31197c478bd9Sstevel@tonic-gate 	isa_list = strcpy(kmem_alloc(len, KM_SLEEP), tp);
31207c478bd9Sstevel@tonic-gate 	kmem_free(tp, TBUFSIZE);
31217c478bd9Sstevel@tonic-gate 
31227c478bd9Sstevel@tonic-gate #undef TBUFSIZE
31237c478bd9Sstevel@tonic-gate }
31247c478bd9Sstevel@tonic-gate 
31257c478bd9Sstevel@tonic-gate 
31267c478bd9Sstevel@tonic-gate #ifdef __amd64
31277c478bd9Sstevel@tonic-gate 
31287c478bd9Sstevel@tonic-gate void *
31297c478bd9Sstevel@tonic-gate device_arena_alloc(size_t size, int vm_flag)
31307c478bd9Sstevel@tonic-gate {
31317c478bd9Sstevel@tonic-gate 	return (vmem_alloc(device_arena, size, vm_flag));
31327c478bd9Sstevel@tonic-gate }
31337c478bd9Sstevel@tonic-gate 
31347c478bd9Sstevel@tonic-gate void
31357c478bd9Sstevel@tonic-gate device_arena_free(void *vaddr, size_t size)
31367c478bd9Sstevel@tonic-gate {
31377c478bd9Sstevel@tonic-gate 	vmem_free(device_arena, vaddr, size);
31387c478bd9Sstevel@tonic-gate }
31397c478bd9Sstevel@tonic-gate 
3140ae115bc7Smrj #else /* __i386 */
31417c478bd9Sstevel@tonic-gate 
31427c478bd9Sstevel@tonic-gate void *
31437c478bd9Sstevel@tonic-gate device_arena_alloc(size_t size, int vm_flag)
31447c478bd9Sstevel@tonic-gate {
31457c478bd9Sstevel@tonic-gate 	caddr_t	vaddr;
31467c478bd9Sstevel@tonic-gate 	uintptr_t v;
31477c478bd9Sstevel@tonic-gate 	size_t	start;
31487c478bd9Sstevel@tonic-gate 	size_t	end;
31497c478bd9Sstevel@tonic-gate 
31507c478bd9Sstevel@tonic-gate 	vaddr = vmem_alloc(heap_arena, size, vm_flag);
31517c478bd9Sstevel@tonic-gate 	if (vaddr == NULL)
31527c478bd9Sstevel@tonic-gate 		return (NULL);
31537c478bd9Sstevel@tonic-gate 
31547c478bd9Sstevel@tonic-gate 	v = (uintptr_t)vaddr;
31557c478bd9Sstevel@tonic-gate 	ASSERT(v >= kernelbase);
3156ae115bc7Smrj 	ASSERT(v + size <= valloc_base);
31577c478bd9Sstevel@tonic-gate 
31587c478bd9Sstevel@tonic-gate 	start = btop(v - kernelbase);
31597c478bd9Sstevel@tonic-gate 	end = btop(v + size - 1 - kernelbase);
31607c478bd9Sstevel@tonic-gate 	ASSERT(start < toxic_bit_map_len);
31617c478bd9Sstevel@tonic-gate 	ASSERT(end < toxic_bit_map_len);
31627c478bd9Sstevel@tonic-gate 
31637c478bd9Sstevel@tonic-gate 	while (start <= end) {
31647c478bd9Sstevel@tonic-gate 		BT_ATOMIC_SET(toxic_bit_map, start);
31657c478bd9Sstevel@tonic-gate 		++start;
31667c478bd9Sstevel@tonic-gate 	}
31677c478bd9Sstevel@tonic-gate 	return (vaddr);
31687c478bd9Sstevel@tonic-gate }
31697c478bd9Sstevel@tonic-gate 
31707c478bd9Sstevel@tonic-gate void
31717c478bd9Sstevel@tonic-gate device_arena_free(void *vaddr, size_t size)
31727c478bd9Sstevel@tonic-gate {
31737c478bd9Sstevel@tonic-gate 	uintptr_t v = (uintptr_t)vaddr;
31747c478bd9Sstevel@tonic-gate 	size_t	start;
31757c478bd9Sstevel@tonic-gate 	size_t	end;
31767c478bd9Sstevel@tonic-gate 
31777c478bd9Sstevel@tonic-gate 	ASSERT(v >= kernelbase);
3178ae115bc7Smrj 	ASSERT(v + size <= valloc_base);
31797c478bd9Sstevel@tonic-gate 
31807c478bd9Sstevel@tonic-gate 	start = btop(v - kernelbase);
31817c478bd9Sstevel@tonic-gate 	end = btop(v + size - 1 - kernelbase);
31827c478bd9Sstevel@tonic-gate 	ASSERT(start < toxic_bit_map_len);
31837c478bd9Sstevel@tonic-gate 	ASSERT(end < toxic_bit_map_len);
31847c478bd9Sstevel@tonic-gate 
31857c478bd9Sstevel@tonic-gate 	while (start <= end) {
31867c478bd9Sstevel@tonic-gate 		ASSERT(BT_TEST(toxic_bit_map, start) != 0);
31877c478bd9Sstevel@tonic-gate 		BT_ATOMIC_CLEAR(toxic_bit_map, start);
31887c478bd9Sstevel@tonic-gate 		++start;
31897c478bd9Sstevel@tonic-gate 	}
31907c478bd9Sstevel@tonic-gate 	vmem_free(heap_arena, vaddr, size);
31917c478bd9Sstevel@tonic-gate }
31927c478bd9Sstevel@tonic-gate 
31937c478bd9Sstevel@tonic-gate /*
31947c478bd9Sstevel@tonic-gate  * returns 1st address in range that is in device arena, or NULL
31957c478bd9Sstevel@tonic-gate  * if len is not NULL it returns the length of the toxic range
31967c478bd9Sstevel@tonic-gate  */
31977c478bd9Sstevel@tonic-gate void *
31987c478bd9Sstevel@tonic-gate device_arena_contains(void *vaddr, size_t size, size_t *len)
31997c478bd9Sstevel@tonic-gate {
32007c478bd9Sstevel@tonic-gate 	uintptr_t v = (uintptr_t)vaddr;
32017c478bd9Sstevel@tonic-gate 	uintptr_t eaddr = v + size;
32027c478bd9Sstevel@tonic-gate 	size_t start;
32037c478bd9Sstevel@tonic-gate 	size_t end;
32047c478bd9Sstevel@tonic-gate 
32057c478bd9Sstevel@tonic-gate 	/*
32067c478bd9Sstevel@tonic-gate 	 * if called very early by kmdb, just return NULL
32077c478bd9Sstevel@tonic-gate 	 */
32087c478bd9Sstevel@tonic-gate 	if (toxic_bit_map == NULL)
32097c478bd9Sstevel@tonic-gate 		return (NULL);
32107c478bd9Sstevel@tonic-gate 
32117c478bd9Sstevel@tonic-gate 	/*
32127c478bd9Sstevel@tonic-gate 	 * First check if we're completely outside the bitmap range.
32137c478bd9Sstevel@tonic-gate 	 */
3214ae115bc7Smrj 	if (v >= valloc_base || eaddr < kernelbase)
32157c478bd9Sstevel@tonic-gate 		return (NULL);
32167c478bd9Sstevel@tonic-gate 
32177c478bd9Sstevel@tonic-gate 	/*
32187c478bd9Sstevel@tonic-gate 	 * Trim ends of search to look at only what the bitmap covers.
32197c478bd9Sstevel@tonic-gate 	 */
32207c478bd9Sstevel@tonic-gate 	if (v < kernelbase)
32217c478bd9Sstevel@tonic-gate 		v = kernelbase;
32227c478bd9Sstevel@tonic-gate 	start = btop(v - kernelbase);
32237c478bd9Sstevel@tonic-gate 	end = btop(eaddr - kernelbase);
32247c478bd9Sstevel@tonic-gate 	if (end >= toxic_bit_map_len)
32257c478bd9Sstevel@tonic-gate 		end = toxic_bit_map_len;
32267c478bd9Sstevel@tonic-gate 
32277c478bd9Sstevel@tonic-gate 	if (bt_range(toxic_bit_map, &start, &end, end) == 0)
32287c478bd9Sstevel@tonic-gate 		return (NULL);
32297c478bd9Sstevel@tonic-gate 
32307c478bd9Sstevel@tonic-gate 	v = kernelbase + ptob(start);
32317c478bd9Sstevel@tonic-gate 	if (len != NULL)
32327c478bd9Sstevel@tonic-gate 		*len = ptob(end - start);
32337c478bd9Sstevel@tonic-gate 	return ((void *)v);
32347c478bd9Sstevel@tonic-gate }
32357c478bd9Sstevel@tonic-gate 
3236ae115bc7Smrj #endif	/* __i386 */
3237