1 /*
2 * Copyright (c) 2000-2019 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_FREE_COPYRIGHT@
30 */
31 /*
32 * Mach Operating System
33 * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
34 * All Rights Reserved.
35 *
36 * Permission to use, copy, modify and distribute this software and its
37 * documentation is hereby granted, provided that both the copyright
38 * notice and this permission notice appear in all copies of the
39 * software, derivative works or modified versions, and any portions
40 * thereof, and that both notices appear in supporting documentation.
41 *
42 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
43 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
44 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
45 *
46 * Carnegie Mellon requests users of this software to return to
47 *
48 * Software Distribution Coordinator or [email protected]
49 * School of Computer Science
50 * Carnegie Mellon University
51 * Pittsburgh PA 15213-3890
52 *
53 * any improvements or extensions that they make and grant Carnegie Mellon
54 * the rights to redistribute these changes.
55 */
56 /*
57 */
58 /*
59 * File: thread.h
60 * Author: Avadis Tevanian, Jr.
61 *
62 * This file contains the structure definitions for threads.
63 *
64 */
65 /*
66 * Copyright (c) 1993 The University of Utah and
67 * the Computer Systems Laboratory (CSL). All rights reserved.
68 *
69 * Permission to use, copy, modify and distribute this software and its
70 * documentation is hereby granted, provided that both the copyright
71 * notice and this permission notice appear in all copies of the
72 * software, derivative works or modified versions, and any portions
73 * thereof, and that both notices appear in supporting documentation.
74 *
75 * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
76 * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
77 * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
78 *
79 * CSL requests users of this software to return to [email protected] any
80 * improvements that they make and grant CSL redistribution rights.
81 *
82 */
83
84 #ifndef _KERN_THREAD_H_
85 #define _KERN_THREAD_H_
86
87 #include <mach/kern_return.h>
88 #include <mach/mach_types.h>
89 #include <mach/mach_param.h>
90 #include <mach/message.h>
91 #include <mach/boolean.h>
92 #include <mach/vm_param.h>
93 #include <mach/thread_info.h>
94 #include <mach/thread_status.h>
95 #include <mach/exception_types.h>
96
97 #include <kern/kern_types.h>
98 #include <vm/vm_kern.h>
99 #include <sys/cdefs.h>
100 #include <sys/_types/_size_t.h>
101
102 #ifdef MACH_KERNEL_PRIVATE
103 #include <mach_assert.h>
104 #include <mach_ldebug.h>
105
106 #include <ipc/ipc_types.h>
107
108 #include <mach/port.h>
109 #include <kern/cpu_number.h>
110 #include <kern/smp.h>
111 #include <kern/queue.h>
112
113 #include <kern/timer.h>
114 #include <kern/simple_lock.h>
115 #include <kern/locks.h>
116 #include <kern/sched.h>
117 #include <kern/sched_prim.h>
118 #include <mach/sfi_class.h>
119 #include <kern/thread_call.h>
120 #include <kern/thread_group.h>
121 #include <kern/timer_call.h>
122 #include <kern/task.h>
123 #include <kern/exception.h>
124 #include <kern/affinity.h>
125 #include <kern/debug.h>
126 #include <kern/block_hint.h>
127 #include <kern/recount.h>
128 #include <kern/turnstile.h>
129 #include <kern/mpsc_queue.h>
130
131 #include <kern/waitq.h>
132 #include <san/kasan.h>
133 #include <san/kcov_data.h>
134 #include <os/refcnt.h>
135
136 #include <ipc/ipc_kmsg.h>
137
138 #include <machine/atomic.h>
139 #include <machine/cpu_data.h>
140 #include <machine/thread.h>
141
142 #endif /* MACH_KERNEL_PRIVATE */
143 #ifdef XNU_KERNEL_PRIVATE
144 /* priority queue static asserts fail for __ARM64_ARCH_8_32__ kext builds */
145 #include <kern/priority_queue.h>
146 #endif /* XNU_KERNEL_PRIVATE */
147
148 __BEGIN_DECLS
149
150 #ifdef XNU_KERNEL_PRIVATE
151 #if CONFIG_TASKWATCH
152 /* Taskwatch related. TODO: find this a better home */
153 typedef struct task_watcher task_watch_t;
154 #endif /* CONFIG_TASKWATCH */
155
156 /* Thread tags; for easy identification. */
157 __options_closed_decl(thread_tag_t, uint16_t, {
158 THREAD_TAG_MAINTHREAD = 0x01,
159 THREAD_TAG_CALLOUT = 0x02,
160 THREAD_TAG_IOWORKLOOP = 0x04,
161 THREAD_TAG_PTHREAD = 0x10,
162 THREAD_TAG_WORKQUEUE = 0x20,
163 THREAD_TAG_USER_JOIN = 0x40,
164 });
165
166 __options_closed_decl(thread_ro_flags_t, uint16_t, {
167 TRO_NONE = 0x0000,
168 TRO_SETUID = 0x0001,
169 });
170
171 typedef struct thread_ro *thread_ro_t;
172
173 /*!
174 * @struct thread_ro
175 *
176 * @brief
177 * A structure allocated in a read only zone that safely
178 * represents the linkages of a thread to its cred, proc, task, ...
179 *
180 * @discussion
181 * The lifetime of a @c thread_ro structure is 1:1 with that
182 * of a @c thread_t or a @c uthread_t and holding a thread reference
183 * always allows to dereference this structure safely.
184 */
185 struct thread_ro {
186 struct thread *tro_owner;
187 #if MACH_BSD
188 struct ucred *tro_cred;
189 struct proc *tro_proc;
190 struct proc_ro *tro_proc_ro;
191 #endif
192 struct task *tro_task;
193 thread_ro_flags_t tro_flags;
194
195 struct ipc_port *tro_self_port;
196 struct ipc_port *tro_settable_self_port; /* send right */
197 struct ipc_port *tro_ports[THREAD_SELF_PORT_COUNT]; /* no right */
198
199 struct exception_action *tro_exc_actions;
200 };
201
202 /*
203 * Flags for `thread set status`.
204 */
205 __options_decl(thread_set_status_flags_t, uint32_t, {
206 TSSF_FLAGS_NONE = 0,
207
208 /* Translate the state to user. */
209 TSSF_TRANSLATE_TO_USER = 0x01,
210
211 /* Translate the state to user. Preserve flags */
212 TSSF_PRESERVE_FLAGS = 0x02,
213
214 /* Check kernel signed flag */
215 TSSF_CHECK_USER_FLAGS = 0x04,
216
217 /* Allow only user state PTRS */
218 TSSF_ALLOW_ONLY_USER_PTRS = 0x08,
219
220 /* Generate random diversifier and stash it */
221 TSSF_RANDOM_USER_DIV = 0x10,
222
223 /* Stash sigreturn token */
224 TSSF_STASH_SIGRETURN_TOKEN = 0x20,
225
226 /* Check sigreturn token */
227 TSSF_CHECK_SIGRETURN_TOKEN = 0x40,
228
229 /* Allow only matching sigreturn token */
230 TSSF_ALLOW_ONLY_MATCHING_TOKEN = 0x80,
231
232 /* Stash diversifier from thread */
233 TSSF_THREAD_USER_DIV = 0x100,
234
235 /* Check for entitlement */
236 TSSF_CHECK_ENTITLEMENT = 0x200,
237 });
238
239 /*
240 * Size in bits of compact thread id (ctid).
241 */
242 #define CTID_SIZE_BIT 20
243 typedef uint32_t ctid_t;
244
245 #endif /* XNU_KERNEL_PRIVATE */
246 #ifdef MACH_KERNEL_PRIVATE
247
248 extern zone_t thread_ro_zone;
249
250 __options_decl(thread_work_interval_flags_t, uint32_t, {
251 TH_WORK_INTERVAL_FLAGS_NONE = 0x0,
252 #if CONFIG_SCHED_AUTO_JOIN
253 /* Flags to indicate status about work interval thread is currently part of */
254 TH_WORK_INTERVAL_FLAGS_AUTO_JOIN_LEAK = 0x1,
255 #endif /* CONFIG_SCHED_AUTO_JOIN */
256 TH_WORK_INTERVAL_FLAGS_HAS_WORKLOAD_ID = 0x2,
257 TH_WORK_INTERVAL_FLAGS_RT_ALLOWED = 0x4,
258 });
259
260 typedef union thread_rr_state {
261 uint32_t trr_value;
262 struct {
263 #define TRR_FAULT_NONE 0
264 #define TRR_FAULT_PENDING 1
265 #define TRR_FAULT_OBSERVED 2
266 /*
267 * Set to TRR_FAULT_PENDING with interrupts disabled
268 * by the thread when it is entering a user fault codepath.
269 *
270 * Moved to TRR_FAULT_OBSERVED from TRR_FAULT_PENDING:
271 * - by the thread if at IPI time,
272 * - or by task_restartable_ranges_synchronize() if the thread
273 * is interrupted (under the thread lock)
274 *
275 * Cleared by the thread when returning from a user fault
276 * codepath.
277 */
278 uint8_t trr_fault_state;
279
280 /*
281 * Set by task_restartable_ranges_synchronize()
282 * if trr_fault_state is TRR_FAULT_OBSERVED
283 * and a rendez vous at the AST is required.
284 *
285 * Set atomically if trr_fault_state == TRR_FAULT_OBSERVED,
286 * and trr_ipi_ack_pending == 0
287 */
288 uint8_t trr_sync_waiting;
289
290 /*
291 * Updated under the thread_lock(),
292 * set by task_restartable_ranges_synchronize()
293 * when the thread was IPIed and the caller is waiting
294 * for an ACK.
295 */
296 uint16_t trr_ipi_ack_pending;
297 };
298 } thread_rr_state_t;
299
300 struct thread {
301 #if MACH_ASSERT
302 #define THREAD_MAGIC 0x1234ABCDDCBA4321ULL
303 /* Ensure nothing uses &thread as a queue entry */
304 uint64_t thread_magic;
305 #endif /* MACH_ASSERT */
306
307 /*
308 * NOTE: The runq field in the thread structure has an unusual
309 * locking protocol. If its value is PROCESSOR_NULL, then it is
310 * locked by the thread_lock, but if its value is something else
311 * then it is locked by the associated run queue lock. It is
312 * set to PROCESSOR_NULL without holding the thread lock, but the
313 * transition from PROCESSOR_NULL to non-null must be done
314 * under the thread lock and the run queue lock.
315 *
316 * New waitq APIs allow the 'links' and 'runq' fields to be
317 * anywhere in the thread structure.
318 */
319 union {
320 queue_chain_t runq_links; /* run queue links */
321 queue_chain_t wait_links; /* wait queue links */
322 struct mpsc_queue_chain mpsc_links; /* thread daemon mpsc links */
323 struct priority_queue_entry_sched wait_prioq_links; /* priority ordered waitq links */
324 };
325
326 event64_t wait_event; /* wait queue event */
327 processor_t runq; /* run queue assignment */
328 waitq_t waitq; /* wait queue this thread is enqueued on */
329 struct turnstile *turnstile; /* thread's turnstile, protected by primitives interlock */
330 void *inheritor; /* inheritor of the primitive the thread will block on */
331 struct priority_queue_sched_max sched_inheritor_queue; /* Inheritor queue for kernel promotion */
332 struct priority_queue_sched_max base_inheritor_queue; /* Inheritor queue for user promotion */
333
334 #if CONFIG_SCHED_EDGE
335 bool th_bound_cluster_enqueued;
336 bool th_shared_rsrc_enqueued[CLUSTER_SHARED_RSRC_TYPE_COUNT];
337 bool th_shared_rsrc_heavy_user[CLUSTER_SHARED_RSRC_TYPE_COUNT];
338 bool th_shared_rsrc_heavy_perf_control[CLUSTER_SHARED_RSRC_TYPE_COUNT];
339 #endif /* CONFIG_SCHED_EDGE */
340
341 #if CONFIG_SCHED_CLUTCH
342 /*
343 * In the clutch scheduler, the threads are maintained in runqs at the clutch_bucket
344 * level (clutch_bucket defines a unique thread group and scheduling bucket pair). The
345 * thread is linked via a couple of linkages in the clutch bucket:
346 *
347 * - A stable priority queue linkage which is the main runqueue (based on sched_pri) for the clutch bucket
348 * - A regular priority queue linkage which is based on thread's base/promoted pri (used for clutch bucket priority calculation)
349 * - A queue linkage used for timesharing operations of threads at the scheduler tick
350 */
351 struct priority_queue_entry_stable th_clutch_runq_link;
352 struct priority_queue_entry_sched th_clutch_pri_link;
353 queue_chain_t th_clutch_timeshare_link;
354 #endif /* CONFIG_SCHED_CLUTCH */
355
356 /* Data updated during assert_wait/thread_wakeup */
357 decl_simple_lock_data(, sched_lock); /* scheduling lock (thread_lock()) */
358 decl_simple_lock_data(, wake_lock); /* for thread stop / wait (wake_lock()) */
359 uint16_t options; /* options set by thread itself */
360 #define TH_OPT_INTMASK 0x0003 /* interrupt / abort level */
361 #define TH_OPT_VMPRIV 0x0004 /* may allocate reserved memory */
362 #define TH_OPT_SYSTEM_CRITICAL 0x0010 /* Thread must always be allowed to run - even under heavy load */
363 #define TH_OPT_PROC_CPULIMIT 0x0020 /* Thread has a task-wide CPU limit applied to it */
364 #define TH_OPT_PRVT_CPULIMIT 0x0040 /* Thread has a thread-private CPU limit applied to it */
365 #define TH_OPT_IDLE_THREAD 0x0080 /* Thread is a per-processor idle thread */
366 #define TH_OPT_GLOBAL_FORCED_IDLE 0x0100 /* Thread performs forced idle for thermal control */
367 #define TH_OPT_SCHED_VM_GROUP 0x0200 /* Thread belongs to special scheduler VM group */
368 #define TH_OPT_HONOR_QLIMIT 0x0400 /* Thread will honor qlimit while sending mach_msg, regardless of MACH_SEND_ALWAYS */
369 #define TH_OPT_SEND_IMPORTANCE 0x0800 /* Thread will allow importance donation from kernel rpc */
370 #define TH_OPT_ZONE_PRIV 0x1000 /* Thread may use the zone replenish reserve */
371 #define TH_OPT_IPC_TG_BLOCKED 0x2000 /* Thread blocked in sync IPC and has made the thread group blocked callout */
372 #define TH_OPT_FORCED_LEDGER 0x4000 /* Thread has a forced CPU limit */
373 #define TH_IN_MACH_EXCEPTION 0x8000 /* Thread is currently handling a mach exception */
374
375 bool wake_active; /* wake event on stop */
376 bool at_safe_point; /* thread_abort_safely allowed */
377 uint8_t sched_saved_run_weight;
378 #if DEVELOPMENT || DEBUG
379 bool pmap_footprint_suspended;
380 #endif /* DEVELOPMENT || DEBUG */
381
382
383 ast_t reason; /* why we blocked */
384 uint32_t quantum_remaining;
385 wait_result_t wait_result; /* outcome of wait -
386 * may be examined by this thread
387 * WITHOUT locking */
388 thread_rr_state_t t_rr_state; /* state for restartable ranges */
389 thread_continue_t continuation; /* continue here next dispatch */
390 void *parameter; /* continuation parameter */
391
392 /* Data updated/used in thread_invoke */
393 vm_offset_t kernel_stack; /* current kernel stack */
394 vm_offset_t reserved_stack; /* reserved kernel stack */
395
396 /*** Machine-dependent state ***/
397 struct machine_thread machine;
398
399 #if KASAN
400 struct kasan_thread_data kasan_data;
401 #endif
402 #if CONFIG_KCOV
403 kcov_thread_data_t kcov_data;
404 #endif
405
406 /* Thread state: */
407 int state;
408 /*
409 * Thread states [bits or'ed]
410 * All but TH_WAIT_REPORT are encoded in SS_TH_FLAGS
411 * All are encoded in kcdata.py ('ths_state')
412 */
413 #define TH_WAIT 0x01 /* queued for waiting */
414 #define TH_SUSP 0x02 /* stopped or requested to stop */
415 #define TH_RUN 0x04 /* running or on runq */
416 #define TH_UNINT 0x08 /* waiting uninteruptibly */
417 #define TH_TERMINATE 0x10 /* halted at termination */
418 #define TH_TERMINATE2 0x20 /* added to termination queue */
419 #define TH_WAIT_REPORT 0x40 /* the wait is using the sched_call,
420 * only set if TH_WAIT is also set */
421 #define TH_IDLE 0x80 /* idling processor */
422 #define TH_WAKING 0x100 /* between waitq remove and thread_go */
423
424 /* Scheduling information */
425 sched_mode_t sched_mode; /* scheduling mode */
426 sched_mode_t saved_mode; /* saved mode during forced mode demotion */
427
428 /* This thread's contribution to global sched counters */
429 sched_bucket_t th_sched_bucket;
430
431 sfi_class_id_t sfi_class; /* SFI class (XXX Updated on CSW/QE/AST) */
432 sfi_class_id_t sfi_wait_class; /* Currently in SFI wait for this class, protected by sfi_lock */
433
434 uint32_t sched_flags; /* current flag bits */
435 #define TH_SFLAG_NO_SMT 0x0001 /* On an SMT CPU, this thread must be scheduled alone */
436 #define TH_SFLAG_FAILSAFE 0x0002 /* fail-safe has tripped */
437 #define TH_SFLAG_THROTTLED 0x0004 /* throttled thread forced to timeshare mode (may be applied in addition to failsafe) */
438
439 #define TH_SFLAG_PROMOTED 0x0008 /* sched pri has been promoted by kernel mutex priority promotion */
440 #define TH_SFLAG_ABORT 0x0010 /* abort interruptible waits */
441 #define TH_SFLAG_ABORTSAFELY 0x0020 /* ... but only those at safe point */
442 #define TH_SFLAG_ABORTED_MASK (TH_SFLAG_ABORT | TH_SFLAG_ABORTSAFELY)
443 #define TH_SFLAG_DEPRESS 0x0040 /* normal depress yield */
444 #define TH_SFLAG_POLLDEPRESS 0x0080 /* polled depress yield */
445 #define TH_SFLAG_DEPRESSED_MASK (TH_SFLAG_DEPRESS | TH_SFLAG_POLLDEPRESS)
446 /* unused TH_SFLAG_PRI_UPDATE 0x0100 */
447 #define TH_SFLAG_EAGERPREEMPT 0x0200 /* Any preemption of this thread should be treated as if AST_URGENT applied */
448 #define TH_SFLAG_RW_PROMOTED 0x0400 /* promote reason: blocking with RW lock held */
449 #define TH_SFLAG_BASE_PRI_FROZEN 0x0800 /* (effective) base_pri is frozen */
450 #define TH_SFLAG_WAITQ_PROMOTED 0x1000 /* promote reason: waitq wakeup (generally for IPC receive) */
451
452 #if __AMP__
453 #define TH_SFLAG_ECORE_ONLY 0x2000 /* (unused) Bind thread to E core processor set */
454 #define TH_SFLAG_PCORE_ONLY 0x4000 /* (unused) Bind thread to P core processor set */
455 #endif
456
457 #define TH_SFLAG_EXEC_PROMOTED 0x8000 /* promote reason: thread is in an exec */
458
459 #define TH_SFLAG_THREAD_GROUP_AUTO_JOIN 0x10000 /* thread has been auto-joined to thread group */
460 #if __AMP__
461 #define TH_SFLAG_BOUND_SOFT 0x20000 /* thread is soft bound to a cluster; can run anywhere if bound cluster unavailable */
462 #endif /* __AMP__ */
463
464 #if CONFIG_PREADOPT_TG
465 #define TH_SFLAG_REEVALUTE_TG_HIERARCHY_LATER 0x40000 /* thread needs to reevaluate its TG hierarchy */
466 #endif
467
468 #define TH_SFLAG_FLOOR_PROMOTED 0x80000 /* promote reason: boost requested */
469
470 /* 'promote reasons' that request a priority floor only, not a custom priority */
471 #define TH_SFLAG_PROMOTE_REASON_MASK (TH_SFLAG_RW_PROMOTED | TH_SFLAG_WAITQ_PROMOTED | TH_SFLAG_EXEC_PROMOTED | TH_SFLAG_FLOOR_PROMOTED)
472
473 #define TH_SFLAG_RT_DISALLOWED 0x100000 /* thread wants RT but may not have joined a work interval that allows it */
474 #define TH_SFLAG_DEMOTED_MASK (TH_SFLAG_THROTTLED | TH_SFLAG_FAILSAFE | TH_SFLAG_RT_DISALLOWED) /* saved_mode contains previous sched_mode */
475
476 int16_t sched_pri; /* scheduled (current) priority */
477 int16_t base_pri; /* effective base priority (equal to req_base_pri unless TH_SFLAG_BASE_PRI_FROZEN) */
478 int16_t req_base_pri; /* requested base priority */
479 int16_t max_priority; /* copy of max base priority */
480 int16_t task_priority; /* copy of task base priority */
481 int16_t promotion_priority; /* priority thread is currently promoted to */
482 uint16_t priority_floor_count; /* number of push to boost the floor priority */
483 int16_t suspend_count; /* Kernel holds on this thread */
484
485 int iotier_override; /* atomic operations to set, cleared on ret to user */
486 os_ref_atomic_t ref_count; /* number of references to me */
487
488 uint32_t rwlock_count; /* Number of lck_rw_t locks held by thread */
489 #ifdef DEBUG_RW
490 rw_lock_debug_t rw_lock_held; /* rw_locks currently held by the thread */
491 #endif /* DEBUG_RW */
492
493 integer_t importance; /* task-relative importance */
494
495 /* Priority depression expiration */
496 integer_t depress_timer_active;
497 timer_call_t depress_timer;
498
499 /* real-time parameters */
500 struct { /* see mach/thread_policy.h */
501 uint32_t period;
502 uint32_t computation;
503 uint32_t constraint;
504 bool preemptible;
505 uint8_t priority_offset; /* base_pri = BASEPRI_RTQUEUES + priority_offset */
506 uint64_t deadline;
507 } realtime;
508
509 uint64_t last_run_time; /* time when thread was switched away from */
510 uint64_t last_made_runnable_time; /* time when thread was unblocked or preempted */
511 uint64_t last_basepri_change_time; /* time when thread was last changed in basepri while runnable */
512 uint64_t same_pri_latency;
513 /*
514 * workq_quantum_deadline is the workq thread's next runtime deadline. This
515 * value is set to 0 if the thread has no such deadline applicable to it.
516 *
517 * The synchronization for this field is due to how this field is modified
518 * 1) This field is always modified on the thread by itself or on the thread
519 * when it is not running/runnable
520 * 2) Change of this field is immediately followed by a
521 * corresponding change to the AST_KEVENT to either set or clear the
522 * AST_KEVENT_WORKQ_QUANTUM_EXPIRED bit
523 *
524 * workq_quantum_deadline can be modified by the thread on itself during
525 * interrupt context. However, due to (2) and due to the fact that the
526 * change to the AST_KEVENT is volatile, this forces the compiler to
527 * guarantee the order between the write to workq_quantum_deadline and the
528 * kevent field and therefore guarantees the correct synchronization.
529 */
530 uint64_t workq_quantum_deadline;
531
532 #if WORKQ_QUANTUM_HISTORY_DEBUG
533
534 #define WORKQ_QUANTUM_HISTORY_COUNT 16
535 struct workq_quantum_history {
536 uint64_t time;
537 uint64_t deadline;
538 bool arm;
539 } workq_quantum_history[WORKQ_QUANTUM_HISTORY_COUNT];
540 uint64_t workq_quantum_history_index;
541
542 #define WORKQ_QUANTUM_HISTORY_WRITE_ENTRY(thread, ...) ({\
543 thread_t __th = (thread); \
544 uint64_t __index = os_atomic_inc_orig(&thread->workq_quantum_history_index, relaxed); \
545 struct workq_quantum_history _wq_quantum_history = { mach_approximate_time(), __VA_ARGS__}; \
546 __th->workq_quantum_history[__index % WORKQ_QUANTUM_HISTORY_COUNT] = \
547 (struct workq_quantum_history) _wq_quantum_history; \
548 })
549 #else /* WORKQ_QUANTUM_HISTORY_DEBUG */
550 #define WORKQ_QUANTUM_HISTORY_WRITE_ENTRY(thread, ...)
551 #endif /* WORKQ_QUANTUM_HISTORY_DEBUG */
552
553 #define THREAD_NOT_RUNNABLE (~0ULL)
554
555 #if CONFIG_THREAD_GROUPS
556 struct thread_group *thread_group;
557 #endif
558
559 #if defined(CONFIG_SCHED_MULTIQ)
560 sched_group_t sched_group;
561 #endif /* defined(CONFIG_SCHED_MULTIQ) */
562
563 /* Data used during setrun/dispatch */
564 processor_t bound_processor; /* bound to a processor? */
565 processor_t last_processor; /* processor last dispatched on */
566 processor_t chosen_processor; /* Where we want to run this thread */
567
568 /* Fail-safe computation since last unblock or qualifying yield */
569 uint64_t computation_metered;
570 uint64_t computation_epoch;
571 uint64_t safe_release; /* when to release fail-safe */
572
573 /* Call out from scheduler */
574 void (*sched_call)(int type, thread_t thread);
575
576 #if defined(CONFIG_SCHED_PROTO)
577 uint32_t runqueue_generation; /* last time runqueue was drained */
578 #endif
579
580 /* Statistics and timesharing calculations */
581 #if defined(CONFIG_SCHED_TIMESHARE_CORE)
582 natural_t sched_stamp; /* last scheduler tick */
583 natural_t sched_usage; /* timesharing cpu usage [sched] */
584 natural_t pri_shift; /* usage -> priority from pset */
585 natural_t cpu_usage; /* instrumented cpu usage [%cpu] */
586 natural_t cpu_delta; /* accumulated cpu_usage delta */
587 #endif /* CONFIG_SCHED_TIMESHARE_CORE */
588
589 uint32_t c_switch; /* total context switches */
590 uint32_t p_switch; /* total processor switches */
591 uint32_t ps_switch; /* total pset switches */
592
593 integer_t mutex_count; /* total count of locks held */
594 /* Timing data structures */
595 uint64_t sched_time_save; /* saved time for scheduler tick */
596 uint64_t vtimer_user_save; /* saved values for vtimers */
597 uint64_t vtimer_prof_save;
598 uint64_t vtimer_rlim_save;
599 uint64_t vtimer_qos_save;
600
601 timer_data_t runnable_timer; /* time the thread is runnable (including running) */
602
603 struct recount_thread th_recount; /* resource accounting */
604
605 #if CONFIG_SCHED_SFI
606 /* Timing for wait state */
607 uint64_t wait_sfi_begin_time; /* start time for thread waiting in SFI */
608 #endif
609
610 /*
611 * Processor/cache affinity
612 * - affinity_threads links task threads with the same affinity set
613 */
614 queue_chain_t affinity_threads;
615 affinity_set_t affinity_set;
616
617 #if CONFIG_TASKWATCH
618 task_watch_t *taskwatch; /* task watch */
619 #endif /* CONFIG_TASKWATCH */
620
621 /* Various bits of state to stash across a continuation, exclusive to the current thread block point */
622 union {
623 struct {
624 mach_msg_return_t state; /* receive state */
625 mach_port_seqno_t seqno; /* seqno of recvd message */
626 ipc_object_t object; /* object received on */
627 mach_vm_address_t msg_addr; /* receive msg buffer pointer */
628 mach_vm_address_t aux_addr; /* receive aux buffer pointer */
629 mach_msg_size_t max_msize; /* max rcv size for msg */
630 mach_msg_size_t max_asize; /* max rcv size for aux data */
631 mach_msg_size_t msize; /* actual size for the msg */
632 mach_msg_size_t asize; /* actual size for aux data */
633 mach_msg_option64_t option; /* 64 bits options for receive */
634 mach_port_name_t receiver_name; /* the receive port name */
635 union {
636 struct ipc_kmsg *kmsg; /* received message */
637 struct ipc_mqueue *peekq; /* mqueue to peek at */
638 };
639 } receive;
640 struct {
641 struct semaphore *waitsemaphore; /* semaphore ref */
642 struct semaphore *signalsemaphore; /* semaphore ref */
643 int options; /* semaphore options */
644 kern_return_t result; /* primary result */
645 mach_msg_continue_t continuation;
646 } sema;
647 struct {
648 #define THREAD_SAVE_IOKIT_TLS_COUNT 8
649 void *tls[THREAD_SAVE_IOKIT_TLS_COUNT];
650 } iokit;
651 } saved;
652
653 /* Only user threads can cause guard exceptions, only kernel threads can be thread call threads */
654 union {
655 /* Thread call thread's state structure, stored on its stack */
656 struct thread_call_thread_state *thc_state;
657
658 /* Structure to save information about guard exception */
659 struct {
660 mach_exception_code_t code;
661 mach_exception_subcode_t subcode;
662 } guard_exc_info;
663 };
664
665 /* User level suspensions */
666 int32_t user_stop_count;
667
668 /* IPC data structures */
669 #if IMPORTANCE_INHERITANCE
670 natural_t ith_assertions; /* assertions pending drop */
671 #endif
672 circle_queue_head_t ith_messages; /* messages to reap */
673 mach_port_t ith_kernel_reply_port; /* reply port for kernel RPCs */
674
675 /* Pending thread ast(s) */
676 os_atomic(ast_t) ast;
677
678 /* Ast/Halt data structures */
679 vm_offset_t recover; /* page fault recover(copyin/out) */
680
681 queue_chain_t threads; /* global list of all threads */
682
683 /* Activation */
684 queue_chain_t task_threads;
685
686 /* Task membership */
687 #if __x86_64__ || __arm__
688 struct task *t_task;
689 #endif
690 struct thread_ro *t_tro;
691 vm_map_t map;
692 thread_t handoff_thread;
693
694 /* Timed wait expiration */
695 timer_call_t wait_timer;
696 uint16_t wait_timer_active; /* is the call running */
697 bool wait_timer_armed; /* should the wait be cleared */
698
699 /* Miscellaneous bits guarded by mutex */
700 uint32_t
701 active:1, /* Thread is active and has not been terminated */
702 ipc_active:1, /* IPC with the thread ports is allowed */
703 started:1, /* Thread has been started after creation */
704 static_param:1, /* Disallow policy parameter changes */
705 inspection:1, /* TRUE when task is being inspected by crash reporter */
706 policy_reset:1, /* Disallow policy parameter changes on terminating threads */
707 suspend_parked:1, /* thread parked in thread_suspended */
708 corpse_dup:1, /* TRUE when thread is an inactive duplicate in a corpse */
709 :0;
710
711 decl_lck_mtx_data(, mutex);
712
713 struct ipc_port *ith_special_reply_port; /* ref to special reply port */
714
715 #if CONFIG_DTRACE
716 uint16_t t_dtrace_flags; /* DTrace thread states */
717 #define TH_DTRACE_EXECSUCCESS 0x01
718 uint16_t t_dtrace_inprobe; /* Executing under dtrace_probe */
719 uint32_t t_dtrace_predcache; /* DTrace per thread predicate value hint */
720 int64_t t_dtrace_tracing; /* Thread time under dtrace_probe() */
721 int64_t t_dtrace_vtime;
722 #endif
723
724 clock_sec_t t_page_creation_time;
725 uint32_t t_page_creation_count;
726 uint32_t t_page_creation_throttled;
727 #if (DEVELOPMENT || DEBUG)
728 uint64_t t_page_creation_throttled_hard;
729 uint64_t t_page_creation_throttled_soft;
730 #endif /* DEVELOPMENT || DEBUG */
731 int t_pagein_error; /* for vm_fault(), holds error from vnop_pagein() */
732
733 #ifdef KPERF
734 /* The high 8 bits are the number of frames to sample of a user callstack. */
735 #define T_KPERF_CALLSTACK_DEPTH_OFFSET (24)
736 #define T_KPERF_SET_CALLSTACK_DEPTH(DEPTH) (((uint32_t)(DEPTH)) << T_KPERF_CALLSTACK_DEPTH_OFFSET)
737 #define T_KPERF_GET_CALLSTACK_DEPTH(FLAGS) ((FLAGS) >> T_KPERF_CALLSTACK_DEPTH_OFFSET)
738 #define T_KPERF_ACTIONID_OFFSET (18)
739 #define T_KPERF_SET_ACTIONID(AID) (((uint32_t)(AID)) << T_KPERF_ACTIONID_OFFSET)
740 #define T_KPERF_GET_ACTIONID(FLAGS) ((FLAGS) >> T_KPERF_ACTIONID_OFFSET)
741 #endif
742
743 #define T_KPERF_AST_CALLSTACK 0x1 /* dump a callstack on thread's next AST */
744 #define T_KPERF_AST_DISPATCH 0x2 /* dump a name on thread's next AST */
745 #define T_KPC_ALLOC 0x4 /* thread needs a kpc_buf allocated */
746
747 #define T_KPERF_AST_ALL \
748 (T_KPERF_AST_CALLSTACK | T_KPERF_AST_DISPATCH | T_KPC_ALLOC)
749 /* only go up to T_KPERF_ACTIONID_OFFSET - 1 */
750
751 #ifdef KPERF
752 uint32_t kperf_ast;
753 uint32_t kperf_pet_gen; /* last generation of PET that sampled this thread*/
754 uint32_t kperf_c_switch; /* last dispatch detection */
755 uint32_t kperf_pet_cnt; /* how many times a thread has been sampled by PET */
756 #endif
757
758 #ifdef KPC
759 /* accumulated performance counters for this thread */
760 uint64_t *kpc_buf;
761 #endif
762
763 #if HYPERVISOR
764 /* hypervisor virtual CPU object associated with this thread */
765 void *hv_thread_target;
766 #endif /* HYPERVISOR */
767
768 /* Statistics accumulated per-thread and aggregated per-task */
769 uint32_t syscalls_unix;
770 uint32_t syscalls_mach;
771 ledger_t t_ledger;
772 ledger_t t_threadledger; /* per thread ledger */
773 ledger_t t_bankledger; /* ledger to charge someone */
774 uint64_t t_deduct_bank_ledger_time; /* cpu time to be deducted from bank ledger */
775 uint64_t t_deduct_bank_ledger_energy; /* energy to be deducted from bank ledger */
776
777 uint64_t thread_id; /* system wide unique thread-id */
778 uint32_t ctid; /* system wide compact thread-id */
779 uint32_t ctsid; /* this thread ts ID */
780
781 /* policy is protected by the thread mutex */
782 struct thread_requested_policy requested_policy;
783 struct thread_effective_policy effective_policy;
784
785 /* usynch override is protected by the task lock, eventually will be thread mutex */
786 struct thread_qos_override {
787 struct thread_qos_override *override_next;
788 uint32_t override_contended_resource_count;
789 int16_t override_qos;
790 int16_t override_resource_type;
791 user_addr_t override_resource;
792 } *overrides;
793
794 uint32_t kevent_overrides;
795 uint8_t user_promotion_basepri;
796 uint8_t kern_promotion_schedpri;
797 _Atomic uint16_t kevent_ast_bits;
798
799 io_stat_info_t thread_io_stats; /* per-thread I/O statistics */
800
801 uint32_t thread_callout_interrupt_wakeups;
802 uint32_t thread_callout_platform_idle_wakeups;
803 uint32_t thread_timer_wakeups_bin_1;
804 uint32_t thread_timer_wakeups_bin_2;
805 thread_tag_t thread_tag;
806
807 /*
808 * callout_* fields are only set for thread call threads whereas guard_exc_fatal is set
809 * by user threads on themselves while taking a guard exception. So it's okay for them to
810 * share this bitfield.
811 */
812 uint16_t
813 callout_woken_from_icontext:1,
814 callout_woken_from_platform_idle:1,
815 callout_woke_thread:1,
816 guard_exc_fatal:1,
817 thread_bitfield_unused:12;
818
819 mach_port_name_t ith_voucher_name;
820 ipc_voucher_t ith_voucher;
821
822 #if CONFIG_THREAD_GROUPS
823 #if CONFIG_PREADOPT_TG
824 /* The preadopt thread group is set on the thread
825 *
826 * a) By another thread when it is a creator and it is scheduled with the
827 * thread group on the TR
828 * b) On itself when it binds a thread request and becomes a
829 * servicer or when it rebinds to the thread request
830 * c) On itself when it processes knotes and finds the first
831 * EVFILT_MACHPORT event to deliver to userspace
832 *
833 * Note that this is a full reference owned by the thread_t and not a
834 * borrowed reference.
835 *
836 * This reference is cleared from the thread_t by the thread itself at the
837 * following times:
838 * a) When it explicitly adopts a work interval or a bank voucher
839 * b) If it still exists on the thread, after it has unbound and is about
840 * to park
841 * c) During thread termination if one still exists
842 * d) When a different preadoption thread group is set on the thread
843 *
844 * It is modified under the thread lock.
845 */
846 struct thread_group *preadopt_thread_group;
847
848 /* This field here is present in order to make sure that the t->thread_group
849 * is always pointing to a valid thread group and isn't a dangling pointer.
850 *
851 * Consider the following scenario:
852 * a) t->thread_group points to the preadoption thread group
853 * b) The preadoption thread group is modified on the thread but we are
854 * unable to resolve the hierarchy immediately due to the current state of
855 * the thread
856 *
857 * In order to make sure that t->thread_group points to a valid thread
858 * group until we can resolve the hierarchy again, we save the existing
859 * thread_group it points to in old_preadopt_thread_group. The next time a
860 * hierarchy resolution is done, we know that t->thread_group will not point
861 * to this field anymore so we can clear it.
862 *
863 * This field is always going to take the reference that was previously in
864 * preadopt_thread_group so it will have a full +1
865 */
866 struct thread_group *old_preadopt_thread_group;
867 #endif /* CONFIG_PREADOPT_TG */
868
869 /* This is a borrowed reference to the TG from the ith_voucher and is saved
870 * here since we may not always be in the right context to able to do the
871 * lookups.
872 *
873 * It is set always set on self under the thread lock */
874 struct thread_group *bank_thread_group;
875
876 /* Whether this is the autojoin thread group or the work interval thread
877 * group depends on whether the thread's sched_flags has the
878 * TH_SFLAG_THREAD_GROUP_AUTO_JOIN bit set */
879 union {
880 /* This is a borrowed reference to the auto join thread group from the
881 * work_interval. It is set with the thread lock held */
882 struct thread_group *auto_join_thread_group;
883 /* This is a borrowed reference to the explicit work_interval thread group
884 * and is always set on self */
885 struct thread_group *work_interval_thread_group;
886 };
887 #endif /* CONFIG_THREAD_GROUPS */
888
889 /* work interval (if any) associated with the thread. Only modified by
890 * current thread on itself or when another thread when the thread is held
891 * off of runq */
892 struct work_interval *th_work_interval;
893 thread_work_interval_flags_t th_work_interval_flags;
894
895 #define THREAD_BOUND_CLUSTER_NONE (UINT32_MAX)
896 uint32_t th_bound_cluster_id;
897
898 #if SCHED_TRACE_THREAD_WAKEUPS
899 uintptr_t thread_wakeup_bt[64];
900 #endif
901 turnstile_update_flags_t inheritor_flags; /* inheritor flags for inheritor field */
902 block_hint_t pending_block_hint;
903 block_hint_t block_hint; /* What type of primitive last caused us to block. */
904 uint32_t decompressions; /* Per-thread decompressions counter to be added to per-task decompressions counter */
905 int thread_region_page_shift; /* Page shift that this thread would like to use when */
906 /* introspecting a task. This is currently being used */
907 /* by footprint which uses a thread for each task being inspected. */
908 #if CONFIG_SCHED_RT_ALLOW
909 /* Used when a thread is requested to set/clear its own CPU limit */
910 uint32_t
911 t_ledger_req_action:2,
912 t_ledger_req_percentage:7,
913 t_ledger_req_interval_ms:16,
914 :0;
915 #endif /* CONFIG_SCHED_RT_ALLOW */
916
917 #if CONFIG_IOSCHED
918 void *decmp_upl;
919 #endif /* CONFIG_IOSCHED */
920 struct knote *ith_knote; /* knote fired for rcv */
921
922 };
923
924 #define ith_state saved.receive.state
925 #define ith_object saved.receive.object
926 #define ith_msg_addr saved.receive.msg_addr
927 #define ith_aux_addr saved.receive.aux_addr
928 #define ith_max_msize saved.receive.max_msize
929 #define ith_max_asize saved.receive.max_asize
930 #define ith_msize saved.receive.msize
931 #define ith_asize saved.receive.asize
932 #define ith_option saved.receive.option
933 #define ith_receiver_name saved.receive.receiver_name
934 #define ith_kmsg saved.receive.kmsg
935 #define ith_peekq saved.receive.peekq
936 #define ith_seqno saved.receive.seqno
937
938 #define sth_waitsemaphore saved.sema.waitsemaphore
939 #define sth_signalsemaphore saved.sema.signalsemaphore
940 #define sth_options saved.sema.options
941 #define sth_result saved.sema.result
942 #define sth_continuation saved.sema.continuation
943
944 #define ITH_KNOTE_NULL ((void *)NULL)
945 #define ITH_KNOTE_PSEUDO ((void *)0xdeadbeef)
946 /*
947 * The ith_knote is used during message delivery, and can safely be interpreted
948 * only when used for one of these codepaths, which the test for the msgt_name
949 * being RECEIVE or SEND_ONCE is about.
950 */
951 #define ITH_KNOTE_VALID(kn, msgt_name) \
952 (((kn) != ITH_KNOTE_NULL && (kn) != ITH_KNOTE_PSEUDO) && \
953 ((msgt_name) == MACH_MSG_TYPE_PORT_RECEIVE || \
954 (msgt_name) == MACH_MSG_TYPE_PORT_SEND_ONCE))
955
956 #if MACH_ASSERT
957 #define assert_thread_magic(thread) assertf((thread)->thread_magic == THREAD_MAGIC, \
958 "bad thread magic 0x%llx for thread %p, expected 0x%llx", \
959 (thread)->thread_magic, (thread), THREAD_MAGIC)
960 #else
961 #define assert_thread_magic(thread) do { (void)(thread); } while (0)
962 #endif
963
964 extern thread_t thread_bootstrap(void);
965
966 extern void thread_machine_init_template(void);
967
968 extern void thread_init(void);
969
970 extern void thread_daemon_init(void);
971
972 extern void thread_reference(
973 thread_t thread);
974
975 extern void thread_deallocate(
976 thread_t thread);
977
978 extern void thread_inspect_deallocate(
979 thread_inspect_t thread);
980
981 extern void thread_read_deallocate(
982 thread_read_t thread);
983
984 extern void thread_terminate_self(void);
985
986 extern kern_return_t thread_terminate_internal(
987 thread_t thread);
988
989 extern void thread_start(
990 thread_t thread) __attribute__ ((noinline));
991
992 extern void thread_start_in_assert_wait(
993 thread_t thread,
994 event_t event,
995 wait_interrupt_t interruptible) __attribute__ ((noinline));
996
997 extern void thread_terminate_enqueue(
998 thread_t thread);
999
1000 extern void thread_exception_enqueue(
1001 task_t task,
1002 thread_t thread,
1003 exception_type_t etype);
1004
1005 extern void thread_backtrace_enqueue(
1006 kcdata_object_t obj,
1007 exception_port_t ports[static BT_EXC_PORTS_COUNT],
1008 exception_type_t etype);
1009
1010 extern void thread_copy_resource_info(
1011 thread_t dst_thread,
1012 thread_t src_thread);
1013
1014 extern void thread_terminate_crashed_threads(void);
1015
1016 extern void thread_stack_enqueue(
1017 thread_t thread);
1018
1019 extern void thread_hold(
1020 thread_t thread);
1021
1022 extern void thread_release(
1023 thread_t thread);
1024
1025 extern void thread_corpse_continue(void) __dead2;
1026
1027 extern boolean_t thread_is_active(thread_t thread);
1028
1029 extern lck_grp_t thread_lck_grp;
1030
1031 /* Locking for scheduler state, always acquired with interrupts disabled (splsched()) */
1032 #define thread_lock_init(th) simple_lock_init(&(th)->sched_lock, 0)
1033 #define thread_lock(th) simple_lock(&(th)->sched_lock, &thread_lck_grp)
1034 #define thread_unlock(th) simple_unlock(&(th)->sched_lock)
1035 #define thread_lock_assert(th, x) simple_lock_assert(&(th)->sched_lock, (x))
1036
1037 #define wake_lock_init(th) simple_lock_init(&(th)->wake_lock, 0)
1038 #define wake_lock(th) simple_lock(&(th)->wake_lock, &thread_lck_grp)
1039 #define wake_unlock(th) simple_unlock(&(th)->wake_lock)
1040
1041 #define thread_should_halt_fast(thread) (!(thread)->active)
1042
1043 extern void stack_alloc(
1044 thread_t thread);
1045
1046 extern void stack_handoff(
1047 thread_t from,
1048 thread_t to);
1049
1050 extern void stack_free(
1051 thread_t thread);
1052
1053 extern void stack_free_reserved(
1054 thread_t thread);
1055
1056 extern boolean_t stack_alloc_try(
1057 thread_t thread);
1058
1059 extern void stack_collect(void);
1060
1061 extern kern_return_t thread_info_internal(
1062 thread_t thread,
1063 thread_flavor_t flavor,
1064 thread_info_t thread_info_out,
1065 mach_msg_type_number_t *thread_info_count);
1066
1067 extern kern_return_t kernel_thread_create(
1068 thread_continue_t continuation,
1069 void *parameter,
1070 integer_t priority,
1071 thread_t *new_thread);
1072
1073 extern kern_return_t kernel_thread_start_priority(
1074 thread_continue_t continuation,
1075 void *parameter,
1076 integer_t priority,
1077 thread_t *new_thread);
1078
1079 extern void machine_stack_attach(
1080 thread_t thread,
1081 vm_offset_t stack);
1082
1083 extern vm_offset_t machine_stack_detach(
1084 thread_t thread);
1085
1086 extern void machine_stack_handoff(
1087 thread_t old,
1088 thread_t new);
1089
1090 extern thread_t machine_switch_context(
1091 thread_t old_thread,
1092 thread_continue_t continuation,
1093 thread_t new_thread);
1094
1095 extern void machine_load_context(
1096 thread_t thread) __attribute__((noreturn));
1097
1098 extern void machine_thread_state_initialize(
1099 thread_t thread);
1100
1101 extern kern_return_t machine_thread_set_state(
1102 thread_t thread,
1103 thread_flavor_t flavor,
1104 thread_state_t state,
1105 mach_msg_type_number_t count);
1106
1107 extern mach_vm_address_t machine_thread_pc(
1108 thread_t thread);
1109
1110 extern void machine_thread_reset_pc(
1111 thread_t thread,
1112 mach_vm_address_t pc);
1113
1114 extern boolean_t machine_thread_on_core(
1115 thread_t thread);
1116
1117 extern boolean_t machine_thread_on_core_allow_invalid(
1118 thread_t thread);
1119
1120 extern kern_return_t machine_thread_get_state(
1121 thread_t thread,
1122 thread_flavor_t flavor,
1123 thread_state_t state,
1124 mach_msg_type_number_t *count);
1125
1126 extern kern_return_t machine_thread_state_convert_from_user(
1127 thread_t thread,
1128 thread_flavor_t flavor,
1129 thread_state_t tstate,
1130 mach_msg_type_number_t count,
1131 thread_state_t old_tstate,
1132 mach_msg_type_number_t old_count,
1133 thread_set_status_flags_t tssf_flags);
1134
1135 extern kern_return_t machine_thread_state_convert_to_user(
1136 thread_t thread,
1137 thread_flavor_t flavor,
1138 thread_state_t tstate,
1139 mach_msg_type_number_t *count,
1140 thread_set_status_flags_t tssf_flags);
1141
1142 extern kern_return_t machine_thread_dup(
1143 thread_t self,
1144 thread_t target,
1145 boolean_t is_corpse);
1146
1147 extern void machine_thread_init(void);
1148
1149 extern void machine_thread_template_init(thread_t thr_template);
1150
1151
1152 extern void machine_thread_create(
1153 thread_t thread,
1154 task_t task,
1155 bool first_thread);
1156
1157 extern kern_return_t machine_thread_process_signature(
1158 thread_t thread,
1159 task_t task);
1160
1161 extern void machine_thread_switch_addrmode(
1162 thread_t thread);
1163
1164 extern void machine_thread_destroy(
1165 thread_t thread);
1166
1167 extern void machine_set_current_thread(
1168 thread_t thread);
1169
1170 extern kern_return_t machine_thread_get_kern_state(
1171 thread_t thread,
1172 thread_flavor_t flavor,
1173 thread_state_t tstate,
1174 mach_msg_type_number_t *count);
1175
1176 extern kern_return_t machine_thread_inherit_taskwide(
1177 thread_t thread,
1178 task_t parent_task);
1179
1180 extern kern_return_t machine_thread_set_tsd_base(
1181 thread_t thread,
1182 mach_vm_offset_t tsd_base);
1183
1184 #define thread_mtx_try(thread) lck_mtx_try_lock(&(thread)->mutex)
1185 #define thread_mtx_held(thread) lck_mtx_assert(&(thread)->mutex, LCK_MTX_ASSERT_OWNED)
1186
1187 extern void thread_apc_ast(thread_t thread);
1188
1189 extern void thread_update_qos_cpu_time(thread_t thread);
1190
1191 void act_machine_sv_free(thread_t, int);
1192
1193 vm_offset_t min_valid_stack_address(void);
1194 vm_offset_t max_valid_stack_address(void);
1195
1196 extern bool thread_no_smt(thread_t thread);
1197 extern bool processor_active_thread_no_smt(processor_t processor);
1198
1199 extern void thread_set_options(uint32_t thopt);
1200
1201 #if CONFIG_THREAD_GROUPS
1202 struct thread_group *thread_get_current_voucher_thread_group(thread_t thread);
1203 #endif /* CONFIG_THREAD_GROUPS */
1204
1205 #if CONFIG_COALITIONS
1206 uint64_t thread_get_current_voucher_resource_coalition_id(thread_t thread);
1207 #endif /* CONFIG_COALITIONS */
1208
1209 #endif /* MACH_KERNEL_PRIVATE */
1210 #if BSD_KERNEL_PRIVATE
1211
1212 /* Duplicated from osfmk/kern/ipc_tt.h */
1213 __options_decl(port_intrans_options_t, uint32_t, {
1214 PORT_INTRANS_OPTIONS_NONE = 0x0000,
1215 PORT_INTRANS_THREAD_IN_CURRENT_TASK = 0x0001,
1216 PORT_INTRANS_THREAD_NOT_CURRENT_THREAD = 0x0002,
1217
1218 PORT_INTRANS_SKIP_TASK_EVAL = 0x0004,
1219 PORT_INTRANS_ALLOW_CORPSE_TASK = 0x0008,
1220 });
1221
1222 extern thread_t port_name_to_thread(
1223 mach_port_name_t port_name,
1224 port_intrans_options_t options);
1225
1226 #endif /* BSD_KERNEL_PRIVATE */
1227 #ifdef XNU_KERNEL_PRIVATE
1228
1229 extern void thread_require(
1230 thread_t thread);
1231
1232 extern void thread_deallocate_safe(
1233 thread_t thread);
1234
1235 extern uint64_t thread_rettokern_addr(
1236 thread_t thread);
1237
1238 extern uint64_t thread_wqquantum_addr(
1239 thread_t thread);
1240
1241 extern integer_t thread_kern_get_pri(thread_t thr) __pure2;
1242
1243 extern void thread_kern_set_pri(thread_t thr, integer_t pri);
1244
1245 extern integer_t thread_kern_get_kernel_maxpri(void) __pure2;
1246
1247 uint16_t thread_set_tag(thread_t thread, uint16_t tag);
1248 uint16_t thread_get_tag(thread_t thread);
1249
1250 __options_decl(shared_rsrc_policy_agent_t, uint32_t, {
1251 SHARED_RSRC_POLICY_AGENT_DISPATCH = 0,
1252 SHARED_RSRC_POLICY_AGENT_SYSCTL = 1,
1253 SHARED_RSRC_POLICY_AGENT_PERFCTL_CSW = 2,
1254 SHARED_RSRC_POLICY_AGENT_PERFCTL_QUANTUM = 3,
1255 });
1256
1257 boolean_t thread_shared_rsrc_policy_get(thread_t thread, cluster_shared_rsrc_type_t type);
1258 kern_return_t thread_shared_rsrc_policy_set(thread_t thread, uint32_t index, cluster_shared_rsrc_type_t type, shared_rsrc_policy_agent_t agent);
1259 kern_return_t thread_shared_rsrc_policy_clear(thread_t thread, cluster_shared_rsrc_type_t type, shared_rsrc_policy_agent_t agent);
1260
1261 #ifdef MACH_KERNEL_PRIVATE
1262 static inline thread_tag_t
thread_set_tag_internal(thread_t thread,thread_tag_t tag)1263 thread_set_tag_internal(thread_t thread, thread_tag_t tag)
1264 {
1265 return os_atomic_or_orig(&thread->thread_tag, tag, relaxed);
1266 }
1267
1268 static inline thread_tag_t
thread_get_tag_internal(thread_t thread)1269 thread_get_tag_internal(thread_t thread)
1270 {
1271 return thread->thread_tag;
1272 }
1273 #endif /* MACH_KERNEL_PRIVATE */
1274
1275 uint64_t thread_last_run_time(thread_t thread);
1276
1277 extern kern_return_t thread_state_initialize(
1278 thread_t thread);
1279
1280 extern kern_return_t thread_setstatus(
1281 thread_t thread,
1282 int flavor,
1283 thread_state_t tstate,
1284 mach_msg_type_number_t count);
1285
1286 extern kern_return_t thread_setstatus_from_user(
1287 thread_t thread,
1288 int flavor,
1289 thread_state_t tstate,
1290 mach_msg_type_number_t count,
1291 thread_state_t old_tstate,
1292 mach_msg_type_number_t old_count,
1293 thread_set_status_flags_t flags);
1294
1295 extern kern_return_t thread_getstatus(
1296 thread_t thread,
1297 int flavor,
1298 thread_state_t tstate,
1299 mach_msg_type_number_t *count);
1300
1301 extern void main_thread_set_immovable_pinned(thread_t thread);
1302
1303 extern kern_return_t thread_getstatus_to_user(
1304 thread_t thread,
1305 int flavor,
1306 thread_state_t tstate,
1307 mach_msg_type_number_t *count,
1308 thread_set_status_flags_t flags);
1309
1310 extern kern_return_t thread_create_with_continuation(
1311 task_t task,
1312 thread_t *new_thread,
1313 thread_continue_t continuation);
1314
1315 extern kern_return_t main_thread_create_waiting(task_t task,
1316 thread_continue_t continuation,
1317 event_t event,
1318 thread_t *new_thread);
1319
1320 extern kern_return_t thread_create_workq_waiting(
1321 task_t task,
1322 thread_continue_t thread_return,
1323 thread_t *new_thread);
1324
1325 extern void thread_yield_internal(
1326 mach_msg_timeout_t interval);
1327
1328 extern void thread_yield_to_preemption(void);
1329
1330 extern void thread_depress_timer_setup(thread_t self);
1331
1332 /*
1333 * Thread-private CPU limits: apply a private CPU limit to this thread only. Available actions are:
1334 *
1335 * 1) Block. Prevent CPU consumption of the thread from exceeding the limit.
1336 * 2) Exception. Generate a resource consumption exception when the limit is exceeded.
1337 * 3) Disable. Remove any existing CPU limit.
1338 */
1339 #define THREAD_CPULIMIT_BLOCK 0x1
1340 #define THREAD_CPULIMIT_EXCEPTION 0x2
1341 #define THREAD_CPULIMIT_DISABLE 0x3
1342
1343 struct _thread_ledger_indices {
1344 int cpu_time;
1345 };
1346
1347 extern struct _thread_ledger_indices thread_ledgers;
1348
1349 extern int thread_get_cpulimit(int *action, uint8_t *percentage, uint64_t *interval_ns);
1350 extern int thread_set_cpulimit(int action, uint8_t percentage, uint64_t interval_ns);
1351
1352 extern uint64_t thread_cpulimit_remaining(uint64_t now);
1353 extern bool thread_cpulimit_interval_has_expired(uint64_t now);
1354 extern void thread_cpulimit_restart(uint64_t now);
1355
1356 extern void thread_read_times(
1357 thread_t thread,
1358 time_value_t *user_time,
1359 time_value_t *system_time,
1360 time_value_t *runnable_time);
1361
1362 extern void thread_read_times_unsafe(
1363 thread_t thread,
1364 time_value_t *user_time,
1365 time_value_t *system_time,
1366 time_value_t *runnable_time);
1367
1368 extern uint64_t thread_get_runtime_self(void);
1369
1370 extern void thread_setuserstack(
1371 thread_t thread,
1372 mach_vm_offset_t user_stack);
1373
1374 extern user_addr_t thread_adjuserstack(
1375 thread_t thread,
1376 int adjust);
1377
1378
1379 extern void thread_setentrypoint(
1380 thread_t thread,
1381 mach_vm_offset_t entry);
1382
1383 extern kern_return_t thread_set_tsd_base(
1384 thread_t thread,
1385 mach_vm_offset_t tsd_base);
1386
1387 extern kern_return_t thread_setsinglestep(
1388 thread_t thread,
1389 int on);
1390
1391 extern kern_return_t thread_userstack(
1392 thread_t,
1393 int,
1394 thread_state_t,
1395 unsigned int,
1396 mach_vm_offset_t *,
1397 int *,
1398 boolean_t);
1399
1400 extern kern_return_t thread_entrypoint(
1401 thread_t,
1402 int,
1403 thread_state_t,
1404 unsigned int,
1405 mach_vm_offset_t *);
1406
1407 extern kern_return_t thread_userstackdefault(
1408 mach_vm_offset_t *,
1409 boolean_t);
1410
1411 extern kern_return_t thread_wire_internal(
1412 host_priv_t host_priv,
1413 thread_t thread,
1414 boolean_t wired,
1415 boolean_t *prev_state);
1416
1417
1418 extern kern_return_t thread_dup(thread_t);
1419
1420 extern kern_return_t thread_dup2(thread_t, thread_t);
1421
1422 #if !defined(_SCHED_CALL_T_DEFINED)
1423 #define _SCHED_CALL_T_DEFINED
1424 typedef void (*sched_call_t)(
1425 int type,
1426 thread_t thread);
1427 #endif
1428
1429 #define SCHED_CALL_BLOCK 0x1
1430 #define SCHED_CALL_UNBLOCK 0x2
1431
1432 extern void thread_sched_call(
1433 thread_t thread,
1434 sched_call_t call);
1435
1436 extern boolean_t thread_is_static_param(
1437 thread_t thread);
1438
1439 extern task_t get_threadtask(thread_t) __pure2;
1440
1441 extern task_t get_threadtask_early(thread_t) __pure2;
1442
1443 /*
1444 * Thread is running within a 64-bit address space.
1445 */
1446 #define thread_is_64bit_addr(thd) \
1447 task_has_64Bit_addr(get_threadtask(thd))
1448
1449 /*
1450 * Thread is using 64-bit machine state.
1451 */
1452 #define thread_is_64bit_data(thd) \
1453 task_has_64Bit_data(get_threadtask(thd))
1454
1455 struct uthread;
1456
1457 #if defined(__x86_64__)
1458 extern int thread_task_has_ldt(thread_t);
1459 #endif
1460 extern void set_thread_pagein_error(thread_t, int);
1461 extern event_t workq_thread_init_and_wq_lock(task_t, thread_t); // bsd/pthread/
1462
1463 struct proc;
1464 struct uthread;
1465 struct image_params;
1466 extern const size_t uthread_size;
1467 extern thread_ro_t get_thread_ro_unchecked(thread_t) __pure2;
1468 extern thread_ro_t get_thread_ro(thread_t) __pure2;
1469 extern thread_ro_t current_thread_ro_unchecked(void) __pure2;
1470 extern thread_ro_t current_thread_ro(void) __pure2;
1471 extern void clear_thread_ro_proc(thread_t);
1472 extern struct uthread *get_bsdthread_info(thread_t) __pure2;
1473 extern thread_t get_machthread(struct uthread *) __pure2;
1474 extern uint64_t uthread_tid(struct uthread *) __pure2;
1475 extern user_addr_t thread_get_sigreturn_token(thread_t thread);
1476 extern uint32_t thread_get_sigreturn_diversifier(thread_t thread);
1477 extern void uthread_init(task_t, struct uthread *, thread_ro_t, int);
1478 extern void uthread_cleanup_name(struct uthread *uthread);
1479 extern void uthread_cleanup(struct uthread *, thread_ro_t);
1480 extern void uthread_cred_ref(struct ucred *);
1481 extern void uthread_cred_free(struct ucred *);
1482 extern void uthread_destroy(struct uthread *);
1483 extern void uthread_reset_proc_refcount(struct uthread *);
1484 extern void thread_ro_update_cred(thread_ro_t, struct ucred *);
1485 extern void thread_ro_update_flags(thread_ro_t, thread_ro_flags_t add, thread_ro_flags_t clr);
1486 extern void uthread_set_exec_data(struct uthread *uth, struct image_params *imgp);
1487 extern bool uthread_is64bit(struct uthread *uth) __pure2;
1488 #if PROC_REF_DEBUG
1489 extern void uthread_init_proc_refcount(struct uthread *);
1490 extern void uthread_destroy_proc_refcount(struct uthread *);
1491 extern void uthread_assert_zero_proc_refcount(struct uthread *);
1492 #else
1493 #define uthread_init_proc_refcount(uth) ((void)(uth))
1494 #define uthread_destroy_proc_refcount(uth) ((void)(uth))
1495 #define uthread_assert_zero_proc_refcount(uth) ((void)(uth))
1496 #endif
1497 #if CONFIG_DEBUG_SYSCALL_REJECTION
1498 extern uint64_t uthread_get_syscall_rejection_flags(void *);
1499 extern uint64_t *uthread_get_syscall_rejection_mask(void *);
1500 extern uint64_t *uthread_get_syscall_rejection_once_mask(void *);
1501 extern bool uthread_syscall_rejection_is_enabled(void *);
1502 #endif /* CONFIG_DEBUG_SYSCALL_REJECTION */
1503 extern mach_port_name_t uthread_joiner_port(struct uthread *);
1504 extern user_addr_t uthread_joiner_address(struct uthread *);
1505 extern void uthread_joiner_wake(task_t task, struct uthread *);
1506
1507 extern boolean_t thread_should_halt(
1508 thread_t thread);
1509
1510 extern boolean_t thread_should_abort(
1511 thread_t);
1512
1513 extern int is_64signalregset(void);
1514
1515 extern void act_set_kperf(thread_t);
1516 extern void act_set_astledger(thread_t thread);
1517 extern void act_set_astledger_async(thread_t thread);
1518 extern void act_set_io_telemetry_ast(thread_t);
1519 extern void act_set_macf_telemetry_ast(thread_t);
1520 extern void act_set_astproc_resource(thread_t);
1521
1522 extern vm_offset_t thread_get_kernel_stack(thread_t);
1523
1524 extern kern_return_t thread_process_signature(thread_t thread, task_t task);
1525
1526 extern uint32_t dtrace_get_thread_predcache(thread_t);
1527 extern int64_t dtrace_get_thread_vtime(thread_t);
1528 extern int64_t dtrace_get_thread_tracing(thread_t);
1529 extern uint16_t dtrace_get_thread_inprobe(thread_t);
1530 extern int dtrace_get_thread_last_cpu_id(thread_t);
1531 extern vm_offset_t dtrace_get_kernel_stack(thread_t);
1532 #define dtrace_get_kernel_stack thread_get_kernel_stack
1533 extern void dtrace_set_thread_predcache(thread_t, uint32_t);
1534 extern void dtrace_set_thread_vtime(thread_t, int64_t);
1535 extern void dtrace_set_thread_tracing(thread_t, int64_t);
1536 extern void dtrace_set_thread_inprobe(thread_t, uint16_t);
1537 extern void dtrace_thread_bootstrap(void);
1538 extern void dtrace_thread_didexec(thread_t);
1539
1540 extern int64_t dtrace_calc_thread_recent_vtime(thread_t);
1541
1542
1543 extern kern_return_t thread_set_wq_state32(
1544 thread_t thread,
1545 thread_state_t tstate);
1546
1547 extern kern_return_t thread_set_wq_state64(
1548 thread_t thread,
1549 thread_state_t tstate);
1550
1551 extern vm_offset_t kernel_stack_mask;
1552 extern vm_offset_t kernel_stack_size;
1553 extern vm_offset_t kernel_stack_depth_max;
1554
1555 extern void guard_ast(thread_t);
1556 extern void fd_guard_ast(thread_t,
1557 mach_exception_code_t, mach_exception_subcode_t);
1558 #if CONFIG_VNGUARD
1559 extern void vn_guard_ast(thread_t,
1560 mach_exception_code_t, mach_exception_subcode_t);
1561 #endif
1562 extern void mach_port_guard_ast(thread_t,
1563 mach_exception_code_t, mach_exception_subcode_t);
1564 extern void virt_memory_guard_ast(thread_t,
1565 mach_exception_code_t, mach_exception_subcode_t);
1566 extern void thread_guard_violation(thread_t,
1567 mach_exception_code_t, mach_exception_subcode_t, boolean_t);
1568 extern void thread_update_io_stats(thread_t, int size, int io_flags);
1569
1570 extern kern_return_t thread_set_voucher_name(mach_port_name_t name);
1571 extern kern_return_t thread_get_voucher_origin_pid(thread_t thread, int32_t *pid);
1572 extern kern_return_t thread_get_current_voucher_origin_pid(int32_t *pid);
1573
1574 extern void thread_enable_send_importance(thread_t thread, boolean_t enable);
1575
1576 /*
1577 * Translate signal context data pointer to userspace representation
1578 */
1579
1580 extern kern_return_t machine_thread_siguctx_pointer_convert_to_user(
1581 thread_t thread,
1582 user_addr_t *uctxp);
1583
1584 extern void machine_tecs(thread_t thr);
1585
1586 typedef enum cpuvn {
1587 CPUVN_CI = 1
1588 } cpuvn_e;
1589
1590 extern int machine_csv(cpuvn_e cve);
1591 #if defined(__x86_64__)
1592 extern void machine_thread_set_insn_copy_optout(thread_t thr);
1593 #endif
1594
1595 /*
1596 * Translate array of function pointer syscall arguments from userspace representation
1597 */
1598
1599 extern kern_return_t machine_thread_function_pointers_convert_from_user(
1600 thread_t thread,
1601 user_addr_t *fptrs,
1602 uint32_t count);
1603
1604 /*
1605 * Get the duration of the given thread's last wait.
1606 */
1607 uint64_t thread_get_last_wait_duration(thread_t thread);
1608
1609 extern bool thread_get_no_smt(void);
1610 #if defined(__x86_64__)
1611 extern bool curtask_get_insn_copy_optout(void);
1612 extern void curtask_set_insn_copy_optout(void);
1613 #endif /* defined(__x86_64__) */
1614
1615 /*! @function ctid_get_thread
1616 * @abstract translates a ctid_t to thread_t
1617 * @discussion ctid are system wide compact thread-id
1618 * associated to thread_t at thread creation
1619 * and recycled at thread termination. If a ctid is
1620 * referenced past the corresponding thread termination,
1621 * it is considered stale, and the behavior is not defined.
1622 * Note that this call does not acquire a reference on the thread,
1623 * so as soon as the matching thread terminates, the ctid
1624 * will become stale, and it could be re-used and associated with
1625 * another thread. You must externally guarantee that the thread
1626 * will not exit while you are using its ctid.
1627 * @result thread_t corresponding to ctid
1628 */
1629 extern thread_t ctid_get_thread(ctid_t ctid);
1630
1631 /*! @function ctid_get_thread
1632 * @abstract translates a ctid_t to thread_t
1633 * @discussion Unsafe variant of ctid_get_thread() to be used
1634 * when the caller can't guarantee the liveness of this ctid_t.
1635 * may return NULL or a freed thread_t.
1636 */
1637 extern thread_t ctid_get_thread_unsafe(ctid_t ctid);
1638
1639 /*!
1640 * @function thread_get_ctid
1641 * @abstract returns the ctid of thread.
1642 * @param thread to find the corresponding ctid.
1643 * @discussion the ctid provided will become stale after the matching thread
1644 * terminates.
1645 * @result uint32_t ctid.
1646 */
1647 extern ctid_t thread_get_ctid(thread_t thread);
1648
1649 #endif /* XNU_KERNEL_PRIVATE */
1650 #ifdef KERNEL_PRIVATE
1651
1652 typedef struct thread_pri_floor {
1653 thread_t thread;
1654 } thread_pri_floor_t;
1655
1656 #ifdef MACH_KERNEL_PRIVATE
1657 extern void thread_floor_boost_ast(thread_t thread);
1658 extern void thread_floor_boost_set_promotion_locked(thread_t thread);
1659 #endif /* MACH_KERNEL_PRIVATE */
1660
1661 /*! @function thread_priority_floor_start
1662 * @abstract boost the current thread priority to floor.
1663 * @discussion Increase the priority of the current thread to at least MINPRI_FLOOR.
1664 * The boost will be mantained until a corresponding thread_priority_floor_end()
1665 * is called. Every call of thread_priority_floor_start() needs to have a corresponding
1666 * call to thread_priority_floor_end() from the same thread.
1667 * No thread can return to userspace before calling thread_priority_floor_end().
1668 *
1669 * NOTE: avoid to use this function. Try to use gate_t or sleep_with_inheritor()
1670 * instead.
1671 * @result a token to be given to the corresponding thread_priority_floor_end()
1672 */
1673 extern thread_pri_floor_t thread_priority_floor_start(void);
1674 /*! @function thread_priority_floor_end
1675 * @abstract ends the floor boost.
1676 * @param token the token obtained from thread_priority_floor_start()
1677 * @discussion ends the priority floor boost started with thread_priority_floor_start()
1678 */
1679 extern void thread_priority_floor_end(thread_pri_floor_t *token);
1680
1681 extern void thread_set_no_smt(bool set);
1682
1683 extern void thread_mtx_lock(thread_t thread);
1684
1685 extern void thread_mtx_unlock(thread_t thread);
1686
1687 extern uint64_t thread_dispatchqaddr(
1688 thread_t thread);
1689
1690 bool thread_is_eager_preempt(thread_t thread);
1691 void thread_set_eager_preempt(thread_t thread);
1692 void thread_clear_eager_preempt(thread_t thread);
1693 void thread_set_honor_qlimit(thread_t thread);
1694 void thread_clear_honor_qlimit(thread_t thread);
1695 extern ipc_port_t convert_thread_to_port(thread_t);
1696 extern ipc_port_t convert_thread_to_port_pinned(thread_t);
1697 extern ipc_port_t convert_thread_inspect_to_port(thread_inspect_t);
1698 extern ipc_port_t convert_thread_read_to_port(thread_read_t);
1699 extern boolean_t is_external_pageout_thread(void);
1700 extern boolean_t is_vm_privileged(void);
1701 extern boolean_t set_vm_privilege(boolean_t);
1702 extern kern_allocation_name_t thread_set_allocation_name(kern_allocation_name_t new_name);
1703 extern void *thread_iokit_tls_get(uint32_t index);
1704 extern void thread_iokit_tls_set(uint32_t index, void * data);
1705 extern int thread_self_region_page_shift(void);
1706 extern void thread_self_region_page_shift_set(int pgshift);
1707 extern kern_return_t thread_create_immovable(task_t task, thread_t *new_thread);
1708 extern kern_return_t thread_terminate_pinned(thread_t thread);
1709
1710 struct thread_attr_for_ipc_propagation;
1711 extern kern_return_t thread_get_ipc_propagate_attr(thread_t thread, struct thread_attr_for_ipc_propagation *attr);
1712 extern size_t thread_get_current_exec_path(char *path, size_t size);
1713 #endif /* KERNEL_PRIVATE */
1714 #ifdef XNU_KERNEL_PRIVATE
1715
1716 extern void
1717 thread_get_thread_name(thread_t th, char* name);
1718
1719 extern bool thread_supports_cooperative_workqueue(thread_t thread);
1720 extern void thread_arm_workqueue_quantum(thread_t thread);
1721 extern void thread_disarm_workqueue_quantum(thread_t thread);
1722
1723 extern void thread_evaluate_workqueue_quantum_expiry(thread_t thread);
1724 extern bool thread_has_expired_workqueue_quantum(thread_t thread, bool should_trace);
1725
1726
1727 /* Kernel side prototypes for MIG routines */
1728 extern kern_return_t thread_get_exception_ports(
1729 thread_t thread,
1730 exception_mask_t exception_mask,
1731 exception_mask_array_t masks,
1732 mach_msg_type_number_t *CountCnt,
1733 exception_port_array_t ports,
1734 exception_behavior_array_t behaviors,
1735 thread_state_flavor_array_t flavors);
1736
1737 extern kern_return_t thread_get_special_port(
1738 thread_inspect_t thread,
1739 int which,
1740 ipc_port_t *portp);
1741
1742 #endif /* XNU_KERNEL_PRIVATE */
1743
1744 /*! @function thread_has_thread_name
1745 * @abstract Checks if a thread has a name.
1746 * @discussion This function takes one input, a thread, and returns
1747 * a boolean value indicating if that thread already has a name associated
1748 * with it.
1749 * @param th The thread to inspect.
1750 * @result TRUE if the thread has a name, FALSE otherwise.
1751 */
1752 extern boolean_t thread_has_thread_name(thread_t th);
1753
1754 /*! @function thread_set_thread_name
1755 * @abstract Set a thread's name.
1756 * @discussion This function takes two input parameters: a thread to name,
1757 * and the name to apply to the thread. The name will be copied over to
1758 * the thread in order to better identify the thread. If the name is
1759 * longer than MAXTHREADNAMESIZE - 1, it will be truncated.
1760 * @param th The thread to be named.
1761 * @param name The name to apply to the thread.
1762 */
1763 extern void thread_set_thread_name(thread_t th, const char* name);
1764
1765 #if !MACH_KERNEL_PRIVATE || !defined(current_thread)
1766 extern thread_t current_thread(void) __pure2;
1767 #endif
1768
1769 extern uint64_t thread_tid(thread_t thread) __pure2;
1770
1771 extern void thread_reference(
1772 thread_t thread);
1773
1774 extern void thread_deallocate(
1775 thread_t thread);
1776
1777 /*! @function kernel_thread_start
1778 * @abstract Create a kernel thread.
1779 * @discussion This function takes three input parameters, namely reference
1780 * to the function that the thread should execute, caller specified data
1781 * and a reference which is used to return the newly created kernel
1782 * thread. The function returns KERN_SUCCESS on success or an appropriate
1783 * kernel code type indicating the error. It may be noted that the caller
1784 * is responsible for explicitly releasing the reference to the created
1785 * thread when no longer needed. This should be done by calling
1786 * thread_deallocate(new_thread).
1787 * @param continuation A C-function pointer where the thread will begin execution.
1788 * @param parameter Caller specified data to be passed to the new thread.
1789 * @param new_thread Reference to the new thread is returned in this parameter.
1790 * @result Returns KERN_SUCCESS on success or an appropriate kernel code type.
1791 */
1792
1793 extern kern_return_t kernel_thread_start(
1794 thread_continue_t continuation,
1795 void *parameter,
1796 thread_t *new_thread);
1797
1798 __END_DECLS
1799
1800 #endif /* _KERN_THREAD_H_ */
1801