vm_machdep.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.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Portions of this source code were derived from Berkeley 4.3 BSD
* under license from the Regents of the University of California.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* UNIX machine dependent virtual memory support.
*/
#include <vm/seg_kmem.h>
#include <sys/vm_machparam.h>
#include <sys/x86_archext.h>
#include <sys/archsystm.h>
#include <sys/machsystm.h>
#include <sys/ddidmareq.h>
int largepagesupport = 0;
extern uint_t page_create_new;
extern uint_t page_create_exists;
extern uint_t page_create_putbacks;
extern uint_t page_create_putbacks;
extern uintptr_t eprom_kernelbase;
/* 4g memory management */
int physmax4g;
int lotsfree4gshift = 3;
/* 16m memory management: desired number of free pages below 16m. */
#ifdef VM_STATS
struct {
} pga_vmstats;
#endif
/* How many page sizes the users can see */
/*
* Number of pages in 1 GB. Don't enable automatic large pages if we have
* fewer than this many pages.
*/
/*
* Maximum and default segment size tunables for user private
* and shared anon memory, and user text and initialized data.
* to be used for mapping application private and shared anon memory.
*/
/*
* Return the optimum page size for a given mapping
*/
/*ARGSUSED*/
{
level_t l = 0;
return (MMU_PAGESIZE);
}
switch (maptype) {
case MAPPGSZ_HEAP:
case MAPPGSZ_STK:
if (max_lpsize == MMU_PAGESIZE) {
return (MMU_PAGESIZE);
}
if (len == 0) {
}
/*
* use the pages size that best fits len
*/
for (l = mmu.max_page_level; l > 0; --l) {
continue;
} else {
pgsz = LEVEL_SIZE(l);
}
break;
}
p->p_stkpageszc);
}
return (pgsz);
/*
* for ISM use the 1st large page size.
*/
case MAPPGSZ_ISM:
if (mmu.max_page_level == 0)
return (MMU_PAGESIZE);
return (LEVEL_SIZE(1));
}
return (pgsz);
}
static uint_t
{
int i;
return (0);
}
for (i = mmu_page_sizes - 1; i > 0; i--) {
pgsz = page_get_pagesize(i);
if (pgsz > max_lpsize) {
continue;
}
continue;
}
continue;
}
/*
* Set szcvec to the remaining page sizes.
*/
break;
}
return (szcvec);
}
/*
* Return a bit vector of large page size codes that
* can be used to map [addr, addr + len) region.
*/
/*ARGSUSED*/
int memcntl)
{
if (mmu.max_page_level == 0)
return (0);
if (!memcntl)
} else if (flags & MAP_INITDATA) {
if (!memcntl)
} else if (type == MAPPGSZC_SHM) {
if (!memcntl)
} else if (type == MAPPGSZC_HEAP) {
if (!memcntl)
} else if (type == MAPPGSZC_STACK) {
if (!memcntl)
} else {
if (!memcntl)
}
}
/*
* Handle a pagefault.
*/
enum fault_type type,
int iskernel)
{
struct proc *p;
kthread_t *t;
int err;
int mapped_red;
if (INVALID_VADDR(addr))
return (FC_NOMAP);
mapped_red = segkp_map_red();
if (iskernel) {
} else {
t = curthread;
p = ttoproc(t);
}
/*
* Dispatch pagefault.
*/
/*
* If this isn't a potential unmapped hole in the user's
* UNIX data or stack segments, just return status info.
*/
goto out;
/*
* Check to see if we happened to faulted on a currently unmapped
* part of the UNIX data or stack segments. If so, create a zfod
* mapping there and then try calling the fault routine again.
*/
/* not in either UNIX data or stack segments */
goto out;
}
}
/*
* the rest of this function implements a 3.X 4.X 5.X compatibility
* This code is probably not needed anymore
*/
if (p->p_model == DATAMODEL_ILP32) {
/* expand the gap to the page boundaries on each side */
0) {
if (err) {
goto out;
}
} else {
/*
* This page is already mapped by another thread after
* we returned from as_fault() above. We just fall
* through as_fault() below.
*/
}
}
out:
if (mapped_red)
return (res);
}
void
{
}
/*ARGSUSED*/
int
{
return (0);
}
/*
* map_addr_proc() is the routine called when the system is to
* choose an address for the user. We will pick an address
* range which is the highest available below kernelbase.
*
* On input it is a hint from the user to be used in a completely
* machine dependent fashion. We decide to completely ignore this hint.
*
* On output it is NULL if no address can be found in the current
* processes address space or else an address that is currently
* not mapped for len bytes with a page of red zone on either side.
*
* align is not needed on x86 (it's for viturally addressed caches)
*/
/*ARGSUSED*/
void
int vacalign,
struct proc *p,
{
#if defined(__amd64)
/*
* XX64 Yes, this needs more work.
*/
if (p->p_model == DATAMODEL_NATIVE) {
/*
* This happens when a program wants to map
* something in a range that's accessible to a
* program in a smaller address space. For example,
* a 64-bit program calling mmap32(2) to guarantee
* that the returned address is below 4Gbytes.
*/
else {
return;
}
} else {
/*
* XX64 This layout is probably wrong .. but in
* the event we make the amd64 address space look
* like sparcv9 i.e. with the stack -above- the
* heap, this bit of code might even be correct.
*/
}
} else
#endif
/*
* Redzone for each side of the request. This is done to leave
* one page unmapped between segments. This is not required, but
* it's useful for the user because if their program strays across
* a segment boundary, it will catch a fault immediately making
* debugging a little easier.
*/
/*
* figure out what the alignment should be
*
* XX64 -- is there an ELF_AMD64_MAXPGSZ or is it the same????
*/
if (len <= ELF_386_MAXPGSZ) {
/*
* Align virtual addresses to ensure that ELF shared libraries
* are mapped with the appropriate alignment constraints by
* the run-time linker.
*/
} else {
int l = mmu.max_page_level;
while (l && len < LEVEL_SIZE(l))
--l;
align_amount = LEVEL_SIZE(l);
}
len += align_amount;
/*
* Look for a large enough hole starting below userlimit.
* After finding it, use the upper part. Addition of PAGESIZE
* is for the redzone as described above.
*/
/*
* Round address DOWN to the alignment amount,
* add the offset, and if this address is less
* than the original address, add alignment amount.
*/
addr += align_amount;
} else {
}
}
/*
* Determine whether [base, base+len] contains a valid range of
* addresses at least minlen long. base and len are adjusted if
* required to provide a valid range.
*/
/*ARGSUSED3*/
int
{
/*
* If hi rolled over the top, try cutting back.
*/
return (0);
return (0);
return (0);
}
#if defined(__amd64)
/*
* Deal with a possible hole in the address range between
* hole_start and hole_end that should never be mapped.
*/
if (lo < hole_start) {
if (hi > hole_start) {
hi = hole_start;
} else {
/* lo < hole_start && hi >= hole_end */
/*
* prefer lowest range
*/
hi = hole_start;
else
return (0);
} else {
/*
* prefer highest range
*/
hi = hole_start;
else
return (0);
}
}
}
} else {
/* lo >= hole_start */
return (0);
}
return (0);
#endif
return (1);
}
/*
* Determine whether [addr, addr+len] are valid user addresses.
*/
/*ARGSUSED*/
int
{
return (RANGE_BADADDR);
#if defined(__amd64)
/*
* Check for the VA hole
*/
return (RANGE_BADADDR);
#endif
return (RANGE_OKAY);
}
/*
* Return 1 if the page frame is onboard memory, else 0.
*/
int
{
}
/*
* initialized by page_coloring_init().
*/
int cpu_page_colors;
/*
* Page freelists and cachelists are dynamically allocated once mnoderangecnt
* and page_colors are calculated from the l2 cache n-way set size. Within a
* mnode range, the page freelist and cachelist are hashed into bins based on
* color. This makes it easier to search for a page within a specific memory
* range.
*/
#define PAGE_COLORS_MIN 16
page_t ****page_freelists;
/*
* As the PC architecture evolved memory up was clumped into several
* ranges for various historical I/O devices to do DMA.
* < 16Meg - ISA bus
* < 2Gig - ???
* < 4Gig - PCI bus or drivers that don't understand PAE mode
*/
0x100000, /* pfn range for 4G and above */
0x80000, /* pfn range for 2G-4G */
0x01000, /* pfn range for 16M-2G */
0x00000, /* pfn range for 0-16M */
};
/*
* These are changed during startup if the machine has limited memory.
*/
int nranges = NUM_MEM_RANGES;
/*
* Used by page layer to know about page sizes
*/
/*
* drivers to use kmem_alloc'd memory on 32 bit systems with > 4Gig RAM.
*/
#if defined(__i386)
int restricted_kmemalloc = 0;
int restricted_kmemalloc = 0;
#endif
/*
* return the memrange containing pfn
*/
int
{
int n;
for (n = 0; n < nranges - 1; ++n) {
break;
}
return (n);
}
/*
* return the mnoderange containing pfn
*/
int
{
int n;
for (n = mnoderangecnt - 1; n >= 0; n--) {
break;
}
}
return (n);
}
/*
* is_contigpage_free:
* returns a page list of contiguous pages. It minimally has to return
* minctg pages. Caller determines minctg based on the scatter-gather
* list length.
*
* pfnp is set to the next page frame to search on return.
*/
static page_t *
int iolock)
{
int i = 0;
/*
* fail if pfn + minctg crosses a segment boundary.
* Adjust for next starting pfn to begin at segment boundary.
*/
return (NULL);
}
do {
(*pfnp)++;
break;
}
goto retry;
}
(*pfnp)++;
break;
}
} else {
}
if (iolock)
/*
* exit loop when pgcnt satisfied or segment boundary reached.
*/
*pfnp += i; /* set to next pfn to search */
if (i >= minctg) {
*pgcnt -= i;
return (plist);
}
/*
* failure: minctg not satisfied.
*
* if next request crosses segment boundary, set next pfn
* to search from the segment boundary.
*/
/* clean up any pages already allocated */
while (plist) {
if (iolock)
}
return (NULL);
}
/*
* verify that pages being returned from allocator have correct DMA attribute
*/
#ifndef DEBUG
#define check_dma(a, b, c) (0)
#else
static void
{
return;
while (cnt-- > 0) {
}
}
#endif
static kmutex_t contig_lock;
static page_t *
{
int sgllen;
static pgcnt_t lastctgcnt;
CONTIG_LOCK();
if (mattr) {
if (align > MMU_PAGESIZE)
/*
* in order to satisfy the request, must minimally
* acquire minctg contiguous pages
*/
/*
* start from where last searched if the minctg >= lastctgcnt
*/
} else {
lo = 0;
sgllen = 1;
if (minctg < lastctgcnt)
}
lastctgcnt = minctg;
/* conserve 16m memory - start search above 16m when possible */
if (pfnalign)
if (plist) {
sgllen--;
/*
* return when contig pages no longer needed
*/
return (pplist);
}
}
if (pfnalign)
}
/* cannot find contig pages in specified range */
return (NULL);
}
/* did not start with lo previously */
if (pfnalign)
/* allow search to go above startpfn */
sgllen--;
/*
* return when contig pages no longer needed
*/
return (pplist);
}
}
if (pfnalign)
}
return (NULL);
}
/*
* combine mem_node_config and memrange memory ranges into one data
* structure to be used for page list management.
*
* mnode_range_cnt() calculates the number of memory ranges for mnode and
* memranges[]. Used to determine the size of page lists and mnoderanges.
*
* mnode_range_setup() initializes mnoderanges.
*/
int mnoderangecnt;
int mtype4g;
int
mnode_range_cnt(int mnode)
{
int mri;
int mnrcnt = 0;
/* find the memranges index below contained in mnode range */
mri--;
/*
* increment mnode range counter when memranges or mnode
* boundary is reached.
*/
while (mri >= 0 &&
mnrcnt++;
mri--;
else
break;
}
}
return (mnrcnt);
}
void
{
continue;
mri--;
MEMRANGELO(mri)) {
mnoderanges++;
mri--;
else
break;
}
}
}
/*
* Determine if the mnode range specified in mtype contains memory belonging
* to memory node mnode. If flags & PGI_MT_RANGE is set then mtype contains
* the range of indices from high pfn to 0, 16m or 4g.
*
* Return first mnode range type index found otherwise return -1 if none found.
*/
int
{
if (flags & PGI_MT_RANGE) {
int mtlim;
if (flags & PGI_MT_NEXT)
mtype--;
if (flags & PGI_MT_RANGE0)
mtlim = 0;
else if (flags & PGI_MT_RANGE4G)
else if (flags & PGI_MT_RANGE16M)
return (mtype);
mtype--;
}
} else {
return (mtype);
}
return (-1);
}
/*
* Update the page list max counts with the pfn range specified by the
* input parameters. Called from add_physmem() when physical memory with
* page_t's are initially added to the page lists.
*/
void
{
int mtype = 0;
} else {
}
}
mtype++;
}
}
/*
* Returns the free page count for mnode
*/
int
mnode_pgcnt(int mnode)
{
int flags = PGI_MT_RANGE0;
while (mtype != -1) {
}
return (pgcnt);
}
/*
* Initialize page coloring variables based on the l2 cache parameters.
* Calculate and return memory needed for page coloring data structures.
*/
{
int i;
int colors;
/*
* Reduce the memory ranges lists if we don't have large amounts
* of memory. This avoids searching known empty free lists.
*/
i = memrange_num(physmax);
memranges += i;
nranges -= i;
#if defined(__i386)
if (i > 0)
restricted_kmemalloc = 0;
#endif
/* physmax greater than 4g */
if (i == 0)
physmax4g = 1;
/* l2_assoc is 0 for fully associative l2 cache */
if (l2_assoc)
else
l2_colors = 1;
/* for scalability, configure at least PAGE_COLORS_MIN color bins */
/*
* cpu_page_colors is non-zero when a page color may be spread across
* multiple bins.
*/
if (l2_colors < page_colors)
/* initialize number of colors per page size */
for (i = 0; i <= mmu.max_page_level; i++) {
+ 1;
}
/*
* The value of cpu_page_colors determines if additional color bins
* need to be checked for a particular color in the page_get routines.
*/
if (cpu_page_colors != 0) {
ASSERT(a > 0);
ASSERT(a < 16);
for (i = 0; i <= mmu.max_page_level; i++) {
colorequivszc[i] = 0;
continue;
}
while ((colors >> a) == 0)
a--;
ASSERT(a >= 0);
/* higher 4 bits encodes color equiv mask */
colorequivszc[i] = (a << 4);
}
}
/* factor in colorequiv to check additional 'equivalent' bins. */
if (colorequiv > 1) {
if (a > 15)
a = 15;
for (i = 0; i <= mmu.max_page_level; i++) {
continue;
}
while ((colors >> a) == 0)
a--;
if ((a << 4) > colorequivszc[i]) {
colorequivszc[i] = (a << 4);
}
}
}
/* size for mnoderanges */
for (mnoderangecnt = 0, i = 0; i < max_mem_nodes; i++)
mnoderangecnt += mnode_range_cnt(i);
/* size for fpc_mutex and cpc_mutex */
/* size of page_freelists */
for (i = 0; i < mmu_page_sizes; i++) {
colors = page_get_pagecolors(i);
}
/* size of page_cachelists */
return (colorsz);
}
/*
* Called once at startup to configure page_coloring data structures and
* does the 1st page_free()/page_freelist_add().
*/
void
{
int i;
int j;
int k;
int colors;
/*
* do page coloring setup
*/
if (physmax4g)
for (k = 0; k < NPC_MUTEX; k++) {
}
for (k = 0; k < NPC_MUTEX; k++) {
}
for (i = 0; i < mnoderangecnt; i++) {
for (j = 0; j < mmu_page_sizes; j++) {
colors = page_get_pagecolors(j);
}
}
}
/*ARGSUSED*/
int
{
return (0);
}
/*
* get a page from any list with the given mnode
*/
page_t *
{
int i;
int mtypestart;
int plw_initialized;
if (mtype < 0) {
return (NULL);
}
mtypestart = mtype;
/*
* check up to page_colors + 1 bins - origbin may be checked twice
* because of BIN_STEP skip
*/
do {
plw_initialized = 0;
goto nextfreebin;
}
continue;
}
/* check if page within DMA attributes */
dma_attr->dma_attr_addr_hi)) {
break;
}
/* continue looking */
}
/* found a page with specified DMA attributes */
(void *)pp);
}
return (pp);
}
if (plw_initialized == 0) {
plw_initialized = 1;
}
if (plw.plw_do_split) {
&plw);
return (pp);
}
}
} while (mtype >= 0);
/* failed to find a page in the freelist; try it in the cachelist */
/* reset mtype start for cachelist search */
mtype = mtypestart;
/* start with the bin of matching color */
do {
for (i = 0; i <= page_colors; i++) {
goto nextcachebin;
break;
continue;
}
/* check if page within DMA attributes */
dma_attr->dma_attr_addr_hi)) {
break;
}
/* continue looking */
}
/* found a page with specified DMA attributes */
return (pp);
}
bin &= page_colors_mask;
}
} while (mtype >= 0);
return (NULL);
}
/*
* This function is similar to page_get_freelist()/page_get_cachelist()
* but it searches both the lists to find a page with the specified
* color (or no color) and DMA attributes. The search is done in the
* freelist first and then in the cache list within the highest memory
* range (based on DMA attributes) before searching in the lower
* memory ranges.
*
* Note: This function is called only by page_create_io().
*/
/*ARGSUSED*/
page_t *
{
int mtype;
int n;
int m;
int szc;
int fullrange;
int mnode;
int local_failed_stat = 0;
/* only base pagesize currently supported */
if (size != MMU_PAGESIZE)
return (NULL);
/*
* If we're passed a specific lgroup, we use it. Otherwise,
* assume first-touch placement is desired.
*/
if (!LGRP_EXISTS(lgrp))
lgrp = lgrp_home_lgrp();
/* LINTED */
/*
* Only hold one freelist or cachelist lock at a time, that way we
* can start anywhere and not have to worry about lock
* ordering.
*/
n = 0;
m = mnoderangecnt - 1;
fullrange = 1;
} else {
/*
* We can guarantee alignment only for page boundary.
*/
return (NULL);
n = pfn_2_mtype(pfnlo);
m = pfn_2_mtype(pfnhi);
}
if (n > m)
return (NULL);
szc = 0;
/* cylcing thru mtype handled by RANGE0 if n == 0 */
if (n == 0) {
flags |= PGI_MT_RANGE0;
n = m;
}
/*
* Try local memory node first, but try remote if we can't
* get a page of the right color.
*/
/*
* allocate pages from high pfn to low.
*/
if (fullrange != 0) {
}
} else {
}
return (pp);
}
}
if (!local_failed_stat) {
local_failed_stat = 1;
}
}
return (NULL);
}
/*
* page_create_io()
*
* This function is a copy of page_create_va() with an additional
* argument 'mattr' that specifies DMA memory requirements to
* the page list functions. This function is used by the segkmem
* allocator so it is only to create new pages (i.e PG_EXCL is
* set).
*
* Note: This interface is currently used by x86 PSM only and is
* not fully specified so the commitment level is only for
* private interface specific to x86. This interface uses PSM
* specific page_get_anylist() interface.
*/
break; \
} \
}
page_t *
{
"page_create_start:vp %p off %llx bytes %u flags %x",
/*
* Do the freemem and pcf accounting.
*/
return (NULL);
}
"page_create_success:vp %p off %llx",
/*
* If satisfying this request has left us with too little
* memory, start the wheels turning to get some back. The
* first clause of the test prevents waking up the pageout
* daemon in situations where it would decide that there's
* nothing to do.
*/
"pageout_cv_signal:freemem %ld", freemem);
}
if (flags & PG_PHYSCONTIG) {
return (NULL);
}
do {
panic("pg_creat_io: hashin failed %p %p %llx",
}
off += MMU_PAGESIZE;
PP_CLRFREE(pp);
PP_CLRAGED(pp);
if (!npages) {
return (plist);
} else {
}
/*
* fall-thru:
*
* page_get_contigpage returns when npages <= sgllen.
* Grab the rest of the non-contig pages below from anylist.
*/
}
/*
* Loop around collecting the requested number of pages.
* Most of the time, we have to `create' a new page. With
* this in mind, pull the page off the free list before
* getting the hash lock. This will minimize the hash
* lock hold time, nesting, and the like. If it turns
* out we don't need the page, we put it back at the end.
*/
while (npages--) {
top:
/*
* Try to get the page of any color either from
* the freelist or from the cache list.
*/
/*
* Not looking for a special page;
* panic!
*/
}
/*
* No page found! This can happen
* if we are looking for a page
* within a specific memory range
* for DMA purposes. If PG_WAIT is
* specified then we wait for a
* while and then try again. The
* wait could be forever if we
* don't get the page(s) we need.
*
* Note: XXX We really need a mechanism
* to wait for pages in the desired
* range. For now, we wait for any
* pages and see if we can use it.
*/
delay(10);
goto top;
}
goto fail; /* undo accounting stuff */
}
/*
* Since this page came from the
* cachelist, we must destroy the
* old vnode association.
*/
}
}
/*
* We own this page!
*/
/*
* Here we have a page in our hot little mits and are
* just waiting to stuff it on the appropriate lists.
* Get the mutex and check to see if it really does
* not exist.
*/
/*
* Since we hold the page hash mutex and
* just searched for this page, page_hashin
* had better not fail. If it does, that
* means somethread did not follow the
* page hash mutex rules. Panic now and
* get it over with. As usual, go down
* holding all the locks.
*/
panic("page_create: hashin fail %p %p %llx %p",
}
/*
* Hat layer locking need not be done to set
* the following bits since the page is not hashed
* and was on the free list (i.e., had no mappings).
*
* Set the reference bit to protect
* against immediate pageout
*
* XXXmh modify freelist code to set reference
* bit so we don't have to do it here.
*/
} else {
/*
* NOTE: This should not happen for pages associated
* with kernel vnode 'kvp'.
*/
/* XX64 - to debug why this happens! */
"page_create: page not expected "
"in hash list for kernel vnode - pp 0x%p",
(void *)pp);
goto fail;
}
/*
* Got a page! It is locked. Acquire the i/o
* lock since we are going to use the p_next and
* p_prev fields to link the requested pages together.
*/
off += MMU_PAGESIZE;
vaddr += MMU_PAGESIZE;
}
return (plist);
fail:
/*
* Did not need this page after all.
* Put it back on the free list.
*/
}
/*
* Give up the pages we already got.
*/
plist_len++;
/*LINTED: constant in conditional ctx*/
}
/*
* VN_DISPOSE does freemem accounting for the pages in plist
* by calling page_free. So, we need to undo the pcf accounting
* for only the remaining pages.
*/
return (NULL);
}
/*
* Copy the data from the physical page represented by "frompp" to
* that represented by "topp". ppcopy uses CPU->cpu_caddr1 and
* CPU->cpu_caddr2. It assumes that no one uses either map at interrupt
* level and no one sleeps with an active mapping there.
*
* this operation, hence it is up to the caller to update them appropriately.
*/
void
{
void *pte1;
void *pte2;
if (kpm_enable) {
} else {
/*
* disable pre-emption so that CPU can't change
*/
}
if (use_sse_pagecopy)
else
if (!kpm_enable)
}
/*
* Zero the physical page from off to off + len given by `pp'
* without changing the reference and modified bits of page.
*
* We use this using CPU private page address #2, see ppcopy() for more info.
* pagezero() must not be called at interrupt level.
*/
void
{
void *pte2;
if (kpm_enable) {
} else {
}
if (use_sse_pagezero)
else
if (!kpm_enable)
}
/*
* Platform-dependent page scrub call.
*/
void
{
/*
* For now, we rely on the fact that pagezero() will
* always clear UEs.
*/
}
/*
* set up two private addresses for use on a given CPU for use in ppcopy()
*/
void
{
void *addr;
void *pte;
}
/*
* Create the pageout scanner thread. The thread has to
* start at procedure with process pp and priority pri.
*/
void
{
}
/*
* Function for flushing D-cache when performing module relocations
* to an alternate mapping. Unnecessary on Intel / AMD platforms.
*/
void
{}