[apple/xnu.git] / osfmk / i386 / pmap_common.c

/*
 * Copyright (c) 2000-2016 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
#include <vm/pmap.h>
#include <kern/ledger.h>
#include <i386/pmap_internal.h>


/*
 *	Each entry in the pv_head_table is locked by a bit in the
 *	pv_lock_table.  The lock bits are accessed by the physical
 *	address of the page they lock.
 */

char	*pv_lock_table;		/* pointer to array of bits */
char    *pv_hash_lock_table;

pv_rooted_entry_t	pv_head_table;		/* array of entries, one per
						 * page */
uint32_t			pv_hashed_free_count = 0;
uint32_t			pv_hashed_kern_free_count = 0;

pmap_pagetable_corruption_record_t pmap_pagetable_corruption_records[PMAP_PAGETABLE_CORRUPTION_MAX_LOG];
uint32_t pmap_pagetable_corruption_incidents;
uint64_t pmap_pagetable_corruption_last_abstime = (~(0ULL) >> 1);
uint64_t pmap_pagetable_corruption_interval_abstime;
thread_call_t 	pmap_pagetable_corruption_log_call;
static thread_call_data_t 	pmap_pagetable_corruption_log_call_data;
boolean_t pmap_pagetable_corruption_timeout = FALSE;

volatile uint32_t	mappingrecurse = 0;

uint32_t  pv_hashed_low_water_mark, pv_hashed_kern_low_water_mark, pv_hashed_alloc_chunk, pv_hashed_kern_alloc_chunk;

thread_t mapping_replenish_thread;
event_t	mapping_replenish_event, pmap_user_pv_throttle_event;

uint64_t pmap_pv_throttle_stat, pmap_pv_throttled_waiters;

int pmap_asserts_enabled = (DEBUG);
int pmap_asserts_traced = 0;

unsigned int pmap_cache_attributes(ppnum_t pn) {
	if (pmap_get_cache_attributes(pn, FALSE) & INTEL_PTE_NCACHE)
	        return (VM_WIMG_IO);
	else
		return (VM_WIMG_COPYBACK);
}

void	pmap_set_cache_attributes(ppnum_t pn, unsigned int cacheattr) {
	unsigned int current, template = 0;
	int pai;

	if (cacheattr & VM_MEM_NOT_CACHEABLE) {
		if(!(cacheattr & VM_MEM_GUARDED))
			template |= PHYS_PTA;
		template |= PHYS_NCACHE;
	}

	pmap_intr_assert();

	assert((pn != vm_page_fictitious_addr) && (pn != vm_page_guard_addr));

	pai = ppn_to_pai(pn);

	if (!IS_MANAGED_PAGE(pai)) {
		return;
	}

	/* override cache attributes for this phys page
	 * Does not walk through existing mappings to adjust,
	 * assumes page is disconnected
	 */

	LOCK_PVH(pai);

	pmap_update_cache_attributes_locked(pn, template);

	current = pmap_phys_attributes[pai] & PHYS_CACHEABILITY_MASK;
	pmap_phys_attributes[pai] &= ~PHYS_CACHEABILITY_MASK;
	pmap_phys_attributes[pai] |= template;

	UNLOCK_PVH(pai);

	if ((template & PHYS_NCACHE) && !(current & PHYS_NCACHE)) {
		pmap_sync_page_attributes_phys(pn);
	}
}

unsigned	pmap_get_cache_attributes(ppnum_t pn, boolean_t is_ept) {
	if (last_managed_page == 0)
		return 0;

	if (!IS_MANAGED_PAGE(ppn_to_pai(pn)))
	    return PTE_NCACHE(is_ept);

	/*
	 * The cache attributes are read locklessly for efficiency.
	 */
	unsigned int attr = pmap_phys_attributes[ppn_to_pai(pn)];
	unsigned int template = 0;

	/*
	 * The PTA bit is currently unsupported for EPT PTEs.
	 */
	if ((attr & PHYS_PTA) && !is_ept)
		template |= INTEL_PTE_PTA;

	/*
	 * If the page isn't marked as NCACHE, the default for EPT entries
	 * is WB.
	 */
	if (attr & PHYS_NCACHE)
		template |= PTE_NCACHE(is_ept);
	else if (is_ept)
		template |= INTEL_EPT_WB;

	return template;
}

boolean_t 
pmap_has_managed_page(ppnum_t first, ppnum_t last)
{
	ppnum_t     pn, kdata_start, kdata_end;
	boolean_t   result;
	boot_args * args;

	args        = (boot_args *) PE_state.bootArgs;

	// Allow pages that the booter added to the end of the kernel.
	// We may miss reporting some pages in this range that were freed
	// with ml_static_free()
	kdata_start = atop_32(args->kaddr);
	kdata_end   = atop_32(args->kaddr + args->ksize);

    assert(last_managed_page);
    assert(first <= last);

    for (result = FALSE, pn = first; 
    	!result 
    	  && (pn <= last)
    	  && (pn <= last_managed_page); 
    	 pn++)
    {
		if ((pn >= kdata_start) && (pn < kdata_end)) continue;
    	result = (0 != (pmap_phys_attributes[pn] & PHYS_MANAGED));
    }

	return (result);
}

boolean_t
pmap_is_noencrypt(ppnum_t pn)
{
	int		pai;

	pai = ppn_to_pai(pn);

	if (!IS_MANAGED_PAGE(pai))
		return (FALSE);

	if (pmap_phys_attributes[pai] & PHYS_NOENCRYPT)
		return (TRUE);

	return (FALSE);
}


void
pmap_set_noencrypt(ppnum_t pn)
{
	int		pai;

	pai = ppn_to_pai(pn);

	if (IS_MANAGED_PAGE(pai)) {
		LOCK_PVH(pai);

		pmap_phys_attributes[pai] |= PHYS_NOENCRYPT;

		UNLOCK_PVH(pai);
	}
}


void
pmap_clear_noencrypt(ppnum_t pn)
{
	int		pai;

	pai = ppn_to_pai(pn);

	if (IS_MANAGED_PAGE(pai)) {
		/*
		 * synchronization at VM layer prevents PHYS_NOENCRYPT
		 * from changing state, so we don't need the lock to inspect
		 */
		if (pmap_phys_attributes[pai] & PHYS_NOENCRYPT) {
			LOCK_PVH(pai);

			pmap_phys_attributes[pai] &= ~PHYS_NOENCRYPT;

			UNLOCK_PVH(pai);
		}
	}
}

void
compute_pmap_gc_throttle(void *arg __unused)
{
	
}


void
pmap_lock_phys_page(ppnum_t pn)
{
	int		pai;

	pai = ppn_to_pai(pn);

	if (IS_MANAGED_PAGE(pai)) {
		LOCK_PVH(pai);
	} else
		simple_lock(&phys_backup_lock);
}


void
pmap_unlock_phys_page(ppnum_t pn)
{
	int		pai;

	pai = ppn_to_pai(pn);

	if (IS_MANAGED_PAGE(pai)) {
		UNLOCK_PVH(pai);
	} else
		simple_unlock(&phys_backup_lock);
}


__private_extern__ void
pmap_pagetable_corruption_msg_log(int (*log_func)(const char * fmt, ...)__printflike(1,2)) {
	if (pmap_pagetable_corruption_incidents > 0) {
		int i, e = MIN(pmap_pagetable_corruption_incidents, PMAP_PAGETABLE_CORRUPTION_MAX_LOG);
		(*log_func)("%u pagetable corruption incident(s) detected, timeout: %u\n", pmap_pagetable_corruption_incidents, pmap_pagetable_corruption_timeout);
		for (i = 0; i < e; i++) {
			(*log_func)("Incident 0x%x, reason: 0x%x, action: 0x%x, time: 0x%llx\n", pmap_pagetable_corruption_records[i].incident,  pmap_pagetable_corruption_records[i].reason, pmap_pagetable_corruption_records[i].action, pmap_pagetable_corruption_records[i].abstime);
		}
	}
}

static inline void
pmap_pagetable_corruption_log_setup(void) {
	if (pmap_pagetable_corruption_log_call == NULL) {
		nanotime_to_absolutetime(PMAP_PAGETABLE_CORRUPTION_INTERVAL, 0, &pmap_pagetable_corruption_interval_abstime);
		thread_call_setup(&pmap_pagetable_corruption_log_call_data,
		    (thread_call_func_t) pmap_pagetable_corruption_msg_log,
		    (thread_call_param_t) &printf);
		pmap_pagetable_corruption_log_call = &pmap_pagetable_corruption_log_call_data;
	}
}

void
mapping_free_prime(void)
{
	unsigned		i;
	pv_hashed_entry_t	pvh_e;
	pv_hashed_entry_t	pvh_eh;
	pv_hashed_entry_t	pvh_et;
	int			pv_cnt;

	/* Scale based on DRAM size */
	pv_hashed_low_water_mark = MAX(PV_HASHED_LOW_WATER_MARK_DEFAULT, ((uint32_t)(sane_size >> 30)) * 2000);
	pv_hashed_low_water_mark = MIN(pv_hashed_low_water_mark, 16000);
	/* Alterable via sysctl */
	pv_hashed_kern_low_water_mark = MAX(PV_HASHED_KERN_LOW_WATER_MARK_DEFAULT, ((uint32_t)(sane_size >> 30)) * 1000);
	pv_hashed_kern_low_water_mark = MIN(pv_hashed_kern_low_water_mark, 16000);
	pv_hashed_kern_alloc_chunk = PV_HASHED_KERN_ALLOC_CHUNK_INITIAL;
	pv_hashed_alloc_chunk = PV_HASHED_ALLOC_CHUNK_INITIAL;

	pv_cnt = 0;
	pvh_eh = pvh_et = PV_HASHED_ENTRY_NULL;

	for (i = 0; i < (5 * PV_HASHED_ALLOC_CHUNK_INITIAL); i++) {
		pvh_e = (pv_hashed_entry_t) zalloc(pv_hashed_list_zone);

		pvh_e->qlink.next = (queue_entry_t)pvh_eh;
		pvh_eh = pvh_e;

		if (pvh_et == PV_HASHED_ENTRY_NULL)
		        pvh_et = pvh_e;
		pv_cnt++;
	}
	PV_HASHED_FREE_LIST(pvh_eh, pvh_et, pv_cnt);

	pv_cnt = 0;
	pvh_eh = pvh_et = PV_HASHED_ENTRY_NULL;
	for (i = 0; i < PV_HASHED_KERN_ALLOC_CHUNK_INITIAL; i++) {
		pvh_e = (pv_hashed_entry_t) zalloc(pv_hashed_list_zone);

		pvh_e->qlink.next = (queue_entry_t)pvh_eh;
		pvh_eh = pvh_e;

		if (pvh_et == PV_HASHED_ENTRY_NULL)
		        pvh_et = pvh_e;
		pv_cnt++;
	}
	PV_HASHED_KERN_FREE_LIST(pvh_eh, pvh_et, pv_cnt);
}

void mapping_replenish(void);

void mapping_adjust(void) {
	kern_return_t mres;

	pmap_pagetable_corruption_log_setup();

	mres = kernel_thread_start_priority((thread_continue_t)mapping_replenish, NULL, MAXPRI_KERNEL, &mapping_replenish_thread);
	if (mres != KERN_SUCCESS) {
		panic("pmap: mapping_replenish_thread creation failed");
	}
	thread_deallocate(mapping_replenish_thread);
}

unsigned pmap_mapping_thread_wakeups;	
unsigned pmap_kernel_reserve_replenish_stat;
unsigned pmap_user_reserve_replenish_stat;
unsigned pmap_kern_reserve_alloc_stat;

__attribute__((noreturn))
void
mapping_replenish(void)
{
	pv_hashed_entry_t	pvh_e;
	pv_hashed_entry_t	pvh_eh;
	pv_hashed_entry_t	pvh_et;
	int			pv_cnt;
	unsigned             	i;

	/* We qualify for VM privileges...*/
	current_thread()->options |= TH_OPT_VMPRIV;

	for (;;) {

		while (pv_hashed_kern_free_count < pv_hashed_kern_low_water_mark) {
			pv_cnt = 0;
			pvh_eh = pvh_et = PV_HASHED_ENTRY_NULL;

			for (i = 0; i < pv_hashed_kern_alloc_chunk; i++) {
				pvh_e = (pv_hashed_entry_t) zalloc(pv_hashed_list_zone);
				pvh_e->qlink.next = (queue_entry_t)pvh_eh;
				pvh_eh = pvh_e;

				if (pvh_et == PV_HASHED_ENTRY_NULL)
					pvh_et = pvh_e;
				pv_cnt++;
			}
			pmap_kernel_reserve_replenish_stat += pv_cnt;
			PV_HASHED_KERN_FREE_LIST(pvh_eh, pvh_et, pv_cnt);
		}

		pv_cnt = 0;
		pvh_eh = pvh_et = PV_HASHED_ENTRY_NULL;

		if (pv_hashed_free_count < pv_hashed_low_water_mark) {
			for (i = 0; i < pv_hashed_alloc_chunk; i++) {
				pvh_e = (pv_hashed_entry_t) zalloc(pv_hashed_list_zone);

				pvh_e->qlink.next = (queue_entry_t)pvh_eh;
				pvh_eh = pvh_e;

				if (pvh_et == PV_HASHED_ENTRY_NULL)
					pvh_et = pvh_e;
				pv_cnt++;
			}
			pmap_user_reserve_replenish_stat += pv_cnt;
			PV_HASHED_FREE_LIST(pvh_eh, pvh_et, pv_cnt);
		}
/* Wake threads throttled while the kernel reserve was being replenished.
 */
		if (pmap_pv_throttled_waiters) {
			pmap_pv_throttled_waiters = 0;
			thread_wakeup(&pmap_user_pv_throttle_event);
		}
		/* Check if the kernel pool has been depleted since the
		 * first pass, to reduce refill latency.
		 */
		if (pv_hashed_kern_free_count < pv_hashed_kern_low_water_mark)
			continue;
		/* Block sans continuation to avoid yielding kernel stack */
		assert_wait(&mapping_replenish_event, THREAD_UNINT);
		mappingrecurse = 0;
		thread_block(THREAD_CONTINUE_NULL);
		pmap_mapping_thread_wakeups++;
	}
}

/*
 *	Set specified attribute bits.
 */

void
phys_attribute_set(
	ppnum_t		pn,
	int		bits)
{
	int		pai;

	pmap_intr_assert();
	assert(pn != vm_page_fictitious_addr);
	if (pn == vm_page_guard_addr)
		return;

	pai = ppn_to_pai(pn);

	if (!IS_MANAGED_PAGE(pai)) {
		/* Not a managed page.  */
		return;
	}

	LOCK_PVH(pai);
	pmap_phys_attributes[pai] |= bits;
	UNLOCK_PVH(pai);
}

/*
 *	Set the modify bit on the specified physical page.
 */

void
pmap_set_modify(ppnum_t pn)
{
	phys_attribute_set(pn, PHYS_MODIFIED);
}

/*
 *	Clear the modify bits on the specified physical page.
 */

void
pmap_clear_modify(ppnum_t pn)
{
	phys_attribute_clear(pn, PHYS_MODIFIED, 0, NULL);
}

/*
 *	pmap_is_modified:
 *
 *	Return whether or not the specified physical page is modified
 *	by any physical maps.
 */

boolean_t
pmap_is_modified(ppnum_t pn)
{
	if (phys_attribute_test(pn, PHYS_MODIFIED))
		return TRUE;
	return FALSE;
}


/*
 *	pmap_clear_reference:
 *
 *	Clear the reference bit on the specified physical page.
 */

void
pmap_clear_reference(ppnum_t pn)
{
	phys_attribute_clear(pn, PHYS_REFERENCED, 0, NULL);
}

void
pmap_set_reference(ppnum_t pn)
{
	phys_attribute_set(pn, PHYS_REFERENCED);
}

/*
 *	pmap_is_referenced:
 *
 *	Return whether or not the specified physical page is referenced
 *	by any physical maps.
 */

boolean_t
pmap_is_referenced(ppnum_t pn)
{
        if (phys_attribute_test(pn, PHYS_REFERENCED))
		return TRUE;
	return FALSE;
}


/*
 * pmap_get_refmod(phys)
 *  returns the referenced and modified bits of the specified
 *  physical page.
 */
unsigned int
pmap_get_refmod(ppnum_t pn)
{
        int		refmod;
	unsigned int	retval = 0;

	refmod = phys_attribute_test(pn, PHYS_MODIFIED | PHYS_REFERENCED);

	if (refmod & PHYS_MODIFIED)
	        retval |= VM_MEM_MODIFIED;
	if (refmod & PHYS_REFERENCED)
	        retval |= VM_MEM_REFERENCED;

	return (retval);
}


void
pmap_clear_refmod_options(ppnum_t pn, unsigned int mask, unsigned int options, void *arg)
{
        unsigned int  x86Mask;

        x86Mask = (   ((mask &   VM_MEM_MODIFIED)?   PHYS_MODIFIED : 0)
		      | ((mask & VM_MEM_REFERENCED)? PHYS_REFERENCED : 0));

        phys_attribute_clear(pn, x86Mask, options, arg);
}

/*
 * pmap_clear_refmod(phys, mask)
 *  clears the referenced and modified bits as specified by the mask
 *  of the specified physical page.
 */
void
pmap_clear_refmod(ppnum_t pn, unsigned int mask)
{
	unsigned int  x86Mask;

	x86Mask = (   ((mask &   VM_MEM_MODIFIED)?   PHYS_MODIFIED : 0)
	            | ((mask & VM_MEM_REFERENCED)? PHYS_REFERENCED : 0));

	phys_attribute_clear(pn, x86Mask, 0, NULL);
}

unsigned int
pmap_disconnect(ppnum_t pa)
{
	return (pmap_disconnect_options(pa, 0, NULL));
}

/*
 *	Routine:
 *		pmap_disconnect_options
 *
 *	Function:
 *		Disconnect all mappings for this page and return reference and change status
 *		in generic format.
 *
 */
unsigned int
pmap_disconnect_options(ppnum_t pa, unsigned int options, void *arg)
{
	unsigned refmod, vmrefmod = 0;

	pmap_page_protect_options(pa, 0, options, arg);		/* disconnect the page */

	pmap_assert(pa != vm_page_fictitious_addr);
	if ((pa == vm_page_guard_addr) || !IS_MANAGED_PAGE(pa) || (options & PMAP_OPTIONS_NOREFMOD))
		return 0;
	refmod = pmap_phys_attributes[pa] & (PHYS_MODIFIED | PHYS_REFERENCED);
	
	if (refmod & PHYS_MODIFIED)
	        vmrefmod |= VM_MEM_MODIFIED;
	if (refmod & PHYS_REFERENCED)
	        vmrefmod |= VM_MEM_REFERENCED;

	return vmrefmod;
}
Commit	Line	Data
6d2010ae	1	/*
39037602	2	* Copyright (c) 2000-2016 Apple Inc. All rights reserved.
6d2010ae A	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28	#include <vm/pmap.h>
316670eb	29	#include <kern/ledger.h>
6d2010ae A	30	#include <i386/pmap_internal.h>
6d2010ae A	31
316670eb	32
6d2010ae A	33	/*
	34	* Each entry in the pv_head_table is locked by a bit in the
	35	* pv_lock_table. The lock bits are accessed by the physical
	36	* address of the page they lock.
	37	*/
	38
	39	char pv_lock_table; / pointer to array of bits */
	40	char *pv_hash_lock_table;
	41
	42	pv_rooted_entry_t pv_head_table; /* array of entries, one per
	43	* page */
	44	uint32_t pv_hashed_free_count = 0;
	45	uint32_t pv_hashed_kern_free_count = 0;
	46
	47	pmap_pagetable_corruption_record_t pmap_pagetable_corruption_records[PMAP_PAGETABLE_CORRUPTION_MAX_LOG];
	48	uint32_t pmap_pagetable_corruption_incidents;
	49	uint64_t pmap_pagetable_corruption_last_abstime = (~(0ULL) >> 1);
	50	uint64_t pmap_pagetable_corruption_interval_abstime;
	51	thread_call_t pmap_pagetable_corruption_log_call;
	52	static thread_call_data_t pmap_pagetable_corruption_log_call_data;
	53	boolean_t pmap_pagetable_corruption_timeout = FALSE;
	54
	55	volatile uint32_t mappingrecurse = 0;
	56
	57	uint32_t pv_hashed_low_water_mark, pv_hashed_kern_low_water_mark, pv_hashed_alloc_chunk, pv_hashed_kern_alloc_chunk;
	58
	59	thread_t mapping_replenish_thread;
	60	event_t mapping_replenish_event, pmap_user_pv_throttle_event;
	61
	62	uint64_t pmap_pv_throttle_stat, pmap_pv_throttled_waiters;
	63
5c9f4661	64	int pmap_asserts_enabled = (DEBUG);
39037602 A	65	int pmap_asserts_traced = 0;
39037602 A	66
6d2010ae	67	unsigned int pmap_cache_attributes(ppnum_t pn) {
3e170ce0	68	if (pmap_get_cache_attributes(pn, FALSE) & INTEL_PTE_NCACHE)
6d2010ae A	69	return (VM_WIMG_IO);
	70	else
	71	return (VM_WIMG_COPYBACK);
	72	}
	73
	74	void pmap_set_cache_attributes(ppnum_t pn, unsigned int cacheattr) {
	75	unsigned int current, template = 0;
	76	int pai;
	77
	78	if (cacheattr & VM_MEM_NOT_CACHEABLE) {
	79	if(!(cacheattr & VM_MEM_GUARDED))
	80	template \|= PHYS_PTA;
	81	template \|= PHYS_NCACHE;
	82	}
	83
	84	pmap_intr_assert();
	85
	86	assert((pn != vm_page_fictitious_addr) && (pn != vm_page_guard_addr));
	87
	88	pai = ppn_to_pai(pn);
	89
	90	if (!IS_MANAGED_PAGE(pai)) {
	91	return;
	92	}
	93
	94	/* override cache attributes for this phys page
	95	* Does not walk through existing mappings to adjust,
	96	* assumes page is disconnected
	97	*/
	98
	99	LOCK_PVH(pai);
	100
	101	pmap_update_cache_attributes_locked(pn, template);
	102
	103	current = pmap_phys_attributes[pai] & PHYS_CACHEABILITY_MASK;
	104	pmap_phys_attributes[pai] &= ~PHYS_CACHEABILITY_MASK;
	105	pmap_phys_attributes[pai] \|= template;
	106
	107	UNLOCK_PVH(pai);
	108
	109	if ((template & PHYS_NCACHE) && !(current & PHYS_NCACHE)) {
	110	pmap_sync_page_attributes_phys(pn);
	111	}
	112	}
	113
3e170ce0	114	unsigned pmap_get_cache_attributes(ppnum_t pn, boolean_t is_ept) {
6d2010ae A	115	if (last_managed_page == 0)
	116	return 0;
	117
3e170ce0 A	118	if (!IS_MANAGED_PAGE(ppn_to_pai(pn)))
3e170ce0 A	119	return PTE_NCACHE(is_ept);
6d2010ae A	120
	121	/*
	122	* The cache attributes are read locklessly for efficiency.
	123	*/
	124	unsigned int attr = pmap_phys_attributes[ppn_to_pai(pn)];
	125	unsigned int template = 0;
3e170ce0 A	126
	127	/*
	128	* The PTA bit is currently unsupported for EPT PTEs.
	129	*/
	130	if ((attr & PHYS_PTA) && !is_ept)
6d2010ae	131	template \|= INTEL_PTE_PTA;
3e170ce0 A	132
	133	/*
	134	* If the page isn't marked as NCACHE, the default for EPT entries
	135	* is WB.
	136	*/
6d2010ae	137	if (attr & PHYS_NCACHE)
3e170ce0 A	138	template \|= PTE_NCACHE(is_ept);
	139	else if (is_ept)
	140	template \|= INTEL_EPT_WB;
	141
6d2010ae A	142	return template;
	143	}
	144
3e170ce0 A	145	boolean_t
	146	pmap_has_managed_page(ppnum_t first, ppnum_t last)
	147	{
5ba3f43e A	148	ppnum_t pn, kdata_start, kdata_end;
	149	boolean_t result;
	150	boot_args * args;
	151
	152	args = (boot_args *) PE_state.bootArgs;
	153
	154	// Allow pages that the booter added to the end of the kernel.
	155	// We may miss reporting some pages in this range that were freed
	156	// with ml_static_free()
	157	kdata_start = atop_32(args->kaddr);
	158	kdata_end = atop_32(args->kaddr + args->ksize);
3e170ce0 A	159
	160	assert(last_managed_page);
	161	assert(first <= last);
	162
	163	for (result = FALSE, pn = first;
	164	!result
	165	&& (pn <= last)
	166	&& (pn <= last_managed_page);
	167	pn++)
	168	{
5ba3f43e	169	if ((pn >= kdata_start) && (pn < kdata_end)) continue;
3e170ce0 A	170	result = (0 != (pmap_phys_attributes[pn] & PHYS_MANAGED));
	171	}
	172
	173	return (result);
	174	}
6d2010ae A	175
	176	boolean_t
	177	pmap_is_noencrypt(ppnum_t pn)
	178	{
	179	int pai;
	180
	181	pai = ppn_to_pai(pn);
	182
	183	if (!IS_MANAGED_PAGE(pai))
7ddcb079	184	return (FALSE);
6d2010ae A	185
	186	if (pmap_phys_attributes[pai] & PHYS_NOENCRYPT)
	187	return (TRUE);
	188
	189	return (FALSE);
	190	}
	191
	192
	193	void
	194	pmap_set_noencrypt(ppnum_t pn)
	195	{
	196	int pai;
	197
	198	pai = ppn_to_pai(pn);
	199
	200	if (IS_MANAGED_PAGE(pai)) {
	201	LOCK_PVH(pai);
	202
	203	pmap_phys_attributes[pai] \|= PHYS_NOENCRYPT;
	204
	205	UNLOCK_PVH(pai);
	206	}
	207	}
	208
	209
	210	void
	211	pmap_clear_noencrypt(ppnum_t pn)
	212	{
	213	int pai;
	214
	215	pai = ppn_to_pai(pn);
	216
	217	if (IS_MANAGED_PAGE(pai)) {
7ddcb079 A	218	/*
	219	* synchronization at VM layer prevents PHYS_NOENCRYPT
	220	* from changing state, so we don't need the lock to inspect
	221	*/
	222	if (pmap_phys_attributes[pai] & PHYS_NOENCRYPT) {
	223	LOCK_PVH(pai);
6d2010ae	224
7ddcb079	225	pmap_phys_attributes[pai] &= ~PHYS_NOENCRYPT;
6d2010ae	226
7ddcb079 A	227	UNLOCK_PVH(pai);
7ddcb079 A	228	}
6d2010ae A	229	}
	230	}
	231
	232	void
	233	compute_pmap_gc_throttle(void *arg __unused)
	234	{
	235
	236	}
	237
	238
fe8ab488 A	239	void
	240	pmap_lock_phys_page(ppnum_t pn)
	241	{
	242	int pai;
	243
	244	pai = ppn_to_pai(pn);
	245
	246	if (IS_MANAGED_PAGE(pai)) {
	247	LOCK_PVH(pai);
	248	} else
	249	simple_lock(&phys_backup_lock);
	250	}
	251
	252
	253	void
	254	pmap_unlock_phys_page(ppnum_t pn)
	255	{
	256	int pai;
	257
	258	pai = ppn_to_pai(pn);
	259
	260	if (IS_MANAGED_PAGE(pai)) {
	261	UNLOCK_PVH(pai);
	262	} else
	263	simple_unlock(&phys_backup_lock);
	264	}
	265
	266
	267
6d2010ae A	268	__private_extern__ void
	269	pmap_pagetable_corruption_msg_log(int (log_func)(const char fmt, ...)__printflike(1,2)) {
	270	if (pmap_pagetable_corruption_incidents > 0) {
	271	int i, e = MIN(pmap_pagetable_corruption_incidents, PMAP_PAGETABLE_CORRUPTION_MAX_LOG);
	272	(*log_func)("%u pagetable corruption incident(s) detected, timeout: %u\n", pmap_pagetable_corruption_incidents, pmap_pagetable_corruption_timeout);
	273	for (i = 0; i < e; i++) {
	274	(*log_func)("Incident 0x%x, reason: 0x%x, action: 0x%x, time: 0x%llx\n", pmap_pagetable_corruption_records[i].incident, pmap_pagetable_corruption_records[i].reason, pmap_pagetable_corruption_records[i].action, pmap_pagetable_corruption_records[i].abstime);
	275	}
	276	}
	277	}
	278
	279	static inline void
	280	pmap_pagetable_corruption_log_setup(void) {
	281	if (pmap_pagetable_corruption_log_call == NULL) {
	282	nanotime_to_absolutetime(PMAP_PAGETABLE_CORRUPTION_INTERVAL, 0, &pmap_pagetable_corruption_interval_abstime);
	283	thread_call_setup(&pmap_pagetable_corruption_log_call_data,
	284	(thread_call_func_t) pmap_pagetable_corruption_msg_log,
	285	(thread_call_param_t) &printf);
	286	pmap_pagetable_corruption_log_call = &pmap_pagetable_corruption_log_call_data;
	287	}
	288	}
	289
	290	void
	291	mapping_free_prime(void)
	292	{
	293	unsigned i;
	294	pv_hashed_entry_t pvh_e;
	295	pv_hashed_entry_t pvh_eh;
	296	pv_hashed_entry_t pvh_et;
	297	int pv_cnt;
	298
	299	/* Scale based on DRAM size */
	300	pv_hashed_low_water_mark = MAX(PV_HASHED_LOW_WATER_MARK_DEFAULT, ((uint32_t)(sane_size >> 30)) * 2000);
	301	pv_hashed_low_water_mark = MIN(pv_hashed_low_water_mark, 16000);
	302	/* Alterable via sysctl */
	303	pv_hashed_kern_low_water_mark = MAX(PV_HASHED_KERN_LOW_WATER_MARK_DEFAULT, ((uint32_t)(sane_size >> 30)) * 1000);
	304	pv_hashed_kern_low_water_mark = MIN(pv_hashed_kern_low_water_mark, 16000);
	305	pv_hashed_kern_alloc_chunk = PV_HASHED_KERN_ALLOC_CHUNK_INITIAL;
	306	pv_hashed_alloc_chunk = PV_HASHED_ALLOC_CHUNK_INITIAL;
	307
	308	pv_cnt = 0;
	309	pvh_eh = pvh_et = PV_HASHED_ENTRY_NULL;
	310
	311	for (i = 0; i < (5 * PV_HASHED_ALLOC_CHUNK_INITIAL); i++) {
	312	pvh_e = (pv_hashed_entry_t) zalloc(pv_hashed_list_zone);
	313
	314	pvh_e->qlink.next = (queue_entry_t)pvh_eh;
	315	pvh_eh = pvh_e;
	316
	317	if (pvh_et == PV_HASHED_ENTRY_NULL)
	318	pvh_et = pvh_e;
	319	pv_cnt++;
	320	}
	321	PV_HASHED_FREE_LIST(pvh_eh, pvh_et, pv_cnt);
	322
	323	pv_cnt = 0;
	324	pvh_eh = pvh_et = PV_HASHED_ENTRY_NULL;
	325	for (i = 0; i < PV_HASHED_KERN_ALLOC_CHUNK_INITIAL; i++) {
	326	pvh_e = (pv_hashed_entry_t) zalloc(pv_hashed_list_zone);
	327
	328	pvh_e->qlink.next = (queue_entry_t)pvh_eh;
	329	pvh_eh = pvh_e;
	330
	331	if (pvh_et == PV_HASHED_ENTRY_NULL)
332	pvh_et = pvh_e;
333	pv_cnt++;
334	}
335	PV_HASHED_KERN_FREE_LIST(pvh_eh, pvh_et, pv_cnt);
336	}
337
338	void mapping_replenish(void);
339
340	void mapping_adjust(void) {
341	kern_return_t mres;
342
343	pmap_pagetable_corruption_log_setup();
344
345	mres = kernel_thread_start_priority((thread_continue_t)mapping_replenish, NULL, MAXPRI_KERNEL, &mapping_replenish_thread);
346	if (mres != KERN_SUCCESS) {
347	panic("pmap: mapping_replenish_thread creation failed");
348	}
349	thread_deallocate(mapping_replenish_thread);
350	}
351
352	unsigned pmap_mapping_thread_wakeups;
353	unsigned pmap_kernel_reserve_replenish_stat;
354	unsigned pmap_user_reserve_replenish_stat;
355	unsigned pmap_kern_reserve_alloc_stat;
356
39037602 A	357	__attribute__((noreturn))
	358	void
	359	mapping_replenish(void)
6d2010ae A	360	{
	361	pv_hashed_entry_t pvh_e;
	362	pv_hashed_entry_t pvh_eh;
	363	pv_hashed_entry_t pvh_et;
	364	int pv_cnt;
	365	unsigned i;
	366
	367	/* We qualify for VM privileges...*/
	368	current_thread()->options \|= TH_OPT_VMPRIV;
	369
	370	for (;;) {
	371
	372	while (pv_hashed_kern_free_count < pv_hashed_kern_low_water_mark) {
	373	pv_cnt = 0;
	374	pvh_eh = pvh_et = PV_HASHED_ENTRY_NULL;
	375
	376	for (i = 0; i < pv_hashed_kern_alloc_chunk; i++) {
	377	pvh_e = (pv_hashed_entry_t) zalloc(pv_hashed_list_zone);
	378	pvh_e->qlink.next = (queue_entry_t)pvh_eh;
	379	pvh_eh = pvh_e;
	380
	381	if (pvh_et == PV_HASHED_ENTRY_NULL)
	382	pvh_et = pvh_e;
	383	pv_cnt++;
	384	}
	385	pmap_kernel_reserve_replenish_stat += pv_cnt;
	386	PV_HASHED_KERN_FREE_LIST(pvh_eh, pvh_et, pv_cnt);
	387	}
	388
	389	pv_cnt = 0;
	390	pvh_eh = pvh_et = PV_HASHED_ENTRY_NULL;
	391
	392	if (pv_hashed_free_count < pv_hashed_low_water_mark) {
	393	for (i = 0; i < pv_hashed_alloc_chunk; i++) {
	394	pvh_e = (pv_hashed_entry_t) zalloc(pv_hashed_list_zone);
	395
	396	pvh_e->qlink.next = (queue_entry_t)pvh_eh;
	397	pvh_eh = pvh_e;
	398
	399	if (pvh_et == PV_HASHED_ENTRY_NULL)
	400	pvh_et = pvh_e;
	401	pv_cnt++;
	402	}
	403	pmap_user_reserve_replenish_stat += pv_cnt;
	404	PV_HASHED_FREE_LIST(pvh_eh, pvh_et, pv_cnt);
	405	}
	406	/* Wake threads throttled while the kernel reserve was being replenished.
	407	*/
	408	if (pmap_pv_throttled_waiters) {
	409	pmap_pv_throttled_waiters = 0;
	410	thread_wakeup(&pmap_user_pv_throttle_event);
	411	}
	412	/* Check if the kernel pool has been depleted since the
	413	* first pass, to reduce refill latency.
	414	*/
	415	if (pv_hashed_kern_free_count < pv_hashed_kern_low_water_mark)
	416	continue;
	417	/* Block sans continuation to avoid yielding kernel stack */
	418	assert_wait(&mapping_replenish_event, THREAD_UNINT);
	419	mappingrecurse = 0;
	420	thread_block(THREAD_CONTINUE_NULL);
	421	pmap_mapping_thread_wakeups++;
	422	}
	423	}
424
425	/*
426	* Set specified attribute bits.
427	*/
428
429	void
430	phys_attribute_set(
431	ppnum_t pn,
432	int bits)
433	{
434	int pai;
435
436	pmap_intr_assert();
437	assert(pn != vm_page_fictitious_addr);
438	if (pn == vm_page_guard_addr)
439	return;
440
441	pai = ppn_to_pai(pn);
442
443	if (!IS_MANAGED_PAGE(pai)) {
444	/* Not a managed page. */
445	return;
446	}
447
448	LOCK_PVH(pai);
449	pmap_phys_attributes[pai] \|= bits;
450	UNLOCK_PVH(pai);
451	}
452
453	/*
454	* Set the modify bit on the specified physical page.
455	*/
456
457	void
458	pmap_set_modify(ppnum_t pn)
459	{
460	phys_attribute_set(pn, PHYS_MODIFIED);
461	}
462
463	/*
464	* Clear the modify bits on the specified physical page.
465	*/
466
467	void
468	pmap_clear_modify(ppnum_t pn)
469	{
39236c6e	470	phys_attribute_clear(pn, PHYS_MODIFIED, 0, NULL);
6d2010ae A	471	}
	472
	473	/*
	474	* pmap_is_modified:
	475	*
	476	* Return whether or not the specified physical page is modified
	477	* by any physical maps.
	478	*/
	479
	480	boolean_t
	481	pmap_is_modified(ppnum_t pn)
	482	{
	483	if (phys_attribute_test(pn, PHYS_MODIFIED))
	484	return TRUE;
	485	return FALSE;
	486	}
	487
	488
	489	/*
	490	* pmap_clear_reference:
	491	*
	492	* Clear the reference bit on the specified physical page.
	493	*/
	494
	495	void
	496	pmap_clear_reference(ppnum_t pn)
	497	{
39236c6e	498	phys_attribute_clear(pn, PHYS_REFERENCED, 0, NULL);
6d2010ae A	499	}
	500
	501	void
	502	pmap_set_reference(ppnum_t pn)
	503	{
	504	phys_attribute_set(pn, PHYS_REFERENCED);
	505	}
	506
	507	/*
	508	* pmap_is_referenced:
	509	*
	510	* Return whether or not the specified physical page is referenced
	511	* by any physical maps.
	512	*/
	513
	514	boolean_t
	515	pmap_is_referenced(ppnum_t pn)
	516	{
	517	if (phys_attribute_test(pn, PHYS_REFERENCED))
	518	return TRUE;
	519	return FALSE;
	520	}
	521
	522
	523	/*
	524	* pmap_get_refmod(phys)
	525	* returns the referenced and modified bits of the specified
	526	* physical page.
	527	*/
	528	unsigned int
	529	pmap_get_refmod(ppnum_t pn)
	530	{
	531	int refmod;
	532	unsigned int retval = 0;
	533
	534	refmod = phys_attribute_test(pn, PHYS_MODIFIED \| PHYS_REFERENCED);
	535
	536	if (refmod & PHYS_MODIFIED)
	537	retval \|= VM_MEM_MODIFIED;
	538	if (refmod & PHYS_REFERENCED)
	539	retval \|= VM_MEM_REFERENCED;
	540
	541	return (retval);
	542	}
	543
39236c6e A	544
	545	void
	546	pmap_clear_refmod_options(ppnum_t pn, unsigned int mask, unsigned int options, void *arg)
	547	{
	548	unsigned int x86Mask;
	549
	550	x86Mask = ( ((mask & VM_MEM_MODIFIED)? PHYS_MODIFIED : 0)
	551	\| ((mask & VM_MEM_REFERENCED)? PHYS_REFERENCED : 0));
	552
	553	phys_attribute_clear(pn, x86Mask, options, arg);
	554	}
	555
6d2010ae A	556	/*
	557	* pmap_clear_refmod(phys, mask)
	558	* clears the referenced and modified bits as specified by the mask
	559	* of the specified physical page.
	560	*/
	561	void
	562	pmap_clear_refmod(ppnum_t pn, unsigned int mask)
	563	{
	564	unsigned int x86Mask;
	565
	566	x86Mask = ( ((mask & VM_MEM_MODIFIED)? PHYS_MODIFIED : 0)
	567	\| ((mask & VM_MEM_REFERENCED)? PHYS_REFERENCED : 0));
39236c6e A	568
	569	phys_attribute_clear(pn, x86Mask, 0, NULL);
	570	}
	571
	572	unsigned int
	573	pmap_disconnect(ppnum_t pa)
	574	{
	575	return (pmap_disconnect_options(pa, 0, NULL));
6d2010ae A	576	}
	577
	578	/*
	579	* Routine:
39236c6e	580	* pmap_disconnect_options
6d2010ae A	581	*
	582	* Function:
	583	* Disconnect all mappings for this page and return reference and change status
	584	* in generic format.
	585	*
	586	*/
	587	unsigned int
39236c6e	588	pmap_disconnect_options(ppnum_t pa, unsigned int options, void *arg)
6d2010ae A	589	{
	590	unsigned refmod, vmrefmod = 0;
	591
39236c6e	592	pmap_page_protect_options(pa, 0, options, arg); /* disconnect the page */
6d2010ae A	593
6d2010ae A	594	pmap_assert(pa != vm_page_fictitious_addr);
39236c6e	595	if ((pa == vm_page_guard_addr) \|\| !IS_MANAGED_PAGE(pa) \|\| (options & PMAP_OPTIONS_NOREFMOD))
6d2010ae A	596	return 0;
	597	refmod = pmap_phys_attributes[pa] & (PHYS_MODIFIED \| PHYS_REFERENCED);
	598
	599	if (refmod & PHYS_MODIFIED)
	600	vmrefmod \|= VM_MEM_MODIFIED;
	601	if (refmod & PHYS_REFERENCED)
	602	vmrefmod \|= VM_MEM_REFERENCED;
	603
	604	return vmrefmod;
	605	}