X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/2d21ac55c334faf3a56e5634905ed6987fc787d4..c3c9b80d004dbbfdf763edeb97968c6997e3b45b:/osfmk/kern/timer_call.h diff --git a/osfmk/kern/timer_call.h b/osfmk/kern/timer_call.h index d3beccfc7..37bf58b6f 100644 --- a/osfmk/kern/timer_call.h +++ b/osfmk/kern/timer_call.h @@ -1,9 +1,8 @@ /* - * Copyright (c) 1993-1995, 1999-2000 Apple Computer, Inc. - * All rights reserved. + * Copyright (c) 1993-1995, 1999-2008 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ - * + * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in @@ -12,10 +11,10 @@ * unlawful or unlicensed copies of an Apple operating system, or to * circumvent, violate, or enable the circumvention or violation of, any * terms of an Apple operating system software license agreement. - * + * * Please obtain a copy of the License at * http://www.opensource.apple.com/apsl/ and read it before using this file. - * + * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, @@ -23,68 +22,251 @@ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. - * + * * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ + /* - * Declarations for timer interrupt callouts. + * The timer_call system is responsible for manipulating timers that call + * callbacks at a given deadline (with or without some leeway for coalescing). * - * HISTORY + * Call timer_call_setup once on a timer_call structure to register the callback + * function and a context parameter that's passed to it (param0). * - * 20 December 2000 (debo) - * Created. + * To arm the timer to fire at a deadline, call any of the timer_call_enter + * functions. If the function used accepts a parameter, it will be passed to + * the callback function when it fires. + * + * If the timer needs to be cancelled (like if the timer_call has been armed but + * now needs to be deallocated), call timer_call_cancel. */ #ifndef _KERN_TIMER_CALL_H_ #define _KERN_TIMER_CALL_H_ #include +#include + +#ifdef XNU_KERNEL_PRIVATE + +#include #ifdef MACH_KERNEL_PRIVATE +#include +#include +#include + +extern boolean_t mach_timer_coalescing_enabled; +extern void timer_call_queue_init(mpqueue_head_t *); +#endif /* MACH_KERNEL_PRIVATE */ + +#if XNU_TARGET_OS_OSX +#define TIMER_TRACE 1 +#endif + +typedef void *timer_call_param_t; +typedef void (*timer_call_func_t)( + timer_call_param_t param0, + timer_call_param_t param1); + +typedef struct timer_call { + uint64_t tc_soft_deadline; + decl_simple_lock_data(, tc_lock); /* protects tc_queue */ + struct priority_queue_entry_deadline tc_pqlink; + queue_head_t *tc_queue; + queue_chain_t tc_qlink; + timer_call_func_t tc_func; + timer_call_param_t tc_param0; + timer_call_param_t tc_param1; + uint64_t tc_ttd; /* Time to deadline at creation */ +#if TIMER_TRACE + uint64_t tc_entry_time; +#endif + uint32_t tc_flags; + /* this field is locked by the lock in the object tc_queue points at */ + bool tc_async_dequeue; +} timer_call_data_t, *timer_call_t; + +#define EndOfAllTime 0xFFFFFFFFFFFFFFFFULL + + +/* + * Flags to alter the default timer/timeout coalescing behavior + * on a per-timer_call basis. + * + * The SYS urgency classes indicate that the timer_call is not + * directly related to the current thread at the time the timer_call + * is entered, so it is ignored in the calculation entirely (only + * the subclass specified is used). + * + * The USER flags indicate that both the current thread scheduling and QoS + * attributes, in addition to the per-timer_call urgency specification, + * are used to establish coalescing behavior. + */ +#define TIMER_CALL_SYS_NORMAL TIMEOUT_URGENCY_SYS_NORMAL +#define TIMER_CALL_SYS_CRITICAL TIMEOUT_URGENCY_SYS_CRITICAL +#define TIMER_CALL_SYS_BACKGROUND TIMEOUT_URGENCY_SYS_BACKGROUND -typedef struct call_entry *timer_call_t; -typedef void *timer_call_param_t; -typedef void (*timer_call_func_t)( - timer_call_param_t param0, - timer_call_param_t param1); +#define TIMER_CALL_USER_MASK TIMEOUT_URGENCY_USER_MASK +#define TIMER_CALL_USER_NORMAL TIMEOUT_URGENCY_USER_NORMAL +#define TIMER_CALL_USER_CRITICAL TIMEOUT_URGENCY_USER_CRITICAL +#define TIMER_CALL_USER_BACKGROUND TIMEOUT_URGENCY_USER_BACKGROUND -boolean_t -timer_call_enter( - timer_call_t call, - uint64_t deadline); +#define TIMER_CALL_URGENCY_MASK TIMEOUT_URGENCY_MASK + +/* + * Indicate that a specific leeway value is being provided (otherwise + * the leeway parameter is ignored). This supplied value can currently + * only be used to extend the leeway calculated internally from the + * urgency class provided. + */ +#define TIMER_CALL_LEEWAY TIMEOUT_URGENCY_LEEWAY + +/* + * Non-migratable timer_call + */ +#define TIMER_CALL_LOCAL TIMEOUT_URGENCY_FIRST_AVAIL +#define TIMER_CALL_RATELIMITED TIMEOUT_URGENCY_RATELIMITED +extern boolean_t timer_call_enter( + timer_call_t call, + uint64_t deadline, + uint32_t flags); -boolean_t -timer_call_enter1( - timer_call_t call, - timer_call_param_t param1, - uint64_t deadline); +extern boolean_t timer_call_enter1( + timer_call_t call, + timer_call_param_t param1, + uint64_t deadline, + uint32_t flags); -boolean_t -timer_call_cancel( - timer_call_t call); +extern boolean_t timer_call_enter_with_leeway( + timer_call_t call, + timer_call_param_t param1, + uint64_t deadline, + uint64_t leeway, + uint32_t flags, + boolean_t ratelimited); -boolean_t -timer_call_is_delayed( - timer_call_t call, - uint64_t *deadline); +extern boolean_t timer_call_cancel( + timer_call_t call); -#include +extern void timer_call_setup( + timer_call_t call, + timer_call_func_t func, + timer_call_param_t param0); -typedef struct call_entry timer_call_data_t; +extern int timer_get_user_idle_level(void); +extern kern_return_t timer_set_user_idle_level(int ilevel); -void -timer_call_initialize(void); +#define NUM_LATENCY_QOS_TIERS (6) +typedef struct { + uint32_t powergate_latency_abstime; -void -timer_call_setup( - timer_call_t call, - timer_call_func_t func, - timer_call_param_t param0); + uint32_t idle_entry_timer_processing_hdeadline_threshold_abstime; + uint32_t interrupt_timer_coalescing_ilat_threshold_abstime; + uint32_t timer_resort_threshold_abstime; -void -timer_call_shutdown( - processor_t processor); + int32_t timer_coalesce_rt_shift; + int32_t timer_coalesce_bg_shift; + int32_t timer_coalesce_kt_shift; + int32_t timer_coalesce_fp_shift; + int32_t timer_coalesce_ts_shift; + + uint64_t timer_coalesce_rt_abstime_max; + uint64_t timer_coalesce_bg_abstime_max; + uint64_t timer_coalesce_kt_abstime_max; + uint64_t timer_coalesce_fp_abstime_max; + uint64_t timer_coalesce_ts_abstime_max; + + uint32_t latency_qos_scale[NUM_LATENCY_QOS_TIERS]; + uint64_t latency_qos_abstime_max[NUM_LATENCY_QOS_TIERS]; + boolean_t latency_tier_rate_limited[NUM_LATENCY_QOS_TIERS]; +} timer_coalescing_priority_params_t; +extern timer_coalescing_priority_params_t tcoal_prio_params; + +/* + * Initialize the timer call subsystem during system startup. + */ +extern void timer_call_init(void); + +#if MACH_KERNEL_PRIVATE + +/* + * Handle deadlines in the past. + */ +uint64_t timer_call_past_deadline_timer_handle(uint64_t deadline, + uint64_t ctime); + +/* + * Running timers are only active for a given CPU when a non-idle thread + * is running. + */ + +enum running_timer { + RUNNING_TIMER_QUANTUM, +#if KPERF + RUNNING_TIMER_KPERF, +#endif /* KPERF */ + RUNNING_TIMER_MAX, +}; + +/* + * Get the earliest active deadline for this processor. + */ +uint64_t running_timers_deadline(processor_t processor); + +/* + * Run the expire handler to process any timers past their deadline. Returns + * true if any timer was processed, and false otherwise. + */ +bool running_timers_expire(processor_t processor, uint64_t now); + +/* + * Set up a new deadline for the given running timer on the processor, but don't + * synchronize it with the hardware. A subsequent call to running_timers_sync + * is necessary. This allows thread_dispatch to batch all of the setup and only + * set the decrementer once. + */ +void running_timer_setup(processor_t processor, enum running_timer timer, + void *param, uint64_t deadline, uint64_t now); + +/* + * Synchronize the state of any running timers that have been set up with the + * hardware. + */ +void running_timers_sync(void); + +/* + * Enter a new deadline for the given running timer on the processor and put it + * into effect. + */ +void running_timer_enter(processor_t processor, enum running_timer timer, + void *param, uint64_t deadline, uint64_t now); + +/* + * Clear the deadline and parameters for the given running timer on the + * processor. + */ +void running_timer_clear(processor_t processor, enum running_timer timer); + +/* + * Cancel a running timer on the processor. + */ +void running_timer_cancel(processor_t processor, enum running_timer timer); + +/* + * Activate the running timers for the given, current processor. Should only be + * called by thread_dispatch. + */ +void running_timers_activate(processor_t processor); + +/* + * Deactivate the running timers for the given, current processor. Should only + * be called by thread_dispatch. + */ +void running_timers_deactivate(processor_t processor); #endif /* MACH_KERNEL_PRIVATE */ +#endif /* XNU_KERNEL_PRIVATE */ + #endif /* _KERN_TIMER_CALL_H_ */