[apple/xnu.git] / osfmk / i386 / cpu_data.h

/*
 * Copyright (c) 2000-2012 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@
 */
/*
 * @OSF_COPYRIGHT@
 * 
 */

#ifndef	I386_CPU_DATA
#define I386_CPU_DATA

#include <mach_assert.h>

#include <kern/assert.h>
#include <kern/kern_types.h>
#include <kern/queue.h>
#include <kern/processor.h>
#include <kern/pms.h>
#include <pexpert/pexpert.h>
#include <mach/i386/thread_status.h>
#include <mach/i386/vm_param.h>
#include <i386/locks.h>
#include <i386/rtclock_protos.h>
#include <i386/pmCPU.h>
#include <i386/cpu_topology.h>

#if CONFIG_VMX
#include <i386/vmx/vmx_cpu.h>
#endif

#include <machine/pal_routines.h>

/*
 * Data structures referenced (anonymously) from per-cpu data:
 */
struct cpu_cons_buffer;
struct cpu_desc_table;
struct mca_state;
struct prngContext;

/*
 * Data structures embedded in per-cpu data:
 */
typedef struct rtclock_timer {
	mpqueue_head_t		queue;
	uint64_t		deadline;
	uint64_t		when_set;
	boolean_t		has_expired;
} rtclock_timer_t;


typedef struct {
	struct x86_64_tss	*cdi_ktss;
	struct __attribute__((packed)) {
		uint16_t size;
		void *ptr;
	} cdi_gdt, cdi_idt;
	struct fake_descriptor	*cdi_ldt;
	vm_offset_t		cdi_sstk;
} cpu_desc_index_t;

typedef enum {
	TASK_MAP_32BIT,			/* 32-bit user, compatibility mode */ 
	TASK_MAP_64BIT,			/* 64-bit user thread, shared space */ 
} task_map_t;


/*
 * This structure is used on entry into the (uber-)kernel on syscall from
 * a 64-bit user. It contains the address of the machine state save area
 * for the current thread and a temporary place to save the user's rsp
 * before loading this address into rsp.
 */
typedef struct {
	addr64_t	cu_isf;		/* thread->pcb->iss.isf */
	uint64_t	cu_tmp;		/* temporary scratch */	
	addr64_t	cu_user_gs_base;
} cpu_uber_t;

typedef	uint16_t	pcid_t;
typedef	uint8_t		pcid_ref_t;

#define CPU_RTIME_BINS (12)
#define CPU_ITIME_BINS (CPU_RTIME_BINS)

#define MAXPLFRAMES (32)
typedef struct {
	boolean_t pltype;
	int plevel;
	uint64_t plbt[MAXPLFRAMES];
} plrecord_t;

/*
 * Per-cpu data.
 *
 * Each processor has a per-cpu data area which is dereferenced through the
 * current_cpu_datap() macro. For speed, the %gs segment is based here, and
 * using this, inlines provides single-instruction access to frequently used
 * members - such as get_cpu_number()/cpu_number(), and get_active_thread()/
 * current_thread(). 
 * 
 * Cpu data owned by another processor can be accessed using the
 * cpu_datap(cpu_number) macro which uses the cpu_data_ptr[] array of per-cpu
 * pointers.
 */
typedef struct cpu_data
{
	struct pal_cpu_data	cpu_pal_data;		/* PAL-specific data */
#define				cpu_pd cpu_pal_data	/* convenience alias */
	struct cpu_data		*cpu_this;		/* pointer to myself */
	thread_t		cpu_active_thread;
	thread_t		cpu_nthread;
	volatile int		cpu_preemption_level;
	int			cpu_number;		/* Logical CPU */
	void			*cpu_int_state;		/* interrupt state */
	vm_offset_t		cpu_active_stack;	/* kernel stack base */
	vm_offset_t		cpu_kernel_stack;	/* kernel stack top */
	vm_offset_t		cpu_int_stack_top;
	int			cpu_interrupt_level;
	int			cpu_phys_number;	/* Physical CPU */
	cpu_id_t		cpu_id;			/* Platform Expert */
	volatile int		cpu_signals;		/* IPI events */
	volatile int		cpu_prior_signals;	/* Last set of events,
							 * debugging
							 */
	ast_t			cpu_pending_ast;
	volatile int		cpu_running;
	boolean_t		cpu_fixed_pmcs_enabled;
	rtclock_timer_t		rtclock_timer;
	volatile addr64_t	cpu_active_cr3 __attribute((aligned(64)));
	union {
		volatile uint32_t cpu_tlb_invalid;
		struct {
			volatile uint16_t cpu_tlb_invalid_local;
			volatile uint16_t cpu_tlb_invalid_global;
		};
	};
	volatile task_map_t	cpu_task_map;
	volatile addr64_t	cpu_task_cr3;
	addr64_t		cpu_kernel_cr3;
	boolean_t		cpu_pagezero_mapped;
	cpu_uber_t		cpu_uber;
	void			*cpu_chud;
	void			*cpu_console_buf;
	struct x86_lcpu		lcpu;
	struct processor	*cpu_processor;
#if NCOPY_WINDOWS > 0
	struct cpu_pmap		*cpu_pmap;
#endif
	struct cpu_desc_table	*cpu_desc_tablep;
	struct fake_descriptor	*cpu_ldtp;
	cpu_desc_index_t	cpu_desc_index;
	int			cpu_ldt;
#if NCOPY_WINDOWS > 0
	vm_offset_t		cpu_copywindow_base;
	uint64_t		*cpu_copywindow_pdp;

	vm_offset_t		cpu_physwindow_base;
	uint64_t		*cpu_physwindow_ptep;
#endif

#define HWINTCNT_SIZE 256
	uint32_t		cpu_hwIntCnt[HWINTCNT_SIZE];	/* Interrupt counts */
 	uint64_t		cpu_hwIntpexits[HWINTCNT_SIZE];
	uint64_t		cpu_hwIntcexits[HWINTCNT_SIZE];
	uint64_t		cpu_dr7; /* debug control register */
	uint64_t		cpu_int_event_time;	/* intr entry/exit time */
	pal_rtc_nanotime_t	*cpu_nanotime;		/* Nanotime info */
#if KPC
	/* double-buffered performance counter data */
	uint64_t                *cpu_kpc_buf[2];
	/* PMC shadow and reload value buffers */
	uint64_t                *cpu_kpc_shadow;
	uint64_t                *cpu_kpc_reload;
#endif
	uint32_t		cpu_pmap_pcid_enabled;
	pcid_t			cpu_active_pcid;
	pcid_t			cpu_last_pcid;
	pcid_t			cpu_kernel_pcid;
	volatile pcid_ref_t	*cpu_pmap_pcid_coherentp;
	volatile pcid_ref_t	*cpu_pmap_pcid_coherentp_kernel;
#define	PMAP_PCID_MAX_PCID      (0x1000)
	pcid_t			cpu_pcid_free_hint;
	pcid_ref_t		cpu_pcid_refcounts[PMAP_PCID_MAX_PCID];
	pmap_t			cpu_pcid_last_pmap_dispatched[PMAP_PCID_MAX_PCID];
#ifdef	PCID_STATS
	uint64_t		cpu_pmap_pcid_flushes;
	uint64_t		cpu_pmap_pcid_preserves;
#endif
	uint64_t		cpu_aperf;
	uint64_t		cpu_mperf;
	uint64_t		cpu_c3res;
	uint64_t		cpu_c6res;
	uint64_t		cpu_c7res;
	uint64_t		cpu_itime_total;
	uint64_t		cpu_rtime_total;
	uint64_t		cpu_ixtime;
	uint64_t                cpu_idle_exits;
 	uint64_t		cpu_rtimes[CPU_RTIME_BINS];
 	uint64_t		cpu_itimes[CPU_ITIME_BINS];
 	uint64_t		cpu_cur_insns;
 	uint64_t		cpu_cur_ucc;
 	uint64_t		cpu_cur_urc;
	uint64_t		cpu_gpmcs[4];
	uint64_t                cpu_max_observed_int_latency;
	int                     cpu_max_observed_int_latency_vector;
	volatile boolean_t	cpu_NMI_acknowledged;
	uint64_t		debugger_entry_time;
	uint64_t		debugger_ipi_time;
	/* A separate nested interrupt stack flag, to account
	 * for non-nested interrupts arriving while on the interrupt stack
	 * Currently only occurs when AICPM enables interrupts on the
	 * interrupt stack during processor offlining.
	 */
	uint32_t		cpu_nested_istack;
	uint32_t		cpu_nested_istack_events;
	x86_saved_state64_t	*cpu_fatal_trap_state;
	x86_saved_state64_t	*cpu_post_fatal_trap_state;
#if CONFIG_VMX
	vmx_cpu_t		cpu_vmx;		/* wonderful world of virtualization */
#endif
#if CONFIG_MCA
	struct mca_state	*cpu_mca_state;		/* State at MC fault */
#endif
	struct prngContext	*cpu_prng;		/* PRNG's context */
 	int			cpu_type;
 	int			cpu_subtype;
 	int			cpu_threadtype;
 	boolean_t		cpu_iflag;
 	boolean_t		cpu_boot_complete;
	int			cpu_hibernate;
#define MAX_PREEMPTION_RECORDS (128)
#if	DEVELOPMENT || DEBUG
	int			cpu_plri;
	plrecord_t		plrecords[MAX_PREEMPTION_RECORDS];
#endif
} cpu_data_t;

extern cpu_data_t	*cpu_data_ptr[];  

/* Macro to generate inline bodies to retrieve per-cpu data fields. */
#if defined(__clang__)
#define GS_RELATIVE volatile __attribute__((address_space(256)))
#ifndef offsetof
#define offsetof(TYPE,MEMBER) __builtin_offsetof(TYPE,MEMBER)
#endif

#define CPU_DATA_GET(member,type)										\
	cpu_data_t GS_RELATIVE *cpu_data =							\
		(cpu_data_t GS_RELATIVE *)0UL;									\
	type ret;															\
	ret = cpu_data->member;												\
	return ret;

#define CPU_DATA_GET_INDEX(member,index,type)							\
	cpu_data_t GS_RELATIVE *cpu_data =							\
		(cpu_data_t GS_RELATIVE *)0UL;									\
	type ret;															\
	ret = cpu_data->member[index];										\
	return ret;

#define CPU_DATA_SET(member,value)										\
	cpu_data_t GS_RELATIVE *cpu_data =							\
		(cpu_data_t GS_RELATIVE *)0UL;									\
	cpu_data->member = value;

#define CPU_DATA_XCHG(member,value,type)								\
	cpu_data_t GS_RELATIVE *cpu_data =							\
		(cpu_data_t GS_RELATIVE *)0UL;									\
	type ret;															\
	ret = cpu_data->member;												\
	cpu_data->member = value;											\
	return ret;

#else /* !defined(__clang__) */

#ifndef offsetof
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif /* offsetof */
#define CPU_DATA_GET(member,type)					\
	type ret;							\
	__asm__ volatile ("mov %%gs:%P1,%0"				\
		: "=r" (ret)						\
		: "i" (offsetof(cpu_data_t,member)));			\
	return ret;

#define CPU_DATA_GET_INDEX(member,index,type)	\
	type ret;							\
	__asm__ volatile ("mov %%gs:(%1),%0"				\
		: "=r" (ret)						\
		: "r" (offsetof(cpu_data_t,member[index])));			\
	return ret;

#define CPU_DATA_SET(member,value)					\
	__asm__ volatile ("mov %0,%%gs:%P1"				\
		:							\
		: "r" (value), "i" (offsetof(cpu_data_t,member)));

#define CPU_DATA_XCHG(member,value,type)				\
	type ret;							\
	__asm__ volatile ("xchg %0,%%gs:%P1"				\
		: "=r" (ret)						\
		: "i" (offsetof(cpu_data_t,member)), "0" (value));	\
	return ret;

#endif /* !defined(__clang__) */

/*
 * Everyone within the osfmk part of the kernel can use the fast
 * inline versions of these routines.  Everyone outside, must call
 * the real thing,
 */
static inline thread_t
get_active_thread(void)
{
	CPU_DATA_GET(cpu_active_thread,thread_t)
}
#define current_thread_fast()		get_active_thread()
#define current_thread()		current_thread_fast()

#define cpu_mode_is64bit()		TRUE

static inline int
get_preemption_level(void)
{
	CPU_DATA_GET(cpu_preemption_level,int)
}
static inline int
get_interrupt_level(void)
{
	CPU_DATA_GET(cpu_interrupt_level,int)
}
static inline int
get_cpu_number(void)
{
	CPU_DATA_GET(cpu_number,int)
}
static inline int
get_cpu_phys_number(void)
{
	CPU_DATA_GET(cpu_phys_number,int)
}

static inline cpu_data_t *
current_cpu_datap(void) {
	CPU_DATA_GET(cpu_this, cpu_data_t *);
}

/*
 * Facility to diagnose preemption-level imbalances, which are otherwise
 * challenging to debug. On each operation that enables or disables preemption,
 * we record a backtrace into a per-CPU ring buffer, along with the current
 * preemption level and operation type. Thus, if an imbalance is observed,
 * one can examine these per-CPU records to determine which codepath failed
 * to re-enable preemption, enabled premption without a corresponding
 * disablement etc. The backtracer determines which stack is currently active,
 * and uses that to perform bounds checks on unterminated stacks.
 * To enable, sysctl -w machdep.pltrace=1 on DEVELOPMENT or DEBUG kernels (DRK '15)
 * The bounds check currently doesn't account for non-default thread stack sizes.
 */
#if DEVELOPMENT || DEBUG
static inline void pltrace_bt(uint64_t *rets, int maxframes, uint64_t stacklo, uint64_t stackhi) {
	uint64_t *cfp = (uint64_t *) __builtin_frame_address(0);
	int plbtf;

	assert(stacklo !=0  && stackhi !=0);

	for (plbtf = 0; plbtf < maxframes; plbtf++) {
		if (((uint64_t)cfp == 0) || (((uint64_t)cfp < stacklo) || ((uint64_t)cfp > stackhi))) {
			rets[plbtf] = 0;
			continue;
		}
		rets[plbtf] = *(cfp + 1);
		cfp = (uint64_t *) (*cfp);
	}
}


extern uint32_t		low_intstack[];		/* bottom */
extern uint32_t		low_eintstack[];	/* top */
extern char		mp_slave_stack[PAGE_SIZE];

static inline void pltrace_internal(boolean_t enable) {
	cpu_data_t *cdata = current_cpu_datap();
	int cpli = cdata->cpu_preemption_level;
	int cplrecord = cdata->cpu_plri;
	uint64_t kstackb, kstackt, *plbts;

	assert(cpli >= 0);

	cdata->plrecords[cplrecord].pltype = enable;
	cdata->plrecords[cplrecord].plevel = cpli;

	plbts = &cdata->plrecords[cplrecord].plbt[0];

	cplrecord++;

	if (cplrecord >= MAX_PREEMPTION_RECORDS) {
		cplrecord = 0;
	}

	cdata->cpu_plri = cplrecord;
	/* Obtain the 'current' program counter, initial backtrace
	 * element. This will also indicate if we were unable to
	 * trace further up the stack for some reason
	 */
	__asm__ volatile("leaq 1f(%%rip), %%rax; mov %%rax, %0\n1:"
	    : "=m" (plbts[0])
	    :
	    : "rax");


	thread_t cplthread = cdata->cpu_active_thread;
	if (cplthread) {
		uintptr_t csp;
		__asm__ __volatile__ ("movq %%rsp, %0": "=r" (csp):);
		/* Determine which stack we're on to populate stack bounds.
		 * We don't need to trace across stack boundaries for this
		 * routine.
		 */
		kstackb = cdata->cpu_active_stack;
		kstackt = kstackb + KERNEL_STACK_SIZE;
		if (csp < kstackb || csp > kstackt) {
			kstackt = cdata->cpu_kernel_stack;
			kstackb = kstackb - KERNEL_STACK_SIZE;
			if (csp < kstackb || csp > kstackt) {
				kstackt = cdata->cpu_int_stack_top;
				kstackb = kstackt - INTSTACK_SIZE;
				if (csp < kstackb || csp > kstackt) {
					kstackt = (uintptr_t)low_eintstack;
					kstackb = (uintptr_t)low_eintstack - INTSTACK_SIZE;
					if (csp < kstackb || csp > kstackt) {
						kstackb = (uintptr_t) mp_slave_stack;
						kstackt = (uintptr_t) mp_slave_stack + PAGE_SIZE;
					}
				}
			}
		}

		if (kstackb) {
			pltrace_bt(&plbts[1], MAXPLFRAMES - 1, kstackb, kstackt);
		}
	}
}

extern int plctrace_enabled;
#endif /* DEVELOPMENT || DEBUG */

static inline void pltrace(boolean_t plenable) {
#if DEVELOPMENT || DEBUG
	if (__improbable(plctrace_enabled != 0)) {
		pltrace_internal(plenable);
	}
#else
	(void)plenable;
#endif
}

static inline void
disable_preemption_internal(void) {
	assert(get_preemption_level() >= 0);

#if defined(__clang__)
	cpu_data_t GS_RELATIVE *cpu_data = (cpu_data_t GS_RELATIVE *)0UL;
	cpu_data->cpu_preemption_level++;
#else
	__asm__ volatile ("incl %%gs:%P0"
	    :
	    : "i" (offsetof(cpu_data_t, cpu_preemption_level)));
#endif
	pltrace(FALSE);
}

static inline void
enable_preemption_internal(void) {
	assert(get_preemption_level() > 0);
	pltrace(TRUE);
#if defined(__clang__)
	cpu_data_t GS_RELATIVE *cpu_data = (cpu_data_t GS_RELATIVE *)0UL;
	if (0 == --cpu_data->cpu_preemption_level)
		kernel_preempt_check();
#else
	__asm__ volatile ("decl %%gs:%P0		\n\t"
			  "jne 1f			\n\t"
			  "call _kernel_preempt_check	\n\t"
			  "1:"
			: /* no outputs */
			: "i" (offsetof(cpu_data_t, cpu_preemption_level))
			: "eax", "ecx", "edx", "cc", "memory");
#endif
}

static inline void
enable_preemption_no_check(void)
{
	assert(get_preemption_level() > 0);

	pltrace(TRUE);
#if defined(__clang__)
	cpu_data_t GS_RELATIVE *cpu_data = (cpu_data_t GS_RELATIVE *)0UL;
	cpu_data->cpu_preemption_level--;
#else
	__asm__ volatile ("decl %%gs:%P0"
			: /* no outputs */
			: "i" (offsetof(cpu_data_t, cpu_preemption_level))
			: "cc", "memory");
#endif
}

static inline void
_enable_preemption_no_check(void) {
	enable_preemption_no_check();
}

static inline void
mp_disable_preemption(void)
{
	disable_preemption_internal();
}

static inline void
_mp_disable_preemption(void)
{
	disable_preemption_internal();
}

static inline void
mp_enable_preemption(void)
{
	enable_preemption_internal();
}

static inline void
_mp_enable_preemption(void) {
	enable_preemption_internal();
}

static inline void
mp_enable_preemption_no_check(void) {
	enable_preemption_no_check();
}

static inline void
_mp_enable_preemption_no_check(void) {
	enable_preemption_no_check();
}

#ifdef XNU_KERNEL_PRIVATE
#define disable_preemption() disable_preemption_internal()
#define enable_preemption() enable_preemption_internal()
#define MACHINE_PREEMPTION_MACROS (1)
#endif


static inline cpu_data_t *
cpu_datap(int cpu) {
	return cpu_data_ptr[cpu];
}

extern cpu_data_t *cpu_data_alloc(boolean_t is_boot_cpu);
extern void cpu_data_realloc(void);

#endif	/* I386_CPU_DATA */
Commit	Line	Data
1c79356b	1	/*
39236c6e	2	* Copyright (c) 2000-2012 Apple Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	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.
8f6c56a5	14	*
2d21ac55 A	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
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	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.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* @OSF_COPYRIGHT@
	30	*
	31	*/
	32
	33	#ifndef I386_CPU_DATA
	34	#define I386_CPU_DATA
	35
1c79356b A	36	#include <mach_assert.h>
1c79356b A	37
1c79356b A	38	#include <kern/assert.h>
1c79356b A	39	#include <kern/kern_types.h>
b0d623f7	40	#include <kern/queue.h>
91447636	41	#include <kern/processor.h>
0c530ab8	42	#include <kern/pms.h>
55e303ae	43	#include <pexpert/pexpert.h>
0c530ab8	44	#include <mach/i386/thread_status.h>
b0d623f7	45	#include <mach/i386/vm_param.h>
fe8ab488	46	#include <i386/locks.h>
6d2010ae	47	#include <i386/rtclock_protos.h>
0c530ab8	48	#include <i386/pmCPU.h>
2d21ac55 A	49	#include <i386/cpu_topology.h>
2d21ac55 A	50
b0d623f7	51	#if CONFIG_VMX
2d21ac55	52	#include <i386/vmx/vmx_cpu.h>
b0d623f7	53	#endif
91447636	54
6d2010ae A	55	#include <machine/pal_routines.h>
6d2010ae A	56
91447636 A	57	/*
	58	* Data structures referenced (anonymously) from per-cpu data:
	59	*/
91447636	60	struct cpu_cons_buffer;
0c530ab8	61	struct cpu_desc_table;
2d21ac55	62	struct mca_state;
fe8ab488	63	struct prngContext;
91447636	64
91447636 A	65	/*
	66	* Data structures embedded in per-cpu data:
	67	*/
	68	typedef struct rtclock_timer {
6d2010ae	69	mpqueue_head_t queue;
c910b4d9	70	uint64_t deadline;
6d2010ae	71	uint64_t when_set;
c910b4d9	72	boolean_t has_expired;
91447636 A	73	} rtclock_timer_t;
91447636 A	74
2d21ac55	75
91447636	76	typedef struct {
39236c6e	77	struct x86_64_tss *cdi_ktss;
b0d623f7 A	78	struct __attribute__((packed)) {
	79	uint16_t size;
	80	void *ptr;
	81	} cdi_gdt, cdi_idt;
	82	struct fake_descriptor *cdi_ldt;
39236c6e	83	vm_offset_t cdi_sstk;
b0d623f7 A	84	} cpu_desc_index_t;
	85
	86	typedef enum {
	87	TASK_MAP_32BIT, /* 32-bit user, compatibility mode */
	88	TASK_MAP_64BIT, /* 64-bit user thread, shared space */
	89	} task_map_t;
	90
b0d623f7	91
0c530ab8 A	92	/*
	93	* This structure is used on entry into the (uber-)kernel on syscall from
	94	* a 64-bit user. It contains the address of the machine state save area
	95	* for the current thread and a temporary place to save the user's rsp
	96	* before loading this address into rsp.
	97	*/
	98	typedef struct {
	99	addr64_t cu_isf; /* thread->pcb->iss.isf */
	100	uint64_t cu_tmp; /* temporary scratch */
6d2010ae	101	addr64_t cu_user_gs_base;
0c530ab8	102	} cpu_uber_t;
91447636	103
6d2010ae A	104	typedef uint16_t pcid_t;
6d2010ae A	105	typedef uint8_t pcid_ref_t;
bd504ef0 A	106
	107	#define CPU_RTIME_BINS (12)
	108	#define CPU_ITIME_BINS (CPU_RTIME_BINS)
	109
39037602 A	110	#define MAXPLFRAMES (32)
	111	typedef struct {
	112	boolean_t pltype;
	113	int plevel;
	114	uint64_t plbt[MAXPLFRAMES];
	115	} plrecord_t;
	116
91447636 A	117	/*
	118	* Per-cpu data.
	119	*
	120	* Each processor has a per-cpu data area which is dereferenced through the
	121	* current_cpu_datap() macro. For speed, the %gs segment is based here, and
	122	* using this, inlines provides single-instruction access to frequently used
	123	* members - such as get_cpu_number()/cpu_number(), and get_active_thread()/
	124	* current_thread().
	125	*
	126	* Cpu data owned by another processor can be accessed using the
	127	* cpu_datap(cpu_number) macro which uses the cpu_data_ptr[] array of per-cpu
	128	* pointers.
	129	*/
	130	typedef struct cpu_data
	131	{
6d2010ae A	132	struct pal_cpu_data cpu_pal_data; /* PAL-specific data */
6d2010ae A	133	#define cpu_pd cpu_pal_data /* convenience alias */
91447636 A	134	struct cpu_data cpu_this; / pointer to myself */
91447636 A	135	thread_t cpu_active_thread;
39236c6e A	136	thread_t cpu_nthread;
39236c6e A	137	volatile int cpu_preemption_level;
6d2010ae	138	int cpu_number; /* Logical CPU */
0c530ab8 A	139	void cpu_int_state; / interrupt state */
	140	vm_offset_t cpu_active_stack; /* kernel stack base */
	141	vm_offset_t cpu_kernel_stack; /* kernel stack top */
91447636	142	vm_offset_t cpu_int_stack_top;
91447636	143	int cpu_interrupt_level;
91447636 A	144	int cpu_phys_number; /* Physical CPU */
91447636 A	145	cpu_id_t cpu_id; /* Platform Expert */
39236c6e A	146	volatile int cpu_signals; /* IPI events */
39236c6e A	147	volatile int cpu_prior_signals; /* Last set of events,
060df5ea A	148	* debugging
060df5ea A	149	*/
91447636	150	ast_t cpu_pending_ast;
bd504ef0 A	151	volatile int cpu_running;
bd504ef0 A	152	boolean_t cpu_fixed_pmcs_enabled;
0c530ab8	153	rtclock_timer_t rtclock_timer;
6d2010ae A	154	volatile addr64_t cpu_active_cr3 __attribute((aligned(64)));
	155	union {
	156	volatile uint32_t cpu_tlb_invalid;
	157	struct {
	158	volatile uint16_t cpu_tlb_invalid_local;
	159	volatile uint16_t cpu_tlb_invalid_global;
	160	};
	161	};
	162	volatile task_map_t cpu_task_map;
b0d623f7	163	volatile addr64_t cpu_task_cr3;
2d21ac55	164	addr64_t cpu_kernel_cr3;
39037602	165	boolean_t cpu_pagezero_mapped;
0c530ab8 A	166	cpu_uber_t cpu_uber;
0c530ab8 A	167	void *cpu_chud;
6601e61a	168	void *cpu_console_buf;
2d21ac55	169	struct x86_lcpu lcpu;
91447636	170	struct processor *cpu_processor;
b0d623f7	171	#if NCOPY_WINDOWS > 0
91447636	172	struct cpu_pmap *cpu_pmap;
b0d623f7	173	#endif
0c530ab8 A	174	struct cpu_desc_table *cpu_desc_tablep;
0c530ab8 A	175	struct fake_descriptor *cpu_ldtp;
91447636	176	cpu_desc_index_t cpu_desc_index;
0c530ab8	177	int cpu_ldt;
b0d623f7	178	#if NCOPY_WINDOWS > 0
2d21ac55 A	179	vm_offset_t cpu_copywindow_base;
	180	uint64_t *cpu_copywindow_pdp;
	181
	182	vm_offset_t cpu_physwindow_base;
	183	uint64_t *cpu_physwindow_ptep;
b0d623f7 A	184	#endif
b0d623f7 A	185
6d2010ae A	186	#define HWINTCNT_SIZE 256
6d2010ae A	187	uint32_t cpu_hwIntCnt[HWINTCNT_SIZE]; /* Interrupt counts */
bd504ef0 A	188	uint64_t cpu_hwIntpexits[HWINTCNT_SIZE];
bd504ef0 A	189	uint64_t cpu_hwIntcexits[HWINTCNT_SIZE];
0c530ab8	190	uint64_t cpu_dr7; /* debug control register */
2d21ac55	191	uint64_t cpu_int_event_time; /* intr entry/exit time */
6d2010ae	192	pal_rtc_nanotime_t cpu_nanotime; / Nanotime info */
39236c6e A	193	#if KPC
	194	/* double-buffered performance counter data */
	195	uint64_t *cpu_kpc_buf[2];
	196	/* PMC shadow and reload value buffers */
	197	uint64_t *cpu_kpc_shadow;
	198	uint64_t *cpu_kpc_reload;
	199	#endif
6d2010ae A	200	uint32_t cpu_pmap_pcid_enabled;
	201	pcid_t cpu_active_pcid;
	202	pcid_t cpu_last_pcid;
39037602	203	pcid_t cpu_kernel_pcid;
6d2010ae A	204	volatile pcid_ref_t *cpu_pmap_pcid_coherentp;
	205	volatile pcid_ref_t *cpu_pmap_pcid_coherentp_kernel;
	206	#define PMAP_PCID_MAX_PCID (0x1000)
	207	pcid_t cpu_pcid_free_hint;
	208	pcid_ref_t cpu_pcid_refcounts[PMAP_PCID_MAX_PCID];
	209	pmap_t cpu_pcid_last_pmap_dispatched[PMAP_PCID_MAX_PCID];
	210	#ifdef PCID_STATS
	211	uint64_t cpu_pmap_pcid_flushes;
	212	uint64_t cpu_pmap_pcid_preserves;
	213	#endif
4b17d6b6 A	214	uint64_t cpu_aperf;
	215	uint64_t cpu_mperf;
	216	uint64_t cpu_c3res;
	217	uint64_t cpu_c6res;
	218	uint64_t cpu_c7res;
	219	uint64_t cpu_itime_total;
	220	uint64_t cpu_rtime_total;
4b17d6b6	221	uint64_t cpu_ixtime;
bd504ef0 A	222	uint64_t cpu_idle_exits;
	223	uint64_t cpu_rtimes[CPU_RTIME_BINS];
	224	uint64_t cpu_itimes[CPU_ITIME_BINS];
	225	uint64_t cpu_cur_insns;
	226	uint64_t cpu_cur_ucc;
	227	uint64_t cpu_cur_urc;
a1c7dba1	228	uint64_t cpu_gpmcs[4];
6d2010ae A	229	uint64_t cpu_max_observed_int_latency;
6d2010ae A	230	int cpu_max_observed_int_latency_vector;
39236c6e	231	volatile boolean_t cpu_NMI_acknowledged;
060df5ea	232	uint64_t debugger_entry_time;
bd504ef0	233	uint64_t debugger_ipi_time;
060df5ea A	234	/* A separate nested interrupt stack flag, to account
	235	* for non-nested interrupts arriving while on the interrupt stack
	236	* Currently only occurs when AICPM enables interrupts on the
	237	* interrupt stack during processor offlining.
	238	*/
	239	uint32_t cpu_nested_istack;
	240	uint32_t cpu_nested_istack_events;
6d2010ae A	241	x86_saved_state64_t *cpu_fatal_trap_state;
6d2010ae A	242	x86_saved_state64_t *cpu_post_fatal_trap_state;
bd504ef0 A	243	#if CONFIG_VMX
	244	vmx_cpu_t cpu_vmx; /* wonderful world of virtualization */
	245	#endif
	246	#if CONFIG_MCA
	247	struct mca_state cpu_mca_state; / State at MC fault */
	248	#endif
fe8ab488	249	struct prngContext cpu_prng; / PRNG's context */
bd504ef0 A	250	int cpu_type;
	251	int cpu_subtype;
	252	int cpu_threadtype;
	253	boolean_t cpu_iflag;
	254	boolean_t cpu_boot_complete;
39037602 A	255	int cpu_hibernate;
	256	#define MAX_PREEMPTION_RECORDS (128)
	257	#if DEVELOPMENT \|\| DEBUG
	258	int cpu_plri;
	259	plrecord_t plrecords[MAX_PREEMPTION_RECORDS];
	260	#endif
55e303ae	261	} cpu_data_t;
1c79356b	262
91447636	263	extern cpu_data_t *cpu_data_ptr[];
9bccf70c	264
55e303ae	265	/* Macro to generate inline bodies to retrieve per-cpu data fields. */
39236c6e A	266	#if defined(__clang__)
	267	#define GS_RELATIVE volatile __attribute__((address_space(256)))
	268	#ifndef offsetof
	269	#define offsetof(TYPE,MEMBER) __builtin_offsetof(TYPE,MEMBER)
	270	#endif
	271
	272	#define CPU_DATA_GET(member,type) \
	273	cpu_data_t GS_RELATIVE *cpu_data = \
	274	(cpu_data_t GS_RELATIVE *)0UL; \
	275	type ret; \
	276	ret = cpu_data->member; \
	277	return ret;
	278
	279	#define CPU_DATA_GET_INDEX(member,index,type) \
	280	cpu_data_t GS_RELATIVE *cpu_data = \
	281	(cpu_data_t GS_RELATIVE *)0UL; \
	282	type ret; \
	283	ret = cpu_data->member[index]; \
	284	return ret;
	285
	286	#define CPU_DATA_SET(member,value) \
	287	cpu_data_t GS_RELATIVE *cpu_data = \
	288	(cpu_data_t GS_RELATIVE *)0UL; \
	289	cpu_data->member = value;
	290
	291	#define CPU_DATA_XCHG(member,value,type) \
	292	cpu_data_t GS_RELATIVE *cpu_data = \
	293	(cpu_data_t GS_RELATIVE *)0UL; \
	294	type ret; \
	295	ret = cpu_data->member; \
	296	cpu_data->member = value; \
	297	return ret;
	298
	299	#else /* !defined(__clang__) */
	300
2d21ac55	301	#ifndef offsetof
55e303ae	302	#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
2d21ac55	303	#endif /* offsetof */
91447636	304	#define CPU_DATA_GET(member,type) \
55e303ae	305	type ret; \
b0d623f7	306	__asm__ volatile ("mov %%gs:%P1,%0" \
55e303ae	307	: "=r" (ret) \
91447636	308	: "i" (offsetof(cpu_data_t,member))); \
55e303ae	309	return ret;
9bccf70c	310
6d2010ae A	311	#define CPU_DATA_GET_INDEX(member,index,type) \
	312	type ret; \
	313	__asm__ volatile ("mov %%gs:(%1),%0" \
	314	: "=r" (ret) \
	315	: "r" (offsetof(cpu_data_t,member[index]))); \
	316	return ret;
	317
	318	#define CPU_DATA_SET(member,value) \
	319	__asm__ volatile ("mov %0,%%gs:%P1" \
	320	: \
	321	: "r" (value), "i" (offsetof(cpu_data_t,member)));
39236c6e	322
6d2010ae A	323	#define CPU_DATA_XCHG(member,value,type) \
	324	type ret; \
	325	__asm__ volatile ("xchg %0,%%gs:%P1" \
	326	: "=r" (ret) \
	327	: "i" (offsetof(cpu_data_t,member)), "0" (value)); \
	328	return ret;
	329
39236c6e A	330	#endif /* !defined(__clang__) */
39236c6e A	331
1c79356b A	332	/*
	333	* Everyone within the osfmk part of the kernel can use the fast
	334	* inline versions of these routines. Everyone outside, must call
	335	* the real thing,
	336	*/
91447636 A	337	static inline thread_t
91447636 A	338	get_active_thread(void)
1c79356b	339	{
91447636	340	CPU_DATA_GET(cpu_active_thread,thread_t)
1c79356b	341	}
91447636 A	342	#define current_thread_fast() get_active_thread()
91447636 A	343	#define current_thread() current_thread_fast()
1c79356b	344
b0d623f7	345	#define cpu_mode_is64bit() TRUE
0c530ab8	346
91447636 A	347	static inline int
91447636 A	348	get_preemption_level(void)
1c79356b	349	{
91447636	350	CPU_DATA_GET(cpu_preemption_level,int)
55e303ae	351	}
91447636	352	static inline int
91447636	353	get_interrupt_level(void)
55e303ae	354	{
91447636	355	CPU_DATA_GET(cpu_interrupt_level,int)
55e303ae	356	}
91447636 A	357	static inline int
91447636 A	358	get_cpu_number(void)
55e303ae A	359	{
	360	CPU_DATA_GET(cpu_number,int)
	361	}
91447636 A	362	static inline int
91447636 A	363	get_cpu_phys_number(void)
55e303ae A	364	{
55e303ae A	365	CPU_DATA_GET(cpu_phys_number,int)
1c79356b	366	}
1c79356b	367
39037602 A	368	static inline cpu_data_t *
	369	current_cpu_datap(void) {
	370	CPU_DATA_GET(cpu_this, cpu_data_t *);
	371	}
	372
	373	/*
	374	* Facility to diagnose preemption-level imbalances, which are otherwise
	375	* challenging to debug. On each operation that enables or disables preemption,
	376	* we record a backtrace into a per-CPU ring buffer, along with the current
	377	* preemption level and operation type. Thus, if an imbalance is observed,
	378	* one can examine these per-CPU records to determine which codepath failed
	379	* to re-enable preemption, enabled premption without a corresponding
	380	* disablement etc. The backtracer determines which stack is currently active,
	381	* and uses that to perform bounds checks on unterminated stacks.
	382	* To enable, sysctl -w machdep.pltrace=1 on DEVELOPMENT or DEBUG kernels (DRK '15)
	383	* The bounds check currently doesn't account for non-default thread stack sizes.
	384	*/
	385	#if DEVELOPMENT \|\| DEBUG
	386	static inline void pltrace_bt(uint64_t *rets, int maxframes, uint64_t stacklo, uint64_t stackhi) {
	387	uint64_t cfp = (uint64_t ) __builtin_frame_address(0);
	388	int plbtf;
	389
	390	assert(stacklo !=0 && stackhi !=0);
	391
	392	for (plbtf = 0; plbtf < maxframes; plbtf++) {
	393	if (((uint64_t)cfp == 0) \|\| (((uint64_t)cfp < stacklo) \|\| ((uint64_t)cfp > stackhi))) {
	394	rets[plbtf] = 0;
	395	continue;
	396	}
	397	rets[plbtf] = *(cfp + 1);
	398	cfp = (uint64_t ) (cfp);
	399	}
	400	}
	401
	402
	403	extern uint32_t low_intstack[]; /* bottom */
	404	extern uint32_t low_eintstack[]; /* top */
	405	extern char mp_slave_stack[PAGE_SIZE];
	406
	407	static inline void pltrace_internal(boolean_t enable) {
	408	cpu_data_t *cdata = current_cpu_datap();
	409	int cpli = cdata->cpu_preemption_level;
	410	int cplrecord = cdata->cpu_plri;
	411	uint64_t kstackb, kstackt, *plbts;
	412
	413	assert(cpli >= 0);
	414
	415	cdata->plrecords[cplrecord].pltype = enable;
	416	cdata->plrecords[cplrecord].plevel = cpli;
	417
	418	plbts = &cdata->plrecords[cplrecord].plbt[0];
	419
	420	cplrecord++;
	421
	422	if (cplrecord >= MAX_PREEMPTION_RECORDS) {
	423	cplrecord = 0;
	424	}
	425
	426	cdata->cpu_plri = cplrecord;
	427	/* Obtain the 'current' program counter, initial backtrace
	428	* element. This will also indicate if we were unable to
	429	* trace further up the stack for some reason
	430	*/
	431	__asm__ volatile("leaq 1f(%%rip), %%rax; mov %%rax, %0\n1:"
432	: "=m" (plbts[0])
433	:
434	: "rax");
435
436
437	thread_t cplthread = cdata->cpu_active_thread;
438	if (cplthread) {
439	uintptr_t csp;
440	__asm__ __volatile__ ("movq %%rsp, %0": "=r" (csp):);
441	/* Determine which stack we're on to populate stack bounds.
442	* We don't need to trace across stack boundaries for this
443	* routine.
444	*/
445	kstackb = cdata->cpu_active_stack;
446	kstackt = kstackb + KERNEL_STACK_SIZE;
447	if (csp < kstackb \|\| csp > kstackt) {
448	kstackt = cdata->cpu_kernel_stack;
449	kstackb = kstackb - KERNEL_STACK_SIZE;
450	if (csp < kstackb \|\| csp > kstackt) {
451	kstackt = cdata->cpu_int_stack_top;
452	kstackb = kstackt - INTSTACK_SIZE;
453	if (csp < kstackb \|\| csp > kstackt) {
454	kstackt = (uintptr_t)low_eintstack;
455	kstackb = (uintptr_t)low_eintstack - INTSTACK_SIZE;
456	if (csp < kstackb \|\| csp > kstackt) {
457	kstackb = (uintptr_t) mp_slave_stack;
458	kstackt = (uintptr_t) mp_slave_stack + PAGE_SIZE;
459	}
460	}
461	}
462	}
463
464	if (kstackb) {
465	pltrace_bt(&plbts[1], MAXPLFRAMES - 1, kstackb, kstackt);
466	}
467	}
468	}
469
470	extern int plctrace_enabled;
471	#endif /* DEVELOPMENT \|\| DEBUG */
472
473	static inline void pltrace(boolean_t plenable) {
474	#if DEVELOPMENT \|\| DEBUG
475	if (__improbable(plctrace_enabled != 0)) {
476	pltrace_internal(plenable);
477	}
478	#else
479	(void)plenable;
480	#endif
481	}
b0d623f7	482
91447636	483	static inline void
39037602 A	484	disable_preemption_internal(void) {
	485	assert(get_preemption_level() >= 0);
	486
39236c6e A	487	#if defined(__clang__)
	488	cpu_data_t GS_RELATIVE cpu_data = (cpu_data_t GS_RELATIVE )0UL;
	489	cpu_data->cpu_preemption_level++;
	490	#else
91447636	491	__asm__ volatile ("incl %%gs:%P0"
39037602 A	492	:
39037602 A	493	: "i" (offsetof(cpu_data_t, cpu_preemption_level)));
39236c6e	494	#endif
39037602	495	pltrace(FALSE);
91447636	496	}
1c79356b	497
91447636	498	static inline void
39037602	499	enable_preemption_internal(void) {
55e303ae	500	assert(get_preemption_level() > 0);
39037602	501	pltrace(TRUE);
39236c6e A	502	#if defined(__clang__)
	503	cpu_data_t GS_RELATIVE cpu_data = (cpu_data_t GS_RELATIVE )0UL;
	504	if (0 == --cpu_data->cpu_preemption_level)
	505	kernel_preempt_check();
	506	#else
91447636 A	507	__asm__ volatile ("decl %%gs:%P0 \n\t"
	508	"jne 1f \n\t"
	509	"call _kernel_preempt_check \n\t"
	510	"1:"
1c79356b	511	: /* no outputs */
91447636 A	512	: "i" (offsetof(cpu_data_t, cpu_preemption_level))
91447636 A	513	: "eax", "ecx", "edx", "cc", "memory");
39236c6e	514	#endif
1c79356b A	515	}
1c79356b A	516
91447636 A	517	static inline void
91447636 A	518	enable_preemption_no_check(void)
1c79356b	519	{
1c79356b	520	assert(get_preemption_level() > 0);
1c79356b	521
39037602	522	pltrace(TRUE);
39236c6e A	523	#if defined(__clang__)
	524	cpu_data_t GS_RELATIVE cpu_data = (cpu_data_t GS_RELATIVE )0UL;
	525	cpu_data->cpu_preemption_level--;
	526	#else
91447636	527	__asm__ volatile ("decl %%gs:%P0"
1c79356b	528	: /* no outputs */
91447636	529	: "i" (offsetof(cpu_data_t, cpu_preemption_level))
1c79356b	530	: "cc", "memory");
39236c6e	531	#endif
1c79356b A	532	}
1c79356b A	533
39037602 A	534	static inline void
	535	_enable_preemption_no_check(void) {
	536	enable_preemption_no_check();
	537	}
	538
91447636 A	539	static inline void
91447636 A	540	mp_disable_preemption(void)
1c79356b	541	{
39037602	542	disable_preemption_internal();
1c79356b A	543	}
1c79356b A	544
91447636	545	static inline void
39037602	546	_mp_disable_preemption(void)
1c79356b	547	{
39037602	548	disable_preemption_internal();
1c79356b A	549	}
1c79356b A	550
91447636	551	static inline void
39037602	552	mp_enable_preemption(void)
1c79356b	553	{
39037602 A	554	enable_preemption_internal();
	555	}
	556
	557	static inline void
	558	_mp_enable_preemption(void) {
	559	enable_preemption_internal();
	560	}
	561
	562	static inline void
	563	mp_enable_preemption_no_check(void) {
1c79356b	564	enable_preemption_no_check();
1c79356b A	565	}
1c79356b A	566
39037602 A	567	static inline void
	568	_mp_enable_preemption_no_check(void) {
	569	enable_preemption_no_check();
91447636 A	570	}
91447636 A	571
39037602 A	572	#ifdef XNU_KERNEL_PRIVATE
	573	#define disable_preemption() disable_preemption_internal()
	574	#define enable_preemption() enable_preemption_internal()
	575	#define MACHINE_PREEMPTION_MACROS (1)
	576	#endif
	577
	578
91447636	579	static inline cpu_data_t *
39037602	580	cpu_datap(int cpu) {
91447636 A	581	return cpu_data_ptr[cpu];
	582	}
	583
	584	extern cpu_data_t *cpu_data_alloc(boolean_t is_boot_cpu);
316670eb	585	extern void cpu_data_realloc(void);
1c79356b	586
1c79356b	587	#endif /* I386_CPU_DATA */