startup.c revision ec25b48f5e0576a68280c5e549673a266f0be346
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/machsystm.h>
#include <sys/archsystm.h>
#include <sys/bootconf.h>
#include <sys/memlist_plat.h>
#include <sys/memlist_impl.h>
#include <sys/prom_plat.h>
#include <sys/prom_isa.h>
#include <sys/autoconf.h>
#include <sys/iommutsb.h>
#include <vm/seg_kmem.h>
#include <vm/hat_sfmmu.h>
#include <sys/platform_module.h>
#include <sys/cpu_sgnblk_defs.h>
#include <sys/prom_debug.h>
#include <sys/traptrace.h>
#include <sys/mem_cage.h>
extern void setup_trap_table(void);
extern void cpu_intrq_setup(struct cpu *);
extern void cpu_intrq_register(struct cpu *);
extern void contig_mem_init(void);
extern void mach_dump_buffer_init(void);
extern void mach_descrip_init(void);
extern void mach_descrip_startup_fini(void);
extern void mach_memscrub(void);
extern void mach_fpras(void);
extern void mach_cpu_halt_idle(void);
extern void mach_hw_copy_limit(void);
extern void load_mach_drivers(void);
extern void load_tod_module(void);
#pragma weak load_tod_module
#pragma weak ndata_alloc_mmfsa
extern void cif_init(void);
extern void parse_idprom(void);
extern void add_vx_handler(char *, int, void (*)(cell_t *));
extern void mem_config_init(void);
extern void memseg_remap_init(void);
extern void mach_kpm_init(void);
/*
* External Data:
*/
extern int vac_size; /* cache size in bytes */
extern uint_t vac_colors;
/*
* Global Data Definitions:
*/
/*
* XXX - Don't port this to new architectures
* A 3rd party volume manager driver (vxdm) depends on the symbol romp.
* 'romp' has no use with a prom with an IEEE 1275 client interface.
* The driver doesn't use the value, but it depends on the symbol.
*/
void *romp; /* veritas driver won't load without romp 4154976 */
/*
* Declare these as initialized data so we can patch them.
*/
int vac_copyback = 1;
char *cache_mode = NULL;
int use_mix = 1;
int prom_debug = 0;
uint_t tba_taken_over = 0;
/*
* End of first block of contiguous kernel in 32-bit virtual address space
*/
int memexp_flag; /* memory expansion card flag */
/*
* VM data structures
*/
long page_hashsz; /* Size of page hash table (power of two) */
/*
* debugger pages (if allocated)
*/
/*
* Segment for relocated kernel structures in 64-bit large RAM kernels
*/
struct memseg *memseg_base;
struct vnode unused_pages_vp;
/*
* VM data structures allocated early during boot.
*/
char tbr_wr_addr_inited = 0;
/*
* Static Routines:
*/
struct memlist **);
pgcnt_t);
static void kvm_init(void);
static void startup_init(void);
static void startup_memlist(void);
static void startup_modules(void);
static void startup_bop_gone(void);
static void startup_vm(void);
static void startup_end(void);
static void setup_cage_params(void);
static void startup_create_io_node(void);
void *memlist_end;
static pgcnt_t bop_alloc_pages;
uint_t hblk_alloc_dynamic = 0;
/*
* Hooks for unsupported platforms and down-rev firmware
*/
int iam_positron(void);
#pragma weak iam_positron
static void do_prom_version_check(void);
static void kpm_init(void);
static void kpm_npages_setup(int);
static void kpm_memseg_init(void);
/*
* After receiving a thermal interrupt, this is the number of seconds
* to delay before shutting off the system, assuming
* large enough.
*/
int thermal_powerdown_delay = 1200;
/*
* Used to hold off page relocations into the cage until OBP has completed
* its boot-time handoff of its resources to the kernel.
*/
int page_relocate_ready = 0;
/*
* Enable some debugging messages concerning memory usage...
*/
#ifdef DEBUGGING_MEM
static int debugging_mem;
static void
{
if (!debugging_mem)
return;
while (list) {
prom_printf("\taddr = 0x%x %8x, size = 0x%x %8x\n",
}
}
void
{
if (!debugging_mem)
return;
printf("memseg\n");
while (memseg) {
prom_printf("\tpage = 0x%p, epage = 0x%p, "
"pfn = 0x%x, epfn = 0x%x\n",
}
}
#else /* DEBUGGING_MEM */
#endif /* DEBUGGING_MEM */
/* Simple message to indicate that the bootops pointer has been zeroed */
#ifdef DEBUG
static int bootops_gone_on = 0;
#define BOOTOPS_GONE() \
if (bootops_gone_on) \
prom_printf("The bootops vec is zeroed now!\n");
#else
#define BOOTOPS_GONE()
#endif /* DEBUG */
/*
* Monitor pages may not be where this says they are.
* and the debugger may not be there either.
*
* Note that 'pages' here are *physical* pages, which are 8k on sun4u.
*
* Physical memory layout
* (not necessarily contiguous)
* (THIS IS SOMEWHAT WRONG)
* /-----------------------\
* | monitor pages |
* availmem -|-----------------------|
* | |
* | page pool |
* | |
* |-----------------------|
* | configured tables |
* | buffers |
* firstaddr -|-----------------------|
* | hat data structures |
* |-----------------------|
* | kernel data, bss |
* |-----------------------|
* | interrupt stack |
* |-----------------------|
* | kernel text (RO) |
* |-----------------------|
* | trap table (4k) |
* |-----------------------|
* page 1 | panicbuf |
* |-----------------------|
* page 0 | reclaimed |
* |_______________________|
*
*
*
* Kernel's Virtual Memory Layout.
* /-----------------------\
* 0xFFFFFFFF.FFFFFFFF -| |-
* | OBP's virtual page |
* | tables |
* 0xFFFFFFFC.00000000 -|-----------------------|-
* : :
* : :
* 0xFFFFFE00.00000000 -|-----------------------|-
* | segkpm segment | up to 2TB of physical
* | (64-bit kernel ONLY) | memory, VAC has 2 colors
* | |
* 0xFFFFFA00.00000000 -|-----------------------|- 2TB segkpm alignment
* : :
* : :
* 0xFFFFF810.00000000 -|-----------------------|- hole_end
* | | ^
* | bug requires an extra | |
* | 4 GB of space between | |
* | hole and used RAM | |
* | | |
* 0xFFFFF800.00000000 -|-----------------------|- |
* | | |
* | Virtual Address Hole | UltraSPARC
* | | |
* 0x00000800.00000000 -|-----------------------|- |
* | | |
* | bug requires an extra | |
* | 4 GB of space between | |
* | hole and used RAM | |
* | | v
* 0x000007FF.00000000 -|-----------------------|- hole_start -----
* : : ^
* : : |
* 0x00000XXX.XXXXXXXX -|-----------------------|- kmem64_end |
* | | |
* | 64-bit kernel ONLY | |
* | | |
* | kmem64 segment | |
* | | |
* | (Relocated extra HME | Approximately
* | block allocations, | 1 TB of virtual
* | memnode freelists, | address space
* | HME hash buckets, | |
* | mml_table, kpmp_table,| |
* | page_t array and | |
* | hashblock pool to | |
* | avoid hard-coded | |
* | 32-bit vaddr | |
* | limitations) | |
* | | v
* 0x00000700.00000000 -|-----------------------|- SYSLIMIT (kmem64_base)
* | |
* | segkmem segment | (SYSLIMIT - SYSBASE = 4TB)
* | |
* 0x00000300.00000000 -|-----------------------|- SYSBASE
* : :
* : :
* -|-----------------------|-
* | |
* | segmap segment | SEGMAPSIZE (1/8th physmem,
* | | 256G MAX)
* 0x000002a7.50000000 -|-----------------------|- SEGMAPBASE
* : :
* : :
* -|-----------------------|-
* | |
* | segkp | SEGKPSIZE (2GB)
* | |
* | |
* 0x000002a1.00000000 -|-----------------------|- SEGKPBASE
* | |
* 0x000002a0.00000000 -|-----------------------|- MEMSCRUBBASE
* | | (SEGKPBASE - 0x400000)
* 0x0000029F.FFE00000 -|-----------------------|- ARGSBASE
* | | (MEMSCRUBBASE - NCARGS)
* 0x0000029F.FFD80000 -|-----------------------|- PPMAPBASE
* | | (ARGSBASE - PPMAPSIZE)
* 0x0000029F.FFD00000 -|-----------------------|- PPMAP_FAST_BASE
* | |
* 0x0000029F.FF980000 -|-----------------------|- PIOMAPBASE
* | |
* 0x0000029F.FF580000 -|-----------------------|- NARG_BASE
* : :
* : :
* 0x00000000.FFFFFFFF -|-----------------------|- OFW_END_ADDR
* | |
* | OBP |
* | |
* 0x00000000.F0000000 -|-----------------------|- OFW_START_ADDR
* | kmdb |
* 0x00000000.EDD00000 -|-----------------------|- SEGDEBUGBASE
* : :
* : :
* 0x00000000.7c000000 -|-----------------------|- SYSLIMIT32
* | |
* | segkmem32 segment | (SYSLIMIT32 - SYSBASE32 =
* | | ~64MB)
* 0x00000000.78002000 -|-----------------------|
* | panicbuf |
* 0x00000000.78000000 -|-----------------------|- SYSBASE32
* : :
* : :
* | |
* |-----------------------|- econtig32
* | vm structures |
* 0x00000000.01C00000 |-----------------------|- nalloc_end
* | TSBs |
* |-----------------------|- end/nalloc_base
* | kernel data & bss |
* 0x00000000.01800000 -|-----------------------|
* : nucleus text hole :
* 0x00000000.01400000 -|-----------------------|
* : :
* |-----------------------|
* | module text |
* | kernel text |
* |-----------------------|
* | trap table (48k) |
* 0x00000000.01000000 -|-----------------------|- KERNELBASE
* | reserved for trapstat |} TSTAT_TOTAL_SIZE
* |-----------------------|
* | |
* | invalid |
* | |
* 0x00000000.00000000 _|_______________________|
*
*
*
* 32-bit User Virtual Memory Layout.
* /-----------------------\
* | |
* | invalid |
* | |
* 0xFFC00000 -|-----------------------|- USERLIMIT
* | user stack |
* : :
* : :
* : :
* | user data |
* -|-----------------------|-
* | user text |
* 0x00002000 -|-----------------------|-
* | invalid |
* 0x00000000 _|_______________________|
*
*
*
* 64-bit User Virtual Memory Layout.
* /-----------------------\
* | |
* | invalid |
* | |
* 0xFFFFFFFF.80000000 -|-----------------------|- USERLIMIT
* | user stack |
* : :
* : :
* : :
* | user data |
* -|-----------------------|-
* | user text |
* 0x00000000.00100000 -|-----------------------|-
* | invalid |
* 0x00000000.00000000 _|_______________________|
*/
extern uint64_t ecache_flush_address(void);
#pragma weak load_platform_modules
#pragma weak plat_startup_memlist
#pragma weak ecache_init_scrub_flush_area
#pragma weak ecache_flush_address
/*
* By default the DR Cage is enabled for maximum OS
* MPSS performance. Users needing to disable the cage mechanism
* Disabling the cage on systems supporting Dynamic Reconfiguration (DR)
* will result in loss of DR functionality.
* Platforms wishing to disable kernel Cage by default
* should do so in their set_platform_defaults() routine.
*/
int kernel_cage_enable = 1;
static void
setup_cage_params(void)
{
void (*func)(void);
(*func)();
return;
}
if (kernel_cage_enable == 0) {
return;
}
}
if (kcage_on) {
} else {
}
}
/*
* Machine-dependent startup code
*/
void
startup(void)
{
startup_init();
if (&startup_platform)
startup_vm();
startup_end();
}
struct regs sync_reg_buf;
void
sync_handler(void)
{
int i;
/*
* Prevent trying to talk to the other CPUs since they are
* sitting in the prom and won't reply.
*/
for (i = 0; i < NCPU; i++) {
}
}
/*
* We've managed to get here without going through the
* normal panic code path. Try and save some useful
* information.
*/
}
/*
* If we're re-entering the panic path, update the signature
* block so that the SC knows we're in the second part of panic.
*/
if (panicstr)
panic("sync initiated");
}
static void
startup_init(void)
{
/*
* We want to save the registers while we're still in OBP
* so that we know they haven't been fiddled with since.
* (In principle, OBP can't change them just because it
* makes a callback, but we'd rather not depend on that
* behavior.)
*/
char sync_str[] =
"warning @ warning off : sync "
"%%tl-c %%tstate h# %p x! "
"%%g1 h# %p x! %%g2 h# %p x! %%g3 h# %p x! "
"%%g4 h# %p x! %%g5 h# %p x! %%g6 h# %p x! "
"%%g7 h# %p x! %%o0 h# %p x! %%o1 h# %p x! "
"%%o2 h# %p x! %%o3 h# %p x! %%o4 h# %p x! "
"%%o5 h# %p x! %%o6 h# %p x! %%o7 h# %p x! "
"%%tl-c %%tpc h# %p x! %%tl-c %%tnpc h# %p x! "
"%%y h# %p l! %%tl-c %%tt h# %p x! "
"sync ; warning !";
/*
* 20 == num of %p substrings
* 16 == max num of chars %p will expand to.
*/
/*
* Initialize ptl1 stack for the 1st CPU.
*/
/*
* Initialize the address map for cache consistent mappings
* to random pages; must be done after vac_size is set.
*/
ppmapinit();
/*
* Initialize the PROM callback handler.
*/
/*
* have prom call sync_callback() to handle the sync and
* save some useful information which will be stored in the
* core file later.
*/
prom_interpret(bp, 0, 0, 0, 0, 0);
}
(MAX_RSVD_IV * sizeof (intr_vec_t)) + \
(MAX_RSVD_IVX * sizeof (intr_vecx_t)))
/*
* As OBP takes up some RAM when the system boots, pages will already be "lost"
* to the system and reflected in npages by the time we see it.
*
* We only want to allocate kernel structures in the 64-bit virtual address
* space on systems with enough RAM to make the overhead of keeping track of
* an extra kernel memory segment worthwhile.
*
* Since OBP has already performed its memory allocations by this point, if we
* have more than MINMOVE_RAM_MB MB of RAM left free, go ahead and map
* memory in the 64-bit virtual address space; otherwise keep allocations
* contiguous with we've mapped so far in the 32-bit virtual address space.
*/
static void
startup_memlist(void)
{
int memblocks = 0;
int alloc_alignsize = MMU_PAGESIZE;
extern void page_coloring_init(void);
/*
* Initialize enough of the system to allow kmem_alloc to work by
* calling boot to allocate its memory until the time that
* kvm_init is completed. The page structs are allocated after
* rounding up end to the nearest page boundary; the memsegs are
* initialized and the space they use comes from the kernel heap.
* With appropriate initialization, they can be reallocated later
* to a size appropriate for the machine's configuration.
*
* At this point, memory is allocated for things that will never
* need to be freed, this used to be "valloced". This allows a
* savings as the pages don't need page structures to describe
* them because them will not be managed by the vm system.
*/
/*
* We're loaded by boot with the following configuration (as
*
* text: 4 MB chunk aligned on a 4MB boundary
* data & bss: 4 MB chunk aligned on a 4MB boundary
*
* These two chunks will eventually be mapped by 2 locked 4MB
* ttes and will represent the nucleus of the kernel. This gives
* us some free space that is already allocated, some or all of
* which is made available to kernel module text.
*
* The free space in the data-bss chunk is used for nucleus
* allocatable data structures and we reserve it using the
* nalloc_base and nalloc_end variables. This space is currently
* being used for hat data structures required for tlb miss
* handling operations. We align nalloc_base to a l2 cache
* linesize because this is the line size the hardware uses to
* maintain cache coherency.
* 256K is carved out for module data.
*/
/*
* Calculate the start of the data segment.
*/
/*
* Remember any slop after e_text so we can give it to the modules.
*/
panic("nucleus text overflow");
/*
* Remember what the physically available highest page is
* so that dumpsys works properly, and find out how much
* memory is installed.
*/
/* Fill out memory nodes config structure */
/*
* Get the list of physically available memory to size
* the number of page structures needed.
*/
/*
* This first snap shot of npages can represent the pages used
* by OBP's text and data approximately. This is used in the
* the calculation of the kernel size
*/
/*
* On small-memory systems (<MODTEXT_SM_SIZE MB, currently 256MB), the
* in-nucleus module text is capped to MODTEXT_SM_CAP bytes (currently
* 2MB) and any excess pages are put on physavail. The assumption is
* that small-memory systems will need more pages more than they'll
* need efficiently-mapped module texts.
*/
modtext_sz > MODTEXT_SM_CAP) {
} else
extra_etpg = 0;
/*
* Account for any pages after e_text and e_data.
*/
npages += extra_etpg;
/*
* npages is the maximum of available physical memory possible.
* (ie. it will never be more than this)
*/
/*
* initialize the nucleus memory allocator.
*/
/*
* Allocate mmu fault status area from the nucleus data area.
*/
/*
* Allocate kernel TSBs from the nucleus data area.
*/
/*
* Allocate dmv dispatch table from the nucleus data area.
*/
if (ndata_alloc_dmv(&ndata) != 0)
/*
* Allocate page_freelists bin headers for memnode 0 from the
* nucleus data area.
*/
if (ndata_alloc_page_freelists(&ndata, 0) != 0)
"no more nucleus memory after page free lists alloc");
if (kpm_enable) {
kpm_init();
/*
* kpm page space -- Update kpm_npages and make the
* same assumption about fragmenting as it is done
* for memseg_sz.
*/
}
/*
* Allocate hat related structs from the nucleus data area.
*/
/*
* We want to do the BOP_ALLOCs before the real allocation of page
* structs in order to not have to allocate page structs for this
* memory. We need to calculate a virtual address because we want
* the page structs to come before other allocations in virtual address
* space. This is so some (if not all) of page structs can actually
* live in the nucleus.
*/
/*
* WARNING WARNING WARNING WARNING WARNING WARNING WARNING
*
* There are comments all over the SFMMU code warning of dire
* consequences if the TSBs are moved out of 32-bit space. This
* is largely because the asm code uses "sethi %hi(addr)"-type
* instructions which will not provide the expected result if the
* address is a 64-bit one.
*
* WARNING WARNING WARNING WARNING WARNING WARNING WARNING
*/
/*
* Allocate IOMMU TSB array. We do this here so that the physical
* memory gets deducted from the PROM's physical memory list.
*/
/*
* Platforms like Starcat and OPL need special structures assigned in
* 32-bit virtual address space because their probing routines execute
* FCode, and FCode can't handle 64-bit virtual addresses...
*/
if (&plat_startup_memlist) {
}
/*
* If we have enough memory, use 4M pages for alignment because it
* greatly reduces the number of TLB misses we take albeit at the cost
* of possible RAM wastage (degenerate case of 4 MB - MMU_PAGESIZE per
* allocation.) Still, the speedup on large memory systems (e.g. > 64
* GB) is quite noticeable, so it is worth the effort to do if we can.
*
* Note, however, that this speedup will only occur if the boot PROM
* uses the largest possible MMU page size possible to map memory
* requests that are properly aligned and sized (for example, a request
* for a multiple of 4MB of memory aligned to a 4MB boundary will
* result in a mapping using a 4MB MMU page.)
*
* Even then, the large page mappings will only speed things up until
* the startup process proceeds a bit further, as when
* sfmmu_map_prom_mappings() copies page mappings from the PROM to the
* kernel it remaps everything but the TSBs using 8K pages anyway...
*
* At some point in the future, sfmmu_map_prom_mappings() will be
* rewritten to copy memory mappings to the kernel using the same MMU
* page sizes the PROM used. When that occurs, if the PROM did use
* doing now should give us a nice extra performance boost, albeit at
* the cost of greater RAM usage...
*/
/*
* Save off where the contiguous allocations to date have ended
* in econtig32.
*/
/*
* To avoid memory allocation collisions in the 32-bit virtual address
* space, make allocations from this point forward in 64-bit virtual
* address space starting at syslimit and working up. Also use the
* alignment specified by alloc_alignsize, as we may be able to save
* ourselves TLB misses by using larger page sizes if they're
* available.
*
* All this is needed because on large memory systems, the default
* Solaris allocations will collide with SYSBASE32, which is hard
* coded to be at the virtual address 0x78000000. Therefore, on 64-bit
* kernels, move the allocations to a location in the 64-bit virtual
* address space space, allowing those structures to grow without
* worry.
*
* On current CPUs we'll run out of physical memory address bits before
* we need to worry about the allocations running into anything else in
* VM or the virtual address holes on US-I and II, as there's currently
*/
/*
* them here.
*/
/*
* alloc_hme_buckets() will align alloc_base properly before
* assigning the hash buckets, so we don't need to do it
* before the call...
*/
}
/*
* Allocate the remaining page freelists. NUMA systems can
* have lots of page freelists, one per node, which quickly
* outgrow the amount of nucleus memory available.
*/
if (max_mem_nodes > 1) {
int mnode;
}
if (alloc_base > alloc_start) {
"Unable to alloc page freelists\n");
}
}
if (!mml_table) {
/*
* We need to allocate the mml_table here because there
* was not enough space within the nucleus.
*/
panic("mml_table alloc failure");
alloc_base += alloc_sz;
}
/*
* We need to allocate either kpmp_table or kpmp_stable here
* because there was not enough space within the nucleus.
*/
kpmptable_sz = (kpm_smallpages == 0) ?
sizeof (kpm_hlk_t) * kpmp_table_sz :
sizeof (kpm_shlk_t) * kpmp_stable_sz;
if (table != alloc_base)
panic("kpmp_table or kpmp_stable alloc failure");
if (kpm_smallpages == 0) {
} else {
}
alloc_base += alloc_sz;
}
if (&ecache_init_scrub_flush_area) {
/*
* Pass alloc_base directly, as the routine itself is
* responsible for any special alignment requirements...
*/
}
/*
* Take the most current snapshot we can by calling mem-update.
*/
/*
* Reset npages and memblocks based on boot_physavail list.
*/
/*
* Account for extra memory after e_text.
*/
npages += extra_etpg;
/*
* Calculate the largest free memory chunk in the nucleus data area.
* We need to figure out if page structs can fit in there or not.
* We also make sure enough page structs get created for any physical
* memory we might be returning to the system.
*/
/*
* Here's a nice bit of code based on somewhat recursive logic:
*
* If the page array would fit within the nucleus, we want to
* add npages to cover any extra memory we may be returning back
* to the system.
*
* HOWEVER, the page array is sized by calculating the size of
* (struct page * npages), as are the pagehash table, ctrs and
* memseg_list, so the very act of performing the calculation below may
* in fact make the array large enough that it no longer fits in the
* nucleus, meaning there would now be a much larger area of the
* nucleus free that should really be added to npages, which would
* make the page array that much larger, and so on.
*
* This also ignores the memory possibly used in the nucleus for the
* the page hash, ctrs and memseg list and the fact that whether they
* fit there or not varies with the npages calculation below, but we
* don't even factor them into the equation at this point; perhaps we
* should or perhaps we should just take the approach that the few
* extra pages we could add via this calculation REALLY aren't worth
* the hassle...
*/
if (ndata_remain_sz > pp_sz) {
}
/*
* If physmem is patched to be non-zero, use it instead of
* the monitor value unless physmem is larger than the total
* amount of memory on hand.
*/
/*
* If pp_base is NULL that means the routines above have determined
* the page array will not fit in the nucleus; we'll have to
* BOP_ALLOC() ourselves some space for them.
*/
(struct page *)alloc_base)
panic("page alloc failure");
alloc_base += alloc_sz;
}
/*
* The page structure hash table size is a power of 2
* such that the average hash chain length is PAGE_HASHAVELEN.
*/
/*
* We want to TRY to fit the page structure hash table,
* the page size free list counters, the memseg list and
* and the kpm page space in the nucleus if possible.
*
* alloc_sz counts how much memory needs to be allocated by
* BOP_ALLOC().
*/
/*
* Size up per page size free list counters.
*/
ctrs_sz = page_ctrs_sz();
/*
* The memseg list is for the chunks of physical memory that
* will be managed by the vm system. The number calculated is
* a guess as boot may fragment it more when memory allocations
* are made before kphysm_init(). Currently, there are two
* allocations before then, so we assume each causes fragmen-
* tation, and add a couple more for good measure.
*/
if (memseg_base == NULL)
if (kpm_enable) {
/*
* kpm page space -- Update kpm_npages and make the
* same assumption about fragmenting as it is done
* for memseg_sz above.
*/
kpm_pp_sz = (kpm_smallpages == 0) ?
kpm_npages * sizeof (kpm_page_t):
kpm_npages * sizeof (kpm_spage_t);
if (kpm_pp_base == NULL)
}
if (alloc_sz > 0) {
/*
* We need extra memory allocated through BOP_ALLOC.
*/
panic("system page struct alloc failure");
alloc_base += alloc_sz;
}
}
if (memseg_base == NULL) {
}
}
}
/*
* Initialize per page size free list counters.
*/
#ifdef TRAPTRACE
/*
* Allocate trap trace buffer last so as not to affect
* the 4M alignments of the allocations above on V9 SPARCs...
*/
#endif /* TRAPTRACE */
if (kmem64_base) {
/*
* Set the end of the kmem64 segment for V9 SPARCs, if
* appropriate...
*/
}
/*
* Allocate space for the interrupt vector table and also for the
* reserved interrupt vector data structures.
*/
panic("interrupt vector table allocation failure");
/*
* The memory lists from boot are allocated from the heap arena
*/
panic("could not retrieve property \"extent\"");
/*
* Between now and when we finish copying in the memory lists,
* allocations happen so the space gets fragmented and the
* lists longer. Leave enough space for lists twice as long
* as what boot says it has now; roundup to a pagesize.
* Also add space for the final phys-avail copy in the fixup
* routine.
*/
memlist_sz *= 4;
halt("Boot allocation failed.");
/*
* Take the most current snapshot we can by calling mem-update.
*/
/*
* Remove the space used by BOP_ALLOC from the kernel heap
* plus the area actually used by the OBP (if any)
* ignoring virtual addresses in virt_avail, above syslimit.
*/
continue;
break;
/*
* Limit the range to end at syslimit.
*/
}
&memlist, 0, 0);
/*
* Add any extra memory after e_text to the phys_avail list, as long
* as there's at least a page to add.
*/
if (extra_etpg)
&memlist, &phys_avail);
/*
* Add any extra memory after e_data to the phys_avail list as long
* as there's at least a page to add. Usually, there isn't any,
* since extra HME blocks typically get allocated there first before
* using RAM elsewhere.
*/
if (ndata_remain_sz >= MMU_PAGESIZE)
panic("memlist overflow");
/*
* Initialize the page structures from the memory lists.
*/
/*
* Some of the locks depend on page_hashsz being set!
* kmem_init() depends on this; so, keep it here.
*/
/*
* Initialize kernel memory allocator.
*/
kmem_init();
/*
* Initialize bp_mapin().
*/
/*
* Reserve space for panicbuf, intr_vec_table and reserved interrupt
* vector data structures from the 32-bit heap.
*/
}
static void
startup_modules(void)
{
/*
* Log any optional messages from the boot program
*/
if (proplen > 0) {
char *msg;
}
/*
* Let the platforms have a chance to change default
* values before reading system file.
*/
if (&set_platform_defaults)
/*
* Calculate default settings of system parameters based upon
*/
param_calc(0);
mod_setup();
/*
* If this is a positron, complain and halt.
*/
if (&iam_positron && iam_positron()) {
" by this release of Solaris.\n");
#ifdef DEBUG
prom_enter_mon(); /* Type 'go' to resume */
#else /* DEBUG */
halt(0);
#endif /* DEBUG */
}
/*
* If we are running firmware that isn't 64-bit ready
* then complain and halt.
*/
/*
* Initialize system parameters
*/
param_init();
/*
* maxmem is the amount of physical memory we're playing with.
*/
/* Set segkp limits. */
/*
* Initialize the hat layer.
*/
hat_init();
/*
* Initialize segment management stuff.
*/
seg_init();
/*
* Create the va>tte handler, so the prom can understand
* kernel translations. The handler is installed later, just
* as we are about to take over the trap table from the prom.
*/
/*
* Load the forthdebugger (optional)
*/
/*
* Create OBP node for console input callbacks
* if it is needed.
*/
halt("Can't load specfs");
halt("Can't load devfs");
halt("Can't load swapgeneric");
dispinit();
/*
* Infer meanings to the members of the idprom buffer.
*/
parse_idprom();
/* Read cluster configuration data. */
clconf_init();
setup_ddi();
/*
* Lets take this opportunity to load the root device.
*/
if (loadrootmodules() != 0)
debug_enter("Can't load the root filesystem");
/*
* Load tod driver module for the tod part found on this system.
* tends to keep time more accurately.
*/
if (&load_tod_module)
/*
* Allow platforms to load modules which might
* be needed after bootops are gone.
*/
if (&load_platform_modules)
setcpudelay();
/*
* Calculation and allocation of hmeblks needed to remap
* the memory allocated by PROM till now:
*
* (1) calculate how much virtual memory has been bop_alloc'ed.
* (2) roundup this memory to span of hme8blk, i.e. 64KB
* (3) calculate number of hme8blk's needed to remap this memory
* (4) calculate amount of memory that's consumed by these hme8blk's
* (5) add memory calculated in steps (2) and (4) above.
* (6) roundup this memory to span of hme8blk, i.e. 64KB
* (7) calculate number of hme8blk's needed to remap this memory
* (8) calculate amount of memory that's consumed by these hme8blk's
* (9) allocate additional hme1blk's to hold large mappings.
* H8TOH1 determines this. The current SWAG gives enough hblk1's
* to remap everything with 4M mappings.
* (10) account for partially used hblk8's due to non-64K aligned
* PROM mapping entries.
* (11) add memory calculated in steps (8), (9), and (10) above.
* (12) kmem_zalloc the memory calculated in (11); since segkmem
* is not ready yet, this gets bop_alloc'ed.
* (13) there will be very few bop_alloc's after this point before
* trap table takes over
*/
/* sfmmu_init_nucleus_hblks expects properly aligned data structures. */
/*
* Since hblk8's can hold up to 64k of mappings aligned on a 64k
* boundary, the number of hblk8's needed to map the entries in the
* boot_virtavail list needs to be adjusted to take this into
* consideration. Thus, we need to add additional hblk8's since it
* is possible that an hblk8 will not have all 8 slots used due to
* alignment constraints. Since there were boot_virtavail_len entries
* in that list, we need to add that many hblk8's to the number
* already calculated to make sure we don't underestimate.
*/
/* Allocate in pagesize chunks */
}
static void
startup_bop_gone(void)
{
extern int bop_io_quiesced;
/*
* Destroy the MD initialized at startup
* The startup initializes the MD framework
* using prom and BOP alloc free it now.
*/
/*
* Call back into boot and release boots resources.
*/
bop_io_quiesced = 1;
/*
* Copy physinstalled list into kernel space.
*/
/*
* setup physically contiguous area twice as large as the ecache.
* this is used while doing displacement flush of ecaches
*/
if (&ecache_flush_address) {
"startup: no memory to set ecache_flushaddr");
}
}
/*
* Virtual available next.
*/
/*
* Last chance to ask our booter questions ..
*/
}
/*
* startup_fixup_physavail - called from mach_sfmmu.c after the final
* allocations have been performed. We can't call it in startup_bop_gone
* since later operations can cause obp to allocate more memory.
*/
void
startup_fixup_physavail(void)
{
/*
* take the most current snapshot we can by calling mem-update
*/
/*
* Copy phys_avail list, again.
* from the original list we copied earlier.
*/
&memlist, 0, 0);
/*
* Add any extra memory after e_text we added to the phys_avail list
* back to the old list.
*/
if (extra_etpg)
if (ndata_remain_sz >= MMU_PAGESIZE)
/*
* There isn't any bounds checking on the memlist area
* so ensure it hasn't overgrown.
*/
/*
* The kernel removes the pages that were allocated for it from
* the freelist, but we now have to find any -extra- pages that
* the prom has allocated for it's own book-keeping, and remove
* them from the freelist too. sigh.
*/
phys_avail = cur;
/*
* We're done with boot. Just after this point in time, boot
* gets unmapped, so we can no longer rely on its services.
* Zero the bootops to indicate this fact.
*/
BOOTOPS_GONE();
}
static void
startup_vm(void)
{
size_t i;
struct segmap_crargs a;
struct segkpm_crargs b;
int mnode;
extern int use_brk_lpg, use_stk_lpg;
/*
* get prom's mappings, create hments for them and switch
* to the kernel context.
*/
/*
* Take over trap table
*/
/*
* Install the va>tte handler, so that the prom can handle
* misses and understand the kernel table layout in case
* we need call into the prom.
*/
/*
* Set a flag to indicate that the tba has been taken over.
*/
tba_taken_over = 1;
/* initialize MMU primary context register */
/*
* The boot cpu can now take interrupts, x-calls, x-traps
*/
/*
* Set a flag to tell write_scb_int() that it can access V_TBR_WR_ADDR.
*/
tbr_wr_addr_inited = 1;
/*
* Initialize VM system, and map kernel address space.
*/
kvm_init();
/*
* XXX4U: previously, we initialized and turned on
* the caches at this point. But of course we have
* nothing to do, as the prom has already done this
* for us -- main memory must be E$able at all times.
*/
/*
* If the following is true, someone has patched
* phsymem to be less than the number of pages that
* the system actually has. Remove pages until system
* memory is limited to the requested amount. Since we
* have allocated page structures for all pages, we
* correct the amount of memory we want to remove
* by the size of the memory used to hold page structures
* for the non-used pages.
*/
off = 0;
while (diff--) {
availrmem--;
off += MMU_PAGESIZE;
}
}
/*
* When printing memory, show the total as physmem less
* that stolen by a debugger.
*/
/*
* For small memory systems disable automatic large pages.
*/
if (physmem < privm_lpg_min_physmem) {
use_brk_lpg = 0;
use_stk_lpg = 0;
}
/*
* Perform platform specific freelist processing
*/
if (&plat_freelist_process) {
}
/*
* Initialize the segkp segment type. We position it
* after the configured tables and buffers (whose end
* is given by econtig) and before V_WKBASE_ADDR.
* Also in this area is segkmap (size SEGMAPSIZE).
*/
/* XXX - cache alignment? */
"segkpsize has been reset to %ld pages", segkpsize);
}
if (segkp_create(segkp) != 0)
/*
* kpm segment
*/
segmap_kpm = kpm_enable &&
if (kpm_enable) {
/*
* The segkpm virtual range range is larger than the
* actual physical memory size and also covers gaps in
* the physical address range for the following reasons:
* . keep conversion between segkpm and physical addresses
* simple, cheap and unambiguous.
* . avoid complexity for handling of virtual addressed
* caches, segkpm and the regular mapping scheme must be
* kept in sync wrt. the virtual color of mapped pages.
* Any accesses to virtual segkpm ranges not backed by
* physical memory will fall through the memseg pfn hash
* and will be handled in segkpm_fault.
* Additional kpm_size spaces needed for vac alias prevention.
*/
segkpm) < 0)
panic("segkpm_create segkpm");
}
/*
* Now create generic mapping segment. This mapping
* goes SEGMAPSIZE beyond SEGMAPBASE. But if the total
* virtual address is greater than the amount of free
* memory that is available, then we trim back the
* segment size to that amount
*/
/*
* 1201049: segkmap base address must be MAXBSIZE aligned
*/
/*
* Set size of segmap to percentage of freemem at boot,
* but stay within the allowable range
* Note we take percentage before converting from pages
* to bytes to avoid an overflow on 32-bit kernels.
*/
if (i < MINMAPSIZE)
i = MINMAPSIZE;
i &= MAXBMASK; /* 1201049: segkmap size must be MAXBSIZE aligned */
a.shmsize = shm_alignment;
a.nfreelist = 0; /* use segmap driver defaults */
panic("segmap_create segkmap");
segdev_init();
}
static void
startup_end(void)
{
panic("memlist overflow 2");
/* enable page_relocation since OBP is now done */
page_relocate_ready = 1;
/*
* Perform tasks that get done after most of the VM
* initialization has been done but before the clock
* and other devices get started.
*/
kern_setup1();
/*
* Intialize the VM arenas for allocating physically
* contiguus memory chunk for interrupt queues snd
* allocate dump buffer for sun4v systems to store
* extra crash information during crash dump
*/
/*
* Initialize interrupt related stuff
*/
(void) splzs(); /* allow hi clock ints but not zs */
/*
* Initialize errors.
*/
error_init();
/*
* Note that we may have already used kernel bcopy before this
* point - but if you really care about this, adb the use_hw_*
* variables to 0 before rebooting.
*/
/*
* Install the "real" preemption guards before DDI services
* are available.
*/
(void) prom_set_preprom(kern_preprom);
(void) prom_set_postprom(kern_postprom);
/*
* Initialize segnf (kernel support for non-faulting loads).
*/
segnf_init();
/*
* Configure the root devinfo node.
*/
configure(); /* set up devices */
}
void
post_startup(void)
{
#ifdef PTL1_PANIC_DEBUG
extern void init_ptl1_thread(void);
#endif /* PTL1_PANIC_DEBUG */
extern void abort_sequence_init(void);
/*
* Set the system wide, processor-specific flags to be passed
* to userland via the aux vector for performance hints and
* instruction set extensions.
*/
bind_hwcap();
/*
* Startup memory scrubber (if any)
*/
/*
* Allocate soft interrupt to handle abort sequence.
*/
/*
* Configure the rest of the system.
*/
/*
* ON4.0: Force /proc module in until clock interrupt handle fixed
*/
/* load machine class specific drivers */
/* load platform specific drivers */
if (&load_platform_drivers)
if (!fpu_exists) {
halt("Can't load vis");
}
mach_fpras();
#ifdef PTL1_PANIC_DEBUG
#endif /* PTL1_PANIC_DEBUG */
if (&cif_init)
cif_init();
}
#ifdef PTL1_PANIC_DEBUG
int ptl1_panic_test = 0;
int ptl1_panic_xc_one_test = 0;
int ptl1_panic_xc_all_test = 0;
int ptl1_panic_xt_one_test = 0;
int ptl1_panic_xt_all_test = 0;
int ptl1_recurse_count_threshold = 0x40;
int ptl1_recurse_trap_threshold = 0x3d;
extern void ptl1_recurse(int, int);
extern void ptl1_panic_xt(int, int);
/*
* Called once per second by timeout() to wake up
* the ptl1_panic thread to see if it should cause
* a trap to the ptl1_panic() code.
*/
/* ARGSUSED */
static void
ptl1_wakeup(void *arg)
{
}
/*
* ptl1_panic cross call function:
* Needed because xc_one() and xc_some() can pass
* 64 bit args but ptl1_recurse() expects ints.
*/
static void
ptl1_panic_xc(void)
{
}
/*
* The ptl1 thread waits for a global flag to be set
* and uses the recurse thresholds to set the stack depth
* to cause a ptl1_panic() directly via a call to ptl1_recurse
* or indirectly via the cross call and cross trap functions.
*
* This is useful testing stack overflows and normal
* ptl1_panic() states with a know stack frame.
*
* ptl1_recurse() is an asm function in ptl1_panic.s that
* sets the {In, Local, Out, and Global} registers to a
* know state on the stack and just prior to causing a
* test ptl1_panic trap.
*/
static void
ptl1_thread(void)
{
while (ptl1_thread_p) {
int cpu_id;
int my_cpu_id;
int target_cpu_id;
int target_found;
if (ptl1_panic_test) {
}
/*
* Find potential targets for x-call and x-trap,
* if any exist while preempt is disabled we
* start a ptl1_panic if requested via a
* globals.
*/
target_found = 0;
if (!CPUSET_ISNULL(other_cpus)) {
/*
* Pick the first one
*/
continue;
if (CPU_XCALL_READY(cpu_id)) {
target_found = 1;
break;
}
}
if (ptl1_panic_xc_one_test) {
(xcfunc_t *)ptl1_panic_xc, 0, 0);
}
if (ptl1_panic_xc_all_test) {
(xcfunc_t *)ptl1_panic_xc, 0, 0);
}
if (ptl1_panic_xt_one_test) {
(xcfunc_t *)ptl1_panic_xt, 0, 0);
}
if (ptl1_panic_xt_all_test) {
(xcfunc_t *)ptl1_panic_xt, 0, 0);
}
}
}
}
/*
* Called during early startup to create the ptl1_thread
*/
void
init_ptl1_thread(void)
{
}
#endif /* PTL1_PANIC_DEBUG */
/*
* Add to a memory list.
* start = start of new memory segment
* len = length of new memory segment in bytes
* memlistp = pointer to array of available memory segment structures
* curmemlistp = memory list to which to add segment.
*/
static void
struct memlist **curmemlistp)
{
}
/*
* In the case of architectures that support dynamic addition of
* memory at run-time there are two cases where memsegs need to
* be initialized and added to the memseg list.
* 1) memsegs that are constructed at startup.
* 2) memsegs that are constructed at run-time on
* hot-plug capable architectures.
* This code was originally part of the function kphysm_init().
*/
static void
{
struct memseg **prev_memsegp;
/* insert in memseg list, decreasing number of pages order */
break;
}
*prev_memsegp = memsegp;
if (kpm_enable) {
if (prev_memsegp != &memsegs) {
} else {
}
}
}
/*
* PSM add_physmem_cb(). US-II and newer processors have some
* flavor of the prefetch capability implemented. We exploit
* this capability for optimum performance.
*/
#define PREFETCH_BYTES 64
void
{
extern void prefetch_page_w(void *);
/*
* Prefetch one more page_t into E$. To prevent future
* mishaps with the sizeof(page_t) changing on us, we
* catch this on debug kernels if we can't bring in the
* entire hpage with 2 PREFETCH_BYTES reads. See
* also, sun4u/cpu/cpu_module.c
*/
/*LINTED*/
prefetch_page_w((char *)pp);
}
/*
* kphysm_init() tackles the problem of initializing physical memory.
* The old startup made some assumptions about the kernel living in
* physically contiguous space which is no longer valid.
*/
static void
{
pfn_t lastseg_pages_end = 0;
pgcnt_t nelem_used = 0;
/*
* Build the memsegs entry
*/
if (kpm_enable) {
if (lastseg_pages_end) {
/*
* Assume phys_avail is in ascending order
* of physical addresses.
*/
if (prev_pend_a > pbase_a) {
/*
* Overlap, more than one memseg may
* point to the same kpm_page range.
*/
if (kpm_smallpages == 0) {
((kpm_page_t *)kpm_pp
+ nelem - 1);
} else {
msp->kpm_spages =
((kpm_spage_t *)kpm_pp
+ nelem - 1);
}
} else {
if (kpm_smallpages == 0) {
(kpm_page_t *)kpm_pp;
((kpm_page_t *)kpm_pp
+ nelem);
} else {
msp->kpm_spages =
(kpm_spage_t *)kpm_pp;
((kpm_spage_t *)
}
nelem_used += nelem;
}
} else {
if (kpm_smallpages == 0) {
} else {
}
nelem_used = nelem;
}
if (nelem_used > kpm_npages)
panic("kphysm_init: kpm_pp overflow\n");
}
/*
* add_physmem() initializes the PSM part of the page
* struct by calling the PSM back with add_physmem_cb().
* In addition it coalesces pages into larger pages as
* it initializes them.
*/
msp++;
}
}
/*
* Kernel VM initialization.
* Assumptions about kernel address space ordering:
* (1) gap (user space)
* (2) kernel text
* (4) gap
* (5) kernel data structures
* (6) gap
* (7) debugger (optional)
* (8) monitor
* (9) gap (possibly null)
* (10) dvma
* (11) devices
*/
static void
kvm_init(void)
{
/*
* Put the kernel segments in kernel address space.
*/
as_avlinit(&kas);
(void) segkmem_create(&ktextseg);
(void) segkmem_create(&ktexthole);
(void) segkmem_create(&kvalloc);
if (kmem64_base) {
(void) segkmem_create(&kmem64);
}
/*
* We're about to map out /boot. This is the beginning of the
* system resource management transition. We can no longer
* call into /boot for I/O or memory allocations.
*/
(void) segkmem_create(&kvseg);
hblk_alloc_dynamic = 1;
/*
* we need to preallocate pages for DR operations before enabling large
* page kernel heap because of memseg_remap_init() hat_unload() hack.
*/
/* at this point we are ready to use large page heap */
&kvseg32);
(void) segkmem_create(&kvseg32);
/*
* Create a segment for the debugger.
*/
&kdebugseg);
(void) segkmem_create(&kdebugseg);
}
char obp_tte_str[] =
"h# %x constant MMU_PAGESHIFT "
"h# %x constant TTE8K "
"h# %x constant SFHME_SIZE "
"h# %x constant SFHME_TTE "
"h# %x constant HMEBLK_TAG "
"h# %x constant HMEBLK_NEXT "
"h# %x constant HMEBLK_MISC "
"h# %x constant HMEBLK_HME1 "
"h# %x constant NHMENTS "
"h# %x constant HBLK_SZMASK "
"h# %x constant HBLK_RANGE_SHIFT "
"h# %x constant HMEBP_HBLK "
"h# %x constant HMEBUCKET_SIZE "
"h# %x constant HTAG_SFMMUPSZ "
"h# %x constant HTAG_REHASHSZ "
"h# %x constant mmu_hashcnt "
"h# %p constant uhme_hash "
"h# %p constant khme_hash "
"h# %x constant UHMEHASH_SZ "
"h# %x constant KHMEHASH_SZ "
"h# %p constant KCONTEXT "
"h# %p constant KHATID "
"h# %x constant ASI_MEM "
": PHYS-X@ ( phys -- data ) "
" ASI_MEM spacex@ "
"; "
": PHYS-W@ ( phys -- data ) "
" ASI_MEM spacew@ "
"; "
": PHYS-L@ ( phys -- data ) "
" ASI_MEM spaceL@ "
"; "
": TTE_PAGE_SHIFT ( ttesz -- hmeshift ) "
" 3 * MMU_PAGESHIFT + "
"; "
": TTE_IS_VALID ( ttep -- flag ) "
" PHYS-X@ 0< "
"; "
": HME_HASH_SHIFT ( ttesz -- hmeshift ) "
" dup TTE8K = if "
" drop HBLK_RANGE_SHIFT "
" else "
" TTE_PAGE_SHIFT "
" then "
"; "
": HME_HASH_BSPAGE ( addr hmeshift -- bspage ) "
" tuck >> swap MMU_PAGESHIFT - << "
"; "
": HME_HASH_FUNCTION ( sfmmup addr hmeshift -- hmebp ) "
" >> over xor swap ( hash sfmmup ) "
" KHATID <> if ( hash ) "
" UHMEHASH_SZ and ( bucket ) "
" HMEBUCKET_SIZE * uhme_hash + ( hmebp ) "
" else ( hash ) "
" KHMEHASH_SZ and ( bucket ) "
" HMEBUCKET_SIZE * khme_hash + ( hmebp ) "
" then ( hmebp ) "
"; "
": HME_HASH_TABLE_SEARCH "
" ( sfmmup hmebp hblktag -- sfmmup null | sfmmup hmeblkp ) "
" >r hmebp_hblk + phys-x@ begin ( sfmmup hmeblkp ) ( r: hblktag ) "
" dup if ( sfmmup hmeblkp ) ( r: hblktag ) "
" dup hmeblk_tag + phys-x@ r@ = if ( sfmmup hmeblkp ) "
" dup hmeblk_tag + 8 + phys-x@ 2 pick = if "
" true ( sfmmup hmeblkp true ) ( r: hblktag ) "
" else "
" hmeblk_next + phys-x@ false "
" ( sfmmup hmeblkp false ) ( r: hblktag ) "
" then "
" else "
" hmeblk_next + phys-x@ false "
" ( sfmmup hmeblkp false ) ( r: hblktag ) "
" then "
" else "
" true "
" then "
" until r> drop "
"; "
": HME_HASH_TAG ( sfmmup rehash addr -- hblktag ) "
" over HME_HASH_SHIFT HME_HASH_BSPAGE ( sfmmup rehash bspage ) "
" HTAG_REHASHSZ << or nip ( hblktag ) "
"; "
": HBLK_TO_TTEP ( hmeblkp addr -- ttep ) "
" over HMEBLK_MISC + PHYS-L@ HBLK_SZMASK and ( hmeblkp addr ttesz ) "
" TTE8K = if ( hmeblkp addr ) "
" MMU_PAGESHIFT >> NHMENTS 1- and ( hmeblkp hme-index ) "
" else ( hmeblkp addr ) "
" drop 0 ( hmeblkp 0 ) "
" then ( hmeblkp hme-index ) "
" SFHME_SIZE * + HMEBLK_HME1 + ( hmep ) "
" SFHME_TTE + ( ttep ) "
"; "
": unix-tte ( addr cnum -- false | tte-data true ) "
" KCONTEXT = if ( addr ) "
" KHATID ( addr khatid ) "
" else ( addr ) "
" drop false exit ( false ) "
" then "
" ( addr khatid ) "
" mmu_hashcnt 1+ 1 do ( addr sfmmup ) "
" 2dup swap i HME_HASH_SHIFT "
"( addr sfmmup sfmmup addr hmeshift ) "
" HME_HASH_FUNCTION ( addr sfmmup hmebp ) "
" over i 4 pick "
"( addr sfmmup hmebp sfmmup rehash addr ) "
" HME_HASH_TAG ( addr sfmmup hmebp hblktag ) "
" HME_HASH_TABLE_SEARCH "
"( addr sfmmup { null | hmeblkp } ) "
" ?dup if ( addr sfmmup hmeblkp ) "
" nip swap HBLK_TO_TTEP ( ttep ) "
" dup TTE_IS_VALID if ( valid-ttep ) "
" PHYS-X@ true ( tte-data true ) "
" else ( invalid-tte ) "
" drop false ( false ) "
" then ( false | tte-data true ) "
" unloop exit ( false | tte-data true ) "
" then ( addr sfmmup ) "
" loop ( addr sfmmup ) "
" 2drop false ( false ) "
"; "
;
void
create_va_to_tte(void)
{
char *bp;
extern int khmehash_num, uhmehash_num;
/*
* Teach obp how to parse our sw ttes.
*/
sizeof (struct sf_hment),
sizeof (struct hmehash_bucket),
ASI_MEM);
prom_interpret(bp, 0, 0, 0, 0, 0);
}
void
install_va_to_tte(void)
{
/*
* advise prom that he can use unix-tte
*/
prom_interpret("' unix-tte is va>tte-data", 0, 0, 0, 0, 0);
}
/*
* Because kmdb links prom_stdout_is_framebuffer into its own
* module, we add "device-type=display" here for /os-io node, so that
* prom_stdout_is_framebuffer still works corrrectly after /os-io node
* is registered into OBP.
*/
static char *create_node =
"\" /\" find-device "
"new-device "
"\" os-io\" device-name "
"\" display\" device-type "
": cb-r/w ( adr,len method$ -- #read/#written ) "
" 2>r swap 2 2r> ['] $callback catch if "
" 2drop 3drop 0 "
" then "
"; "
": read ( adr,len -- #read ) "
" \" read\" ['] cb-r/w catch if 2drop 2drop -2 exit then "
" ( retN ... ret1 N ) "
" ?dup if "
" swap >r 1- 0 ?do drop loop r> "
" else "
" -2 "
" then "
"; "
": write ( adr,len -- #written ) "
" \" write\" ['] cb-r/w catch if 2drop 2drop 0 exit then "
" ( retN ... ret1 N ) "
" ?dup if "
" swap >r 1- 0 ?do drop loop r> "
" else "
" 0 "
" then "
"; "
": poll-tty ( -- ) ; "
": install-abort ( -- ) ['] poll-tty d# 10 alarm ; "
": remove-abort ( -- ) ['] poll-tty 0 alarm ; "
" 0 -rot ['] $callback catch ?dup if "
" >r 2drop 2drop r> throw "
" else "
" 0 ?do drop loop "
" then "
"; "
": open ( -- ok? ) true ; "
": close ( -- ) ; "
"finish-device "
"device-end ";
/*
* It is needed for both USB console keyboard and for
* the kernel terminal emulator. It is too early to check for a
* kernel console compatible framebuffer now, so we create this
* so that we're ready if we need to enable kernel terminal emulation.
*
* When the USB software takes over the input device at the time
* consconfig runs, OBP's stdin is redirected to this node.
* Whenever the FORTH user interface is used after this switch,
* the node will call back into the kernel for console input.
* If a serial device such as ttya or a UART with a Type 5 keyboard
* attached is used, OBP takes over the serial device when the system
* goes to the debugger after the system is booted. This sharing
* of the relatively simple serial device is difficult but possible.
* Sharing the USB host controller is impossible due its complexity.
*
* Similarly to USB keyboard input redirection, after consconfig_dacf
* configures a kernel console framebuffer as the standard output
* device, OBP's stdout is switched to to vector through the
* /os-io node into the kernel terminal emulator.
*/
static void
startup_create_io_node(void)
{
prom_interpret(create_node, 0, 0, 0, 0, 0);
}
static void
do_prom_version_check(void)
{
int i;
char buf[64];
static char drev[] = "Down-rev firmware detected%s\n"
"\tPlease upgrade to the following minimum version:\n"
"\t\t%s\n";
if (i == PROM_VER64_OK)
return;
if (i == PROM_VER64_UPGRADE) {
#ifdef DEBUG
prom_enter_mon(); /* Type 'go' to continue */
return;
#else
halt(0);
#endif
}
/*
* The other possibility is that this is a server running
* good firmware, but down-rev firmware was detected on at
* least one other cpu board. We just complain if we see
* that.
*/
}
static void
kpm_init()
{
}
void
{
/*
* npages can be scattered in a maximum of 'memblocks'
*/
}
/*
* Must be defined in platform dependent code.
*/
extern size_t modtext_sz;
#define HEAPTEXT_ARENA(addr) \
#define HEAPTEXT_OVERSIZED(addr) \
char kern_bootargs[OBP_MAXPATHLEN];
void
{
/*
* Before we initialize the text_arena, we want to punch holes in the
* underlying heaptext_arena. This guarantees that for any text
* address we can find a text hole less than HEAPTEXT_MAPPED away.
*/
}
/*
* Allocate one page at the oversize to break up the text region
* from the oversized region.
*/
heaptext_arena, 0, VM_SLEEP);
}
{
/*
* First, try a sleeping allocation.
*/
return (rval);
/*
* We didn't get the area that we wanted. We're going to try to do an
* allocation with explicit constraints.
*/
VM_NOSLEEP | VM_BESTFIT);
/*
* That worked. Free our first attempt and return.
*/
return (better);
}
/*
* That didn't work; we'll have to return our first attempt.
*/
return (rval);
}
{
char c[30];
if (HEAPTEXT_OVERSIZED(addr)) {
/*
* If this is an oversized allocation, there is no text hole
* available for it; return NULL.
*/
return (NULL);
}
if (arena == 0) {
(void *)(KERNELBASE + MMU_PAGESIZE4M),
0, VM_SLEEP);
} else {
base = HEAPTEXT_BASE +
(void) snprintf(c, sizeof (c),
"heaptext_holesrc_%d", arena);
0, VM_SLEEP);
}
}
VM_BESTFIT | VM_NOSLEEP));
}
void
{
}