1/*
2 * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
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/*
29 * @OSF_COPYRIGHT@
30 */
31
32#ifndef _KERN_KERN_TYPES_H_
33#define _KERN_KERN_TYPES_H_
34
35#include <stdint.h>
36#include <mach/mach_types.h>
37#include <mach/machine/vm_types.h>
38
39#ifdef KERNEL_PRIVATE
40
41#ifndef MACH_KERNEL_PRIVATE
42
43struct zone ;
44
45#ifndef __LP64__
46struct wait_queue { unsigned int opaque[2]; uintptr_t opaquep[2]; } ;
47#else
48struct wait_queue { unsigned char opaque[32]; };
49#endif
50
51#endif /* MACH_KERNEL_PRIVATE */
52
53typedef struct zone *zone_t;
54#define ZONE_NULL ((zone_t) 0)
55
56typedef struct wait_queue *wait_queue_t;
57#define WAIT_QUEUE_NULL ((wait_queue_t) 0)
58#define SIZEOF_WAITQUEUE sizeof(struct wait_queue)
59
60typedef vm_offset_t ipc_kobject_t;
61#define IKO_NULL ((ipc_kobject_t) 0)
62
63#endif /* KERNEL_PRIVATE */
64
65typedef void *event_t; /* wait event */
66#define NO_EVENT ((event_t) 0)
67
68typedef uint64_t event64_t; /* 64 bit wait event */
69#define NO_EVENT64 ((event64_t) 0)
70#define CAST_EVENT64_T(a_ptr) ((event64_t)((uintptr_t)(a_ptr)))
71
72/*
73 * Possible wait_result_t values.
74 */
75typedef int wait_result_t;
76#define THREAD_WAITING -1 /* thread is waiting */
77#define THREAD_AWAKENED 0 /* normal wakeup */
78#define THREAD_TIMED_OUT 1 /* timeout expired */
79#define THREAD_INTERRUPTED 2 /* aborted/interrupted */
80#define THREAD_RESTART 3 /* restart operation entirely */
81#define THREAD_NOT_WAITING 10 /* thread didn't need to wait */
82
83typedef void (*thread_continue_t)(void *, wait_result_t);
84#define THREAD_CONTINUE_NULL ((thread_continue_t) 0)
85
86/*
87 * Interruptible flag for waits.
88 *
89 * THREAD_UNINT: Uninterruptible wait
90 * Wait will only end when someone explicitly wakes up the thread, or if the
91 * wait timeout expires.
92 *
93 * Use this state if the system as a whole cannot recover from a thread being
94 * interrupted out of the wait.
95 *
96 * THREAD_INTERRUPTIBLE:
97 * Wait will end if someone explicitly wakes up the thread, the wait timeout
98 * expires, or the current thread is being terminated.
99 *
100 * This value can be used when your operation may not be cleanly restartable
101 * for the current process or thread (i.e. the loss of state would be only visible
102 * to the current client). Since the thread is exiting anyways, you're willing
103 * to cut the operation short. The system as a whole must be able to cleanly
104 * deal with the interruption (i.e. remain in a consistent and recoverable state).
105 *
106 * THREAD_ABORTSAFE:
107 * Wait will end if someone explicitly wakes up the thread, the wait timeout
108 * expires, the current thread is being terminated, if any signal arrives for
109 * the task, or thread_abort_safely() is called on the thread.
110 *
111 * Using this value means that you are willing to be interrupted in the face
112 * of any user signal, and safely rewind the thread back to the user/kernel
113 * boundary. Many syscalls will try to restart the operation they were performing
114 * after the signal has been handled.
115 *
116 * You must provide this value for any unbounded wait - otherwise you will
117 * pend user signals forever.
118 *
119 * THREAD_WAIT_NOREPORT:
120 * The scheduler has a callback (sched_call) that some subsystems use to
121 * decide whether more threads should be thrown at a given problem by trying
122 * to maintain a good level of concurrency.
123 *
124 * When the wait will not be helped by adding more threads (e.g. lock
125 * contention), using this flag as an argument to assert_wait* (or any of its
126 * wrappers) will prevent the next wait/block to cause thread creation.
127 *
128 * This comes in two flavors: THREAD_WAIT_NOREPORT_KERNEL, and
129 * THREAD_WAIT_NOREPORT_USER to prevent reporting about the wait for kernel
130 * and user threads respectively.
131 *
132 * Thread interrupt mask:
133 *
134 * The current maximum interruptible state for the thread, as set by
135 * thread_interrupt_level(), will limit the conditions that will cause a wake.
136 * This is useful for code that can't be interrupted to set before calling code
137 * that doesn't know that.
138 *
139 * Thread termination vs safe abort:
140 *
141 * Termination abort: thread_abort(), thread_terminate()
142 *
143 * A termination abort is sticky. Once a thread is marked for termination, every
144 * THREAD_INTERRUPTIBLE wait will return immediately with THREAD_INTERRUPTED
145 * until the thread successfully exits.
146 *
147 * Safe abort: thread_abort_safely()
148 *
149 * A safe abort is not sticky. The current wait, (or the next wait if the thread
150 * is not currently waiting) will be interrupted, but then the abort condition is cleared.
151 * The next wait will sleep as normal. Safe aborts only have a single effect.
152 *
153 * The path back to the user/kernel boundary must not make any further unbounded
154 * wait calls. The waiter should detect the THREAD_INTERRUPTED return code
155 * from an ABORTSAFE wait and return an error code that causes its caller
156 * to understand that the current operation has been interrupted, and its
157 * caller should return a similar error code, and so on until the
158 * user/kernel boundary is reached. For Mach, the error code is usually KERN_ABORTED,
159 * for BSD it is EINTR.
160 *
161 * Debuggers rely on the safe abort mechanism - a signaled thread must return to
162 * the AST at the user/kernel boundary for the debugger to finish attaching.
163 *
164 * No wait/block will ever disappear a thread out from under the waiter. The block
165 * call will always either return or call the passed in continuation.
166 */
167typedef int wait_interrupt_t;
168#define THREAD_UNINT 0x00000000 /* not interruptible */
169#define THREAD_INTERRUPTIBLE 0x00000001 /* may not be restartable */
170#define THREAD_ABORTSAFE 0x00000002 /* abortable safely */
171#define THREAD_WAIT_NOREPORT_KERNEL 0x80000000
172#define THREAD_WAIT_NOREPORT_USER 0x40000000
173#define THREAD_WAIT_NOREPORT (THREAD_WAIT_NOREPORT_KERNEL | THREAD_WAIT_NOREPORT_USER)
174
175typedef int wait_timeout_urgency_t;
176#define TIMEOUT_URGENCY_SYS_NORMAL 0x00 /* use default leeway thresholds for system */
177#define TIMEOUT_URGENCY_SYS_CRITICAL 0x01 /* use critical leeway thresholds for system */
178#define TIMEOUT_URGENCY_SYS_BACKGROUND 0x02 /* use background leeway thresholds for system */
179
180#define TIMEOUT_URGENCY_USER_MASK 0x10 /* mask to identify user timeout urgency classes */
181#define TIMEOUT_URGENCY_USER_NORMAL 0x10 /* use default leeway thresholds for user */
182#define TIMEOUT_URGENCY_USER_CRITICAL 0x11 /* use critical leeway thresholds for user */
183#define TIMEOUT_URGENCY_USER_BACKGROUND 0x12 /* use background leeway thresholds for user */
184
185#define TIMEOUT_URGENCY_MASK 0x13 /* mask to identify timeout urgency */
186
187#define TIMEOUT_URGENCY_LEEWAY 0x20 /* don't ignore provided leeway value */
188
189#define TIMEOUT_URGENCY_FIRST_AVAIL 0x40 /* first available bit outside of urgency mask/leeway */
190#define TIMEOUT_URGENCY_RATELIMITED 0x80
191
192/*
193 * Timeout and deadline tokens for waits.
194 * The following tokens define common values for leeway and deadline parameters.
195 */
196#define TIMEOUT_NO_LEEWAY (0ULL)
197#define TIMEOUT_WAIT_FOREVER (0ULL)
198
199#ifdef KERNEL_PRIVATE
200
201/*
202 * n.b. this is defined in thread_call.h, but in the TIMEOUT_URGENCY flags space:
203 * #define THREAD_CALL_CONTINUOUS 0x100
204 */
205
206#ifdef MACH_KERNEL_PRIVATE
207
208#include <kern/misc_protos.h>
209typedef struct clock *clock_t;
210
211typedef struct mig_object *mig_object_t;
212#define MIG_OBJECT_NULL ((mig_object_t) 0)
213
214typedef struct mig_notify *mig_notify_t;
215#define MIG_NOTIFY_NULL ((mig_notify_t) 0)
216
217typedef struct pset_node *pset_node_t;
218#define PSET_NODE_NULL ((pset_node_t) 0)
219
220typedef struct affinity_set *affinity_set_t;
221#define AFFINITY_SET_NULL ((affinity_set_t) 0)
222
223typedef struct run_queue *run_queue_t;
224#define RUN_QUEUE_NULL ((run_queue_t) 0)
225
226typedef struct grrr_run_queue *grrr_run_queue_t;
227#define GRRR_RUN_QUEUE_NULL ((grrr_run_queue_t) 0)
228
229typedef struct grrr_group *grrr_group_t;
230#define GRRR_GROUP_NULL ((grrr_group_t) 0)
231
232#if defined(CONFIG_SCHED_MULTIQ)
233typedef struct sched_group *sched_group_t;
234#define SCHED_GROUP_NULL ((sched_group_t) 0)
235#endif /* defined(CONFIG_SCHED_MULTIQ) */
236
237#else /* MACH_KERNEL_PRIVATE */
238
239struct wait_queue_set ;
240struct _wait_queue_link ;
241
242#endif /* MACH_KERNEL_PRIVATE */
243
244typedef struct wait_queue_set *wait_queue_set_t;
245#define WAIT_QUEUE_SET_NULL ((wait_queue_set_t)0)
246#define SIZEOF_WAITQUEUE_SET wait_queue_set_size()
247
248typedef struct _wait_queue_link *wait_queue_link_t;
249#define WAIT_QUEUE_LINK_NULL ((wait_queue_link_t)0)
250#define SIZEOF_WAITQUEUE_LINK wait_queue_link_size()
251
252typedef struct perfcontrol_state *perfcontrol_state_t;
253#define PERFCONTROL_STATE_NULL ((perfcontrol_state_t)0)
254
255/*
256 * Enum to define the event which caused the CLPC callout
257 */
258typedef enum perfcontrol_event {
259 /*
260 * Thread State Update Events
261 * Used to indicate events that update properties for
262 * a given thread. These events are passed as part of the
263 * sched_perfcontrol_state_update_t callout
264 */
265 QUANTUM_EXPIRY = 1,
266 THREAD_GROUP_UPDATE = 2,
267 PERFCONTROL_ATTR_UPDATE = 3,
268 /*
269 * Context Switch Events
270 * Used to indicate events that switch from one thread
271 * to the other. These events are passed as part of the
272 * sched_perfcontrol_csw_t callout.
273 */
274 CONTEXT_SWITCH = 10,
275 IDLE = 11
276} perfcontrol_event;
277
278/*
279 * Flags for the sched_perfcontrol_csw_t & sched_perfcontrol_state_update_t
280 * callouts.
281 * Currently defined flags are:
282 * PERFCONTROL_CALLOUT_WAKE_UNSAFE - Flag to indicate its unsafe to
283 * do a wakeup as part of this callout. If this is set, it
284 * indicates that the scheduler holds a spinlock which might be needed
285 * in the wakeup path. In that case CLPC should do a thread_call
286 * instead of a direct wakeup to run their workloop thread.
287 */
288#define PERFCONTROL_CALLOUT_WAKE_UNSAFE 0x1
289
290/*
291 * Enum to define the perfcontrol class for thread.
292 * thread_get_perfcontrol_class() takes the thread's
293 * priority, QoS, urgency etc. into consideration and
294 * produces a value in this enum.
295 */
296typedef enum perfcontrol_class {
297 /* Idle thread */
298 PERFCONTROL_CLASS_IDLE = 1,
299 /* Kernel thread */
300 PERFCONTROL_CLASS_KERNEL = 2,
301 /* Realtime Thread */
302 PERFCONTROL_CLASS_REALTIME = 3,
303 /* Background Thread */
304 PERFCONTROL_CLASS_BACKGROUND = 4,
305 /* Utility Thread */
306 PERFCONTROL_CLASS_UTILITY = 5,
307 /* Non-UI Thread (Default/Legacy) */
308 PERFCONTROL_CLASS_NONUI = 6,
309 /* UI Thread (UI/IN) */
310 PERFCONTROL_CLASS_UI = 7,
311 /* Above UI Thread */
312 PERFCONTROL_CLASS_ABOVEUI = 8,
313} perfcontrol_class_t;
314
315#endif /* KERNEL_PRIVATE */
316
317#endif /* _KERN_KERN_TYPES_H_ */
318