/*
 * Copyright (c) 1998-2000, 2009-2010 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
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * 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,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * 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@
 */

#define IOKIT_ENABLE_SHARED_PTR

#include <libkern/OSDebug.h>
#include <libkern/c++/OSSharedPtr.h>

#include <IOKit/IOCommandGate.h>
#include <IOKit/IOWorkLoop.h>
#include <IOKit/IOReturn.h>
#include <IOKit/IOTimeStamp.h>
#include <IOKit/IOKitDebug.h>

#define super IOEventSource

OSDefineMetaClassAndStructorsWithZone(IOCommandGate, IOEventSource, ZC_NONE)
#if __LP64__
OSMetaClassDefineReservedUnused(IOCommandGate, 0);
#else
OSMetaClassDefineReservedUsedX86(IOCommandGate, 0);
#endif
OSMetaClassDefineReservedUnused(IOCommandGate, 1);
OSMetaClassDefineReservedUnused(IOCommandGate, 2);
OSMetaClassDefineReservedUnused(IOCommandGate, 3);
OSMetaClassDefineReservedUnused(IOCommandGate, 4);
OSMetaClassDefineReservedUnused(IOCommandGate, 5);
OSMetaClassDefineReservedUnused(IOCommandGate, 6);
OSMetaClassDefineReservedUnused(IOCommandGate, 7);

#if IOKITSTATS

#define IOStatisticsInitializeCounter() \
do { \
	IOStatistics::setCounterType(IOEventSource::reserved->counter, kIOStatisticsCommandGateCounter); \
} while (0)

#define IOStatisticsActionCall() \
do { \
	IOStatistics::countCommandGateActionCall(IOEventSource::reserved->counter); \
} while (0)

#else

#define IOStatisticsInitializeCounter()
#define IOStatisticsActionCall()

#endif /* IOKITSTATS */

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wcast-function-type"

bool
IOCommandGate::init(OSObject *inOwner, Action inAction)
{
	bool res = super::init(inOwner, (IOEventSource::Action) inAction);
	if (res) {
		IOStatisticsInitializeCounter();
	}

	return res;
}

OSSharedPtr<IOCommandGate>
IOCommandGate::commandGate(OSObject *inOwner, Action inAction)
{
	OSSharedPtr<IOCommandGate> me = OSMakeShared<IOCommandGate>();

	if (me && !me->init(inOwner, inAction)) {
		return nullptr;
	}

	return me;
}

/* virtual */ void
IOCommandGate::disable()
{
	if (workLoop && !workLoop->inGate()) {
		OSReportWithBacktrace("IOCommandGate::disable() called when not gated");
	}

	super::disable();
}

/* virtual */ void
IOCommandGate::enable()
{
	if (workLoop) {
		closeGate();
		super::enable();
		wakeupGate(&enabled, /* oneThread */ false); // Unblock sleeping threads
		openGate();
	}
}

/* virtual */ void
IOCommandGate::free()
{
	if (workLoop) {
		setWorkLoop(NULL);
	}
	super::free();
}

enum{
	kSleepersRemoved     = 0x00000001,
	kSleepersWaitEnabled = 0x00000002,
	kSleepersActions     = 0x00000100,
	kSleepersActionsMask = 0xffffff00,
};

/* virtual */ void
IOCommandGate::setWorkLoop(IOWorkLoop *inWorkLoop)
{
	IOWorkLoop * wl;
	uintptr_t  * sleepersP = (uintptr_t *) &reserved;
	bool         defer;

	if (!inWorkLoop && (wl = workLoop)) {           // tearing down
		wl->closeGate();
		*sleepersP |= kSleepersRemoved;
		while (*sleepersP & kSleepersWaitEnabled) {
			thread_wakeup_with_result(&enabled, THREAD_INTERRUPTED);
			sleepGate(sleepersP, THREAD_UNINT);
		}
		*sleepersP &= ~kSleepersWaitEnabled;
		defer = (0 != (kSleepersActionsMask & *sleepersP));
		if (!defer) {
			super::setWorkLoop(NULL);
			*sleepersP &= ~kSleepersRemoved;
		}
		wl->openGate();
		return;
	}

	super::setWorkLoop(inWorkLoop);
}

IOReturn
IOCommandGate::runCommand(void *arg0, void *arg1,
    void *arg2, void *arg3)
{
	return runAction((Action) action, arg0, arg1, arg2, arg3);
}

IOReturn
IOCommandGate::attemptCommand(void *arg0, void *arg1,
    void *arg2, void *arg3)
{
	return attemptAction((Action) action, arg0, arg1, arg2, arg3);
}

#pragma clang diagnostic pop

static IOReturn
IOCommandGateActionToBlock(OSObject *owner,
    void *arg0, void *arg1,
    void *arg2, void *arg3)
{
	return ((IOEventSource::ActionBlock) arg0)();
}

IOReturn
IOCommandGate::runActionBlock(ActionBlock _action)
{
	return runAction(&IOCommandGateActionToBlock, _action);
}

IOReturn
IOCommandGate::runAction(Action inAction,
    void *arg0, void *arg1,
    void *arg2, void *arg3)
{
	IOWorkLoop * wl;
	uintptr_t  * sleepersP;

	if (!inAction) {
		return kIOReturnBadArgument;
	}
	if (!(wl = workLoop)) {
		return kIOReturnNotReady;
	}

	// closeGate is recursive needn't worry if we already hold the lock.
	wl->closeGate();
	sleepersP = (uintptr_t *) &reserved;

	// If the command gate is disabled and we aren't on the workloop thread
	// itself then sleep until we get enabled.
	IOReturn res;
	if (!wl->onThread()) {
		while (!enabled) {
			IOReturn sleepResult = kIOReturnSuccess;
			if (workLoop) {
				*sleepersP |= kSleepersWaitEnabled;
				sleepResult = wl->sleepGate(&enabled, THREAD_INTERRUPTIBLE);
				*sleepersP &= ~kSleepersWaitEnabled;
			}
			bool wakeupTearDown = (!workLoop || (0 != (*sleepersP & kSleepersRemoved)));
			if ((kIOReturnSuccess != sleepResult) || wakeupTearDown) {
				wl->openGate();

				if (wakeupTearDown) {
					wl->wakeupGate(sleepersP, false); // No further resources used
				}
				return kIOReturnAborted;
			}
		}
	}

	bool trace = (gIOKitTrace & kIOTraceCommandGates) ? true : false;

	if (trace) {
		IOTimeStampStartConstant(IODBG_CMDQ(IOCMDQ_ACTION),
		    VM_KERNEL_ADDRHIDE(inAction), VM_KERNEL_ADDRHIDE(owner));
	}

	IOStatisticsActionCall();

	// Must be gated and on the work loop or enabled

	*sleepersP += kSleepersActions;
	res = (*inAction)(owner, arg0, arg1, arg2, arg3);
	*sleepersP -= kSleepersActions;

	if (trace) {
		IOTimeStampEndConstant(IODBG_CMDQ(IOCMDQ_ACTION),
		    VM_KERNEL_ADDRHIDE(inAction), VM_KERNEL_ADDRHIDE(owner));
	}

	if (kSleepersRemoved == ((kSleepersActionsMask | kSleepersRemoved) & *sleepersP)) {
		// no actions outstanding
		*sleepersP &= ~kSleepersRemoved;
		super::setWorkLoop(NULL);
	}

	wl->openGate();

	return res;
}

IOReturn
IOCommandGate::attemptAction(Action inAction,
    void *arg0, void *arg1,
    void *arg2, void *arg3)
{
	IOReturn res;
	IOWorkLoop * wl;

	if (!inAction) {
		return kIOReturnBadArgument;
	}
	if (!(wl = workLoop)) {
		return kIOReturnNotReady;
	}

	// Try to close the gate if can't get return immediately.
	if (!wl->tryCloseGate()) {
		return kIOReturnCannotLock;
	}

	// If the command gate is disabled then sleep until we get a wakeup
	if (!wl->onThread() && !enabled) {
		res = kIOReturnNotPermitted;
	} else {
		bool trace = (gIOKitTrace & kIOTraceCommandGates) ? true : false;

		if (trace) {
			IOTimeStampStartConstant(IODBG_CMDQ(IOCMDQ_ACTION),
			    VM_KERNEL_ADDRHIDE(inAction), VM_KERNEL_ADDRHIDE(owner));
		}

		IOStatisticsActionCall();

		res = (*inAction)(owner, arg0, arg1, arg2, arg3);

		if (trace) {
			IOTimeStampEndConstant(IODBG_CMDQ(IOCMDQ_ACTION),
			    VM_KERNEL_ADDRHIDE(inAction), VM_KERNEL_ADDRHIDE(owner));
		}
	}

	wl->openGate();

	return res;
}

IOReturn
IOCommandGate::commandSleep(void *event, UInt32 interruptible)
{
	if (!workLoop->inGate()) {
		/* The equivalent of 'msleep' while not holding the mutex is invalid */
		panic("invalid commandSleep while not holding the gate");
	}

	return sleepGate(event, interruptible);
}

IOReturn
IOCommandGate::commandSleep(void *event, AbsoluteTime deadline, UInt32 interruptible)
{
	if (!workLoop->inGate()) {
		/* The equivalent of 'msleep' while not holding the mutex is invalid */
		panic("invalid commandSleep while not holding the gate");
	}

	return sleepGate(event, deadline, interruptible);
}

void
IOCommandGate::commandWakeup(void *event, bool oneThread)
{
	wakeupGate(event, oneThread);
}