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_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 Software.Distribution@CS.CMU.EDU 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 csl-dist@cs.utah.edu 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/message.h> 90#include <mach/boolean.h> 91#include <mach/vm_param.h> 92#include <mach/thread_info.h> 93#include <mach/thread_status.h> 94#include <mach/exception_types.h> 95 96#include <kern/kern_types.h> 97 98#include <sys/cdefs.h> 99 100#ifdef MACH_KERNEL_PRIVATE 101 102#include <cputypes.h> 103 104#include <mach_assert.h> 105#include <mach_ldebug.h> 106 107#include <ipc/ipc_types.h> 108 109#include <mach/port.h> 110#include <kern/cpu_number.h> 111#include <kern/queue.h> 112#include <kern/timer.h> 113#include <kern/lock.h> 114#include <kern/locks.h> 115#include <kern/sched.h> 116#include <kern/sched_prim.h> 117#include <kern/thread_call.h> 118#include <kern/timer_call.h> 119#include <kern/task.h> 120#include <kern/exception.h> 121#include <kern/affinity.h> 122 123#include <ipc/ipc_kmsg.h> 124 125#include <machine/cpu_data.h> 126#include <machine/thread.h> 127 128struct thread { 129 /* 130 * NOTE: The runq field in the thread structure has an unusual 131 * locking protocol. If its value is PROCESSOR_NULL, then it is 132 * locked by the thread_lock, but if its value is something else 133 * then it is locked by the associated run queue lock. 134 * 135 * When the thread is on a wait queue, these first three fields 136 * are treated as an unofficial union with a wait_queue_element. 137 * If you change these, you must change that definition as well 138 * (kern/wait_queue.h). 139 */ 140 /* Items examined often, modified infrequently */ 141 queue_chain_t links; /* run/wait queue links */ 142 processor_t runq; /* run queue assignment */ 143 wait_queue_t wait_queue; /* wait queue we are currently on */ 144 event64_t wait_event; /* wait queue event */ 145 integer_t options; /* options set by thread itself */ 146#define TH_OPT_INTMASK 0x03 /* interrupt / abort level */ 147#define TH_OPT_VMPRIV 0x04 /* may allocate reserved memory */ 148#define TH_OPT_DTRACE 0x08 /* executing under dtrace_probe */ 149 150 /* Data updated during assert_wait/thread_wakeup */ 151 decl_simple_lock_data(,sched_lock) /* scheduling lock (thread_lock()) */ 152 decl_simple_lock_data(,wake_lock) /* for thread stop / wait (wake_lock()) */ 153 boolean_t wake_active; /* wake event on stop */ 154 int at_safe_point; /* thread_abort_safely allowed */ 155 ast_t reason; /* why we blocked */ 156 wait_result_t wait_result; /* outcome of wait - 157 * may be examined by this thread 158 * WITHOUT locking */ 159 thread_continue_t continuation; /* continue here next dispatch */ 160 void *parameter; /* continuation parameter */ 161 162 /* Data updated/used in thread_invoke */ 163 struct funnel_lock *funnel_lock; /* Non-reentrancy funnel */ 164 int funnel_state; 165#define TH_FN_OWNED 0x1 /* we own the funnel */ 166#define TH_FN_REFUNNEL 0x2 /* re-acquire funnel on dispatch */ 167 168 vm_offset_t kernel_stack; /* current kernel stack */ 169 vm_offset_t reserved_stack; /* reserved kernel stack */ 170 171 /* Thread state: */ 172 int state; 173/* 174 * Thread states [bits or'ed] 175 */ 176#define TH_WAIT 0x01 /* queued for waiting */ 177#define TH_SUSP 0x02 /* stopped or requested to stop */ 178#define TH_RUN 0x04 /* running or on runq */ 179#define TH_UNINT 0x08 /* waiting uninteruptibly */ 180#define TH_TERMINATE 0x10 /* halted at termination */ 181 182#define TH_IDLE 0x80 /* idling processor */ 183 184 /* Scheduling information */ 185 integer_t sched_mode; /* scheduling mode bits */ 186#define TH_MODE_REALTIME 0x0001 /* time constraints supplied */ 187#define TH_MODE_TIMESHARE 0x0002 /* use timesharing algorithm */ 188#define TH_MODE_FAILSAFE 0x0004 /* fail-safe has tripped */ 189#define TH_MODE_PROMOTED 0x0008 /* sched pri has been promoted */ 190#define TH_MODE_ABORT 0x0010 /* abort interruptible waits */ 191#define TH_MODE_ABORTSAFELY 0x0020 /* ... but only those at safe point */ 192#define TH_MODE_ISABORTED (TH_MODE_ABORT | TH_MODE_ABORTSAFELY) 193#define TH_MODE_DEPRESS 0x0040 /* normal depress yield */ 194#define TH_MODE_POLLDEPRESS 0x0080 /* polled depress yield */ 195#define TH_MODE_ISDEPRESSED (TH_MODE_DEPRESS | TH_MODE_POLLDEPRESS) 196 197 integer_t sched_pri; /* scheduled (current) priority */ 198 integer_t priority; /* base priority */ 199 integer_t max_priority; /* max base priority */ 200 integer_t task_priority; /* copy of task base priority */ 201 202 integer_t promotions; /* level of promotion */ 203 integer_t pending_promoter_index; 204 void *pending_promoter[2]; 205 206 integer_t importance; /* task-relative importance */ 207 208 /* real-time parameters */ 209 struct { /* see mach/thread_policy.h */ 210 uint32_t period; 211 uint32_t computation; 212 uint32_t constraint; 213 boolean_t preemptible; 214 215 uint64_t deadline; 216 } realtime; 217 218 uint32_t current_quantum; /* duration of current quantum */ 219 220 /* Data used during setrun/dispatch */ 221 timer_data_t system_timer; /* system mode timer */ 222 processor_t bound_processor; /* bound to a processor? */ 223 processor_t last_processor; /* processor last dispatched on */ 224 uint64_t last_switch; /* time of last context switch */ 225 226 /* Fail-safe computation since last unblock or qualifying yield */ 227 uint64_t computation_metered; 228 uint64_t computation_epoch; 229 integer_t safe_mode; /* saved mode during fail-safe */ 230 natural_t safe_release; /* when to release fail-safe */ 231 232 /* Call out from scheduler */ 233 void (*sched_call)( 234 int type, 235 thread_t thread); 236 237 /* Statistics and timesharing calculations */ 238 natural_t sched_stamp; /* last scheduler tick */ 239 natural_t sched_usage; /* timesharing cpu usage [sched] */ 240 natural_t pri_shift; /* usage -> priority from pset */ 241 natural_t cpu_usage; /* instrumented cpu usage [%cpu] */ 242 natural_t cpu_delta; /* accumulated cpu_usage delta */ 243 uint32_t c_switch; /* total context switches */ 244 uint32_t p_switch; /* total processor switches */ 245 uint32_t ps_switch; /* total pset switches */ 246 247 /* Timing data structures */ 248 timer_data_t user_timer; /* user mode timer */ 249 uint64_t user_timer_save; /* saved user timer value */ 250 uint64_t system_timer_save; /* saved system timer value */ 251 uint64_t vtimer_user_save; /* saved values for vtimers */ 252 uint64_t vtimer_prof_save; 253 uint64_t vtimer_rlim_save; 254 255 /* Timed wait expiration */ 256 timer_call_data_t wait_timer; 257 integer_t wait_timer_active; 258 boolean_t wait_timer_is_set; 259 260 /* Priority depression expiration */ 261 timer_call_data_t depress_timer; 262 integer_t depress_timer_active; 263 264 /* 265 * Processor/cache affinity 266 * - affinity_threads links task threads with the same affinity set 267 */ 268 affinity_set_t affinity_set; 269 queue_chain_t affinity_threads; 270 271 /* Various bits of stashed state */ 272 union { 273 struct { 274 mach_msg_return_t state; /* receive state */ 275 ipc_object_t object; /* object received on */ 276 mach_vm_address_t msg_addr; /* receive buffer pointer */ 277 mach_msg_size_t msize; /* max size for recvd msg */ 278 mach_msg_option_t option; /* options for receive */ 279 mach_msg_size_t slist_size; /* scatter list size */ 280 struct ipc_kmsg *kmsg; /* received message */ 281 mach_port_seqno_t seqno; /* seqno of recvd message */ 282 mach_msg_continue_t continuation; 283 } receive; 284 struct { 285 struct semaphore *waitsemaphore; /* semaphore ref */ 286 struct semaphore *signalsemaphore; /* semaphore ref */ 287 int options; /* semaphore options */ 288 kern_return_t result; /* primary result */ 289 mach_msg_continue_t continuation; 290 } sema; 291 struct { 292 int option; /* switch option */ 293 } swtch; 294 int misc; /* catch-all for other state */ 295 } saved; 296 297 /* IPC data structures */ 298 struct ipc_kmsg_queue ith_messages; 299 mach_port_t ith_rpc_reply; /* reply port for kernel RPCs */ 300 301 /* Ast/Halt data structures */ 302 vm_offset_t recover; /* page fault recover(copyin/out) */ 303 uint32_t ref_count; /* number of references to me */ 304 305 queue_chain_t threads; /* global list of all threads */ 306 307 /* Activation */ 308 queue_chain_t task_threads; 309 310 /*** Machine-dependent state ***/ 311 struct machine_thread machine; 312 313 /* Task membership */ 314 struct task *task; 315 vm_map_t map; 316 317 decl_mutex_data(,mutex) 318 319 /* Kernel holds on this thread */ 320 int suspend_count; 321 322 /* User level suspensions */ 323 int user_stop_count; 324 325 /* Pending thread ast(s) */ 326 ast_t ast; 327 328 /* Miscellaneous bits guarded by mutex */ 329 uint32_t 330 active:1, /* Thread is active and has not been terminated */ 331 started:1, /* Thread has been started after creation */ 332 static_param:1, /* Disallow policy parameter changes */ 333 :0; 334 335 /* Return Handers */ 336 struct ReturnHandler { 337 struct ReturnHandler *next; 338 void (*handler)( 339 struct ReturnHandler *rh, 340 struct thread *thread); 341 } *handlers, special_handler; 342 343 /* Ports associated with this thread */ 344 struct ipc_port *ith_self; /* not a right, doesn't hold ref */ 345 struct ipc_port *ith_sself; /* a send right */ 346 struct exception_action exc_actions[EXC_TYPES_COUNT]; 347 348 /* Owned ulocks (a lock set element) */ 349 queue_head_t held_ulocks; 350 351#ifdef MACH_BSD 352 void *uthread; 353#endif 354 355#if CONFIG_DTRACE 356 uint32_t t_dtrace_predcache;/* DTrace per thread predicate value hint */ 357 int64_t t_dtrace_tracing; /* Thread time under dtrace_probe() */ 358 int64_t t_dtrace_vtime; 359#endif 360 uint32_t t_chud; /* CHUD flags, used for Shark */ 361}; 362 363#define ith_state saved.receive.state 364#define ith_object saved.receive.object 365#define ith_msg_addr saved.receive.msg_addr 366#define ith_msize saved.receive.msize 367#define ith_option saved.receive.option 368#define ith_scatter_list_size saved.receive.slist_size 369#define ith_continuation saved.receive.continuation 370#define ith_kmsg saved.receive.kmsg 371#define ith_seqno saved.receive.seqno 372 373#define sth_waitsemaphore saved.sema.waitsemaphore 374#define sth_signalsemaphore saved.sema.signalsemaphore 375#define sth_options saved.sema.options 376#define sth_result saved.sema.result 377#define sth_continuation saved.sema.continuation 378 379extern void thread_bootstrap(void) __attribute__((section("__TEXT, initcode"))); 380 381extern void thread_init(void) __attribute__((section("__TEXT, initcode"))); 382 383extern void thread_daemon_init(void); 384 385#define thread_reference_internal(thread) \ 386 (void)hw_atomic_add(&(thread)->ref_count, 1) 387 388#define thread_deallocate_internal(thread) \ 389 hw_atomic_sub(&(thread)->ref_count, 1) 390 391#define thread_reference(thread) \ 392MACRO_BEGIN \ 393 if ((thread) != THREAD_NULL) \ 394 thread_reference_internal(thread); \ 395MACRO_END 396 397extern void thread_deallocate( 398 thread_t thread); 399 400extern void thread_terminate_self(void); 401 402extern kern_return_t thread_terminate_internal( 403 thread_t thread); 404 405extern void thread_start_internal( 406 thread_t thread) __attribute__ ((noinline)); 407 408extern void thread_terminate_enqueue( 409 thread_t thread); 410 411extern void thread_stack_enqueue( 412 thread_t thread); 413 414extern void thread_hold( 415 thread_t thread); 416 417extern void thread_release( 418 thread_t thread); 419 420#define thread_lock_init(th) simple_lock_init(&(th)->sched_lock, 0) 421#define thread_lock(th) simple_lock(&(th)->sched_lock) 422#define thread_unlock(th) simple_unlock(&(th)->sched_lock) 423 424#define wake_lock_init(th) simple_lock_init(&(th)->wake_lock, 0) 425#define wake_lock(th) simple_lock(&(th)->wake_lock) 426#define wake_unlock(th) simple_unlock(&(th)->wake_lock) 427 428#define thread_should_halt_fast(thread) (!(thread)->active) 429 430extern void stack_alloc( 431 thread_t thread); 432 433extern void stack_free( 434 thread_t thread); 435 436extern void stack_free_stack( 437 vm_offset_t stack); 438 439extern boolean_t stack_alloc_try( 440 thread_t thread); 441 442extern void stack_collect(void); 443 444extern void stack_init(void) __attribute__((section("__TEXT, initcode"))); 445 446extern kern_return_t thread_state_initialize( 447 thread_t thread); 448 449extern kern_return_t thread_setstatus( 450 thread_t thread, 451 int flavor, 452 thread_state_t tstate, 453 mach_msg_type_number_t count); 454 455extern kern_return_t thread_getstatus( 456 thread_t thread, 457 int flavor, 458 thread_state_t tstate, 459 mach_msg_type_number_t *count); 460 461extern kern_return_t thread_info_internal( 462 thread_t thread, 463 thread_flavor_t flavor, 464 thread_info_t thread_info_out, 465 mach_msg_type_number_t *thread_info_count); 466 467extern void thread_task_priority( 468 thread_t thread, 469 integer_t priority, 470 integer_t max_priority); 471 472extern void thread_policy_reset( 473 thread_t thread); 474 475extern kern_return_t kernel_thread_create( 476 thread_continue_t continuation, 477 void *parameter, 478 integer_t priority, 479 thread_t *new_thread); 480 481extern kern_return_t kernel_thread_start_priority( 482 thread_continue_t continuation, 483 void *parameter, 484 integer_t priority, 485 thread_t *new_thread); 486 487extern void machine_stack_attach( 488 thread_t thread, 489 vm_offset_t stack); 490 491extern vm_offset_t machine_stack_detach( 492 thread_t thread); 493 494extern void machine_stack_handoff( 495 thread_t old, 496 thread_t new); 497 498extern thread_t machine_switch_context( 499 thread_t old_thread, 500 thread_continue_t continuation, 501 thread_t new_thread); 502 503extern void machine_load_context( 504 thread_t thread); 505 506extern kern_return_t machine_thread_state_initialize( 507 thread_t thread); 508 509extern kern_return_t machine_thread_set_state( 510 thread_t thread, 511 thread_flavor_t flavor, 512 thread_state_t state, 513 mach_msg_type_number_t count); 514 515extern kern_return_t machine_thread_get_state( 516 thread_t thread, 517 thread_flavor_t flavor, 518 thread_state_t state, 519 mach_msg_type_number_t *count); 520 521extern kern_return_t machine_thread_dup( 522 thread_t self, 523 thread_t target); 524 525extern void machine_thread_init(void); 526 527extern kern_return_t machine_thread_create( 528 thread_t thread, 529 task_t task); 530extern void machine_thread_switch_addrmode( 531 thread_t thread); 532 533extern void machine_thread_destroy( 534 thread_t thread); 535 536extern void machine_set_current_thread( 537 thread_t thread); 538 539extern void machine_thread_terminate_self(void); 540 541extern kern_return_t machine_thread_get_kern_state( 542 thread_t thread, 543 thread_flavor_t flavor, 544 thread_state_t tstate, 545 mach_msg_type_number_t *count); 546 547 548/* 549 * XXX Funnel locks XXX 550 */ 551 552struct funnel_lock { 553 int fnl_type; /* funnel type */ 554 lck_mtx_t *fnl_mutex; /* underlying mutex for the funnel */ 555 void * fnl_mtxholder; /* thread (last)holdng mutex */ 556 void * fnl_mtxrelease; /* thread (last)releasing mutex */ 557 lck_mtx_t *fnl_oldmutex; /* Mutex before collapsing split funnel */ 558}; 559 560typedef struct ReturnHandler ReturnHandler; 561 562#define thread_mtx_lock(thread) mutex_lock(&(thread)->mutex) 563#define thread_mtx_try(thread) mutex_try(&(thread)->mutex) 564#define thread_mtx_unlock(thread) mutex_unlock(&(thread)->mutex) 565 566extern void act_execute_returnhandlers(void); 567 568extern void install_special_handler( 569 thread_t thread); 570 571extern void special_handler( 572 ReturnHandler *rh, 573 thread_t thread); 574 575void act_machine_sv_free(thread_t, int); 576 577#else /* MACH_KERNEL_PRIVATE */ 578 579__BEGIN_DECLS 580 581extern thread_t current_thread(void); 582 583extern void thread_reference( 584 thread_t thread); 585 586extern void thread_deallocate( 587 thread_t thread); 588 589__END_DECLS 590 591#endif /* MACH_KERNEL_PRIVATE */ 592 593#ifdef KERNEL_PRIVATE 594 595typedef struct funnel_lock funnel_t; 596 597#ifdef MACH_KERNEL_PRIVATE 598 599extern void funnel_lock( 600 funnel_t *lock); 601 602extern void funnel_unlock( 603 funnel_t *lock); 604 605vm_offset_t min_valid_stack_address(void); 606vm_offset_t max_valid_stack_address(void); 607 608#endif /* MACH_KERNEL_PRIVATE */ 609 610__BEGIN_DECLS 611 612extern funnel_t *thread_funnel_get(void); 613 614extern boolean_t thread_funnel_set( 615 funnel_t *lock, 616 boolean_t funneled); 617 618extern thread_t kernel_thread( 619 task_t task, 620 void (*start)(void)); 621 622__END_DECLS 623 624#endif /* KERNEL_PRIVATE */ 625 626__BEGIN_DECLS 627 628#ifdef XNU_KERNEL_PRIVATE 629 630extern void thread_yield_internal( 631 mach_msg_timeout_t interval); 632 633/* 634 * XXX Funnel locks XXX 635 */ 636 637#define THR_FUNNEL_NULL (funnel_t *)0 638 639extern funnel_t *funnel_alloc( 640 int type); 641 642extern void funnel_free( 643 funnel_t *lock); 644 645extern void thread_read_times( 646 thread_t thread, 647 time_value_t *user_time, 648 time_value_t *system_time); 649 650extern void thread_setuserstack( 651 thread_t thread, 652 mach_vm_offset_t user_stack); 653 654extern uint64_t thread_adjuserstack( 655 thread_t thread, 656 int adjust); 657 658extern void thread_setentrypoint( 659 thread_t thread, 660 mach_vm_offset_t entry); 661 662extern kern_return_t thread_setsinglestep( 663 thread_t thread, 664 int on); 665 666extern kern_return_t thread_wire_internal( 667 host_priv_t host_priv, 668 thread_t thread, 669 boolean_t wired, 670 boolean_t *prev_state); 671 672extern kern_return_t thread_dup(thread_t); 673 674typedef void (*sched_call_t)( 675 int type, 676 thread_t thread); 677 678#define SCHED_CALL_BLOCK 0x1 679#define SCHED_CALL_UNBLOCK 0x2 680 681extern void thread_sched_call( 682 thread_t thread, 683 sched_call_t call); 684 685extern void thread_static_param( 686 thread_t thread, 687 boolean_t state); 688 689extern task_t get_threadtask(thread_t); 690#define thread_is_64bit(thd) \ 691 task_has_64BitAddr(get_threadtask(thd)) 692 693 694extern void *get_bsdthread_info(thread_t); 695extern void set_bsdthread_info(thread_t, void *); 696extern void *uthread_alloc(task_t, thread_t); 697extern void uthread_cleanup(task_t, void *, void *); 698extern void uthread_zone_free(void *); 699extern void uthread_cred_free(void *); 700 701extern boolean_t thread_should_halt( 702 thread_t thread); 703 704extern int is_64signalregset(void); 705 706void act_set_apc(thread_t); 707 708extern uint32_t dtrace_get_thread_predcache(thread_t); 709extern int64_t dtrace_get_thread_vtime(thread_t); 710extern int64_t dtrace_get_thread_tracing(thread_t); 711extern boolean_t dtrace_get_thread_reentering(thread_t); 712extern vm_offset_t dtrace_get_kernel_stack(thread_t); 713extern void dtrace_set_thread_predcache(thread_t, uint32_t); 714extern void dtrace_set_thread_vtime(thread_t, int64_t); 715extern void dtrace_set_thread_tracing(thread_t, int64_t); 716extern void dtrace_set_thread_reentering(thread_t, boolean_t); 717extern vm_offset_t dtrace_set_thread_recover(thread_t, vm_offset_t); 718 719extern int64_t dtrace_calc_thread_recent_vtime(thread_t); 720 721 722extern void thread_set_wq_state32( 723 thread_t thread, 724 thread_state_t tstate); 725 726extern void thread_set_wq_state64( 727 thread_t thread, 728 thread_state_t tstate); 729 730#endif /* XNU_KERNEL_PRIVATE */ 731 732extern kern_return_t kernel_thread_start( 733 thread_continue_t continuation, 734 void *parameter, 735 thread_t *new_thread); 736 737__END_DECLS 738 739#endif /* _KERN_THREAD_H_ */ 740