bool
testthreadcall::start( IOService * provider )
{
boolean_t ret;
uint64_t deadline;
IOLog("%s\n", __PRETTY_FUNCTION__);
if (!super::start(provider)) {
return false;
}
IOLog("Attempting thread_call_allocate\n");
tcall = thread_call_allocate(thread_call_test_func, this);
IOLog("thread_call_t %p\n", tcall);
tlock = IOSimpleLockAlloc();
IOLog("tlock %p\n", tlock);
clock_interval_to_deadline(5, NSEC_PER_SEC, &deadline);
IOLog("%d sec deadline is %llu\n", 5, deadline);
ret = thread_call_enter_delayed(tcall, deadline);
return true;
}
void IOHIKeyboard::scheduleAutoRepeat()
// Description: Schedule a procedure to be called when a timeout has expired
// so that we can generate a repeated key.
// Preconditions:
// * _deviceLock should be held on entry
{
KeyboardReserved *tempReservedStruct = GetKeyboardReservedStructEventForService(this);
if ( _calloutPending == true )
{
if (tempReservedStruct) {
thread_call_cancel(tempReservedStruct->repeat_thread_call);
}
_calloutPending = false;
}
if ( AbsoluteTime_to_scalar(&_downRepeatTime) )
{
AbsoluteTime deadline;
clock_absolutetime_interval_to_deadline(_downRepeatTime, &deadline);
if (tempReservedStruct) {
thread_call_enter_delayed(tempReservedStruct->repeat_thread_call, deadline);
}
_calloutPending = true;
}
}
void
SCSIPressurePathManager::PortBandwidthGlobals::SetTimer ( void )
{
AbsoluteTime time;
clock_interval_to_deadline ( 3000, kMillisecondScale, &time );
thread_call_enter_delayed ( gThread, time );
}
void OSMetaClass::considerUnloads()
{
static thread_call_t unloadCallout;
AbsoluteTime when;
mutex_lock(loadLock);
if (!unloadCallout)
unloadCallout = thread_call_allocate(&_OSMetaClassConsiderUnloads, 0);
thread_call_cancel(unloadCallout);
clock_interval_to_deadline(sConsiderUnloadDelay, 1000 * 1000 * 1000, &when);
thread_call_enter_delayed(unloadCallout, when);
mutex_unlock(loadLock);
}
thread_call_t
dtrace_timeout(void (*func)(void *, void *), void* arg, uint64_t nanos)
{
#pragma unused(arg)
thread_call_t call = thread_call_allocate(func, NULL);
nanoseconds_to_absolutetime(nanos, &nanos);
/*
* This method does not use clock_deadline_for_periodic_event() because it is a one-shot,
* and clock drift on later invocations is not a worry.
*/
uint64_t deadline = mach_absolute_time() + nanos;
thread_call_enter_delayed(call, deadline);
return call;
}
void darwin_iwi3945::queue_te(int num, thread_call_func_t func, thread_call_param_t par, UInt32 timei, bool start)
{
if (tlink[num]) queue_td(num,NULL);
//IWI_DEBUG("queue_te0 %d\n",tlink[num]);
if (!tlink[num]) tlink[num]=thread_call_allocate(func,this);
//IWI_DEBUG("queue_te1 %d\n",tlink[num]);
uint64_t timei2;
if (timei) clock_interval_to_deadline(timei,kMillisecondScale,&timei2);
//IWI_DEBUG("queue_te time %d %d\n",timei,timei2);
int r;
if (start==true && tlink[num])
{
if (!par && !timei) r=thread_call_enter(tlink[num]);
if (!par && timei) r=thread_call_enter_delayed(tlink[num],timei2);
if (par && !timei) r=thread_call_enter1(tlink[num],par);
if (par && timei) r=thread_call_enter1_delayed(tlink[num],par,timei2);
}
//IWI_DEBUG("queue_te result %d\n",r);
}
IOReturn NoSleepExtension::clamshellEventInterestHandler(UInt32 messageType, IOService * provider,
void * messageArgument, vm_size_t argSize)
{
if(messageType == kIOPMMessageClamshellStateChange)
{
#ifdef DEBUG
IOLog("%s[%p]::%s(%u, %p, %p, %lu)\n", getName(), this, __FUNCTION__,
(unsigned int)messageType, provider, messageArgument, (long unsigned int)argSize);
#endif
clamshellState = (bool)(((uintptr_t)messageArgument) & kClamshellStateBit);
clamshellShouldSleep = (bool)(((uintptr_t)messageArgument) & kClamshellSleepBit);
isClamshellStateInitialized = true;
if((getCurrentSleepSuppressionState() == kNoSleepStateEnabled)) {
setUserSleepDisabled(true);
UInt64 deadline;
clock_interval_to_deadline(10, kSecondScale, &deadline);
thread_call_enter_delayed(delayTimer, deadline);
if(clamshellShouldSleep) {
pRootDomain->receivePowerNotification(kIOPMDisableClamshell);
}
// Lock screen when lid closed
if(clamshellState == true && oldClamshellState == false) {
lockScreen();
//notify_
//notify_post("com.apple.loginwindow.notify");
//mach_port_t bp = bootstrap_port;
//task_get_bootstrap_port(bootstrap_port, &bp);
}
}
oldClamshellState = clamshellState;
}
return kIOReturnSuccess;
}
kern_return_t
mk_timer_arm_trap(
struct mk_timer_arm_trap_args *args)
{
mach_port_name_t name = args->name;
uint64_t expire_time = args->expire_time;
mk_timer_t timer;
ipc_space_t myspace = current_space();
ipc_port_t port;
kern_return_t result;
result = ipc_port_translate_receive(myspace, name, &port);
if (result != KERN_SUCCESS)
return (result);
if (ip_kotype(port) == IKOT_TIMER) {
timer = (mk_timer_t)port->ip_kobject;
assert(timer != NULL);
simple_lock(&timer->lock);
assert(timer->port == port);
ip_unlock(port);
if (!timer->is_dead) {
timer->is_armed = TRUE;
if (!thread_call_enter_delayed(&timer->call_entry, expire_time))
timer->active++;
}
simple_unlock(&timer->lock);
}
else {
ip_unlock(port);
result = KERN_INVALID_ARGUMENT;
}
return (result);
}
