[apple/xnu.git] / iokit / Tests / Tests.cpp

/*
 * Copyright (c) 1998-2000 Apple Computer, 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 TEST_HEADERS    0

#if TEST_HEADERS

#include <libkern/OSByteOrder.h>
#include <libkern/c++/OSArray.h>
#include <libkern/c++/OSBoolean.h>
#include <libkern/c++/OSCollection.h>
#include <libkern/c++/OSCollectionIterator.h>
#include <libkern/c++/OSContainers.h>
#include <libkern/c++/OSCPPDebug.h>
#include <libkern/c++/OSData.h>
#include <libkern/c++/OSDictionary.h>
#include <libkern/c++/OSEndianTypes.h>
#include <libkern/c++/OSIterator.h>
#include <libkern/c++/OSKext.h>
#include <libkern/c++/OSLib.h>
#include <libkern/c++/OSMetaClass.h>
#include <libkern/c++/OSNumber.h>
#include <libkern/c++/OSObject.h>
#include <libkern/c++/OSOrderedSet.h>
#include <libkern/c++/OSSerialize.h>
#include <libkern/c++/OSSet.h>
#include <libkern/c++/OSString.h>
#include <libkern/c++/OSSymbol.h>
#include <libkern/c++/OSUnserialize.h>
#include <libkern/crypto/aes.h>
#include <libkern/crypto/aesxts.h>
#include <libkern/crypto/crypto_internal.h>
#include <libkern/crypto/des.h>
#include <libkern/crypto/md5.h>
#include <libkern/crypto/register_crypto.h>
#include <libkern/crypto/sha1.h>
#include <libkern/crypto/sha2.h>
#include <libkern/kernel_mach_header.h>
#include <libkern/kext_request_keys.h>
#include <libkern/kxld.h>
#include <libkern/kxld_types.h>
#include <libkern/locks.h>
#include <libkern/mkext.h>
#include <libkern/OSAtomic.h>
#include <libkern/OSBase.h>
#include <libkern/OSDebug.h>
#include <libkern/OSKextLib.h>
#include <libkern/OSKextLibPrivate.h>
#include <libkern/OSMalloc.h>
#include <libkern/OSReturn.h>
#include <libkern/OSSerializeBinary.h>
#include <libkern/OSTypes.h>
#include <libkern/prelink.h>
#include <libkern/stack_protector.h>
#include <libkern/sysctl.h>
#include <libkern/tree.h>
#include <libkern/zconf.h>
#include <libkern/zlib.h>

#include <IOKit/AppleKeyStoreInterface.h>
#include <IOKit/assert.h>
#include <IOKit/IOBSD.h>
#include <IOKit/IOBufferMemoryDescriptor.h>
#include <IOKit/IOCatalogue.h>
#include <IOKit/IOCommand.h>
#include <IOKit/IOCommandGate.h>
#include <IOKit/IOCommandPool.h>
#include <IOKit/IOCommandQueue.h>
#include <IOKit/IOConditionLock.h>
#include <IOKit/IOCPU.h>
//#include <IOKit/IODataQueue.h>
#include <IOKit/IODataQueueShared.h>
#include <IOKit/IODeviceMemory.h>
#include <IOKit/IODeviceTreeSupport.h>
#include <IOKit/IODMACommand.h>
#include <IOKit/IODMAController.h>
#include <IOKit/IODMAEventSource.h>
#include <IOKit/IOEventSource.h>
#include <IOKit/IOFilterInterruptEventSource.h>
#include <IOKit/IOHibernatePrivate.h>
#include <IOKit/IOInterleavedMemoryDescriptor.h>
#include <IOKit/IOInterruptAccounting.h>
#include <IOKit/IOInterruptAccountingPrivate.h>
#include <IOKit/IOInterruptController.h>
#include <IOKit/IOInterruptEventSource.h>
#include <IOKit/IOInterrupts.h>
#include <IOKit/IOKernelReporters.h>
#include <IOKit/IOKernelReportStructs.h>
#include <IOKit/IOKitDebug.h>
#include <IOKit/IOKitDiagnosticsUserClient.h>
#include <IOKit/IOKitKeys.h>
#include <IOKit/IOKitKeysPrivate.h>
#include <IOKit/IOKitServer.h>
#include <IOKit/IOLib.h>
#include <IOKit/IOLocks.h>
#include <IOKit/IOLocksPrivate.h>
#include <IOKit/IOMapper.h>
#include <IOKit/IOMemoryCursor.h>
#include <IOKit/IOMemoryDescriptor.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOMultiMemoryDescriptor.h>
#include <IOKit/IONotifier.h>
#include <IOKit/IONVRAM.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/IOPolledInterface.h>
#include <IOKit/IORangeAllocator.h>
#include <IOKit/IORegistryEntry.h>
#include <IOKit/IOReportMacros.h>
#include <IOKit/IOReportTypes.h>
#include <IOKit/IOReturn.h>
#include <IOKit/IOService.h>
#include <IOKit/IOServicePM.h>
#include <IOKit/IOSharedDataQueue.h>
#include <IOKit/IOSharedLock.h>
#include <IOKit/IOStatistics.h>
#include <IOKit/IOStatisticsPrivate.h>
#include <IOKit/IOSubMemoryDescriptor.h>
#include <IOKit/IOSyncer.h>
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/IOTimeStamp.h>
#include <IOKit/IOTypes.h>
#include <IOKit/IOUserClient.h>
#include <IOKit/IOWorkLoop.h>
#include <IOKit/nvram/IONVRAMController.h>
#include <IOKit/OSMessageNotification.h>
#include <IOKit/platform/AppleMacIO.h>
#include <IOKit/platform/AppleMacIODevice.h>
#include <IOKit/platform/AppleNMI.h>
#include <IOKit/platform/ApplePlatformExpert.h>
#include <IOKit/power/IOPwrController.h>
#include <IOKit/pwr_mgt/IOPM.h>
#include <IOKit/pwr_mgt/IOPMinformee.h>
#include <IOKit/pwr_mgt/IOPMinformeeList.h>
#include <IOKit/pwr_mgt/IOPMLibDefs.h>
#include <IOKit/pwr_mgt/IOPMlog.h>
#include <IOKit/pwr_mgt/IOPMPowerSource.h>
#include <IOKit/pwr_mgt/IOPMPowerSourceList.h>
#include <IOKit/pwr_mgt/IOPMpowerState.h>
#include <IOKit/pwr_mgt/IOPMPrivate.h>
#include <IOKit/pwr_mgt/IOPowerConnection.h>
#include <IOKit/pwr_mgt/RootDomain.h>
#include <IOKit/rtc/IORTCController.h>
#include <IOKit/system.h>
#include <IOKit/system_management/IOWatchDogTimer.h>

#endif /* TEST_HEADERS */

#include <sys/sysctl.h>
#include <libkern/c++/OSData.h>
#include "Tests.h"


#if DEVELOPMENT || DEBUG

#include <IOKit/IOWorkLoop.h>
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/IOInterruptEventSource.h>
#include <IOKit/IOCommandGate.h>
#include <IOKit/IOPlatformExpert.h>
#include <libkern/Block.h>
#include <libkern/Block_private.h>

static uint64_t gIOWorkLoopTestDeadline;

static void
TESAction(OSObject * owner, IOTimerEventSource * tes)
{
	if (mach_absolute_time() < gIOWorkLoopTestDeadline) {
		tes->setTimeout(1, kMicrosecondScale);
	}
}

static int
IOWorkLoopTest(int newValue)
{
	IOReturn err;
	uint32_t idx;
	IOWorkLoop * wl;
	IOTimerEventSource * tes;
	IOInterruptEventSource * ies;

	wl = IOWorkLoop::workLoop();
	assert(wl);
	tes = IOTimerEventSource::timerEventSource(kIOTimerEventSourceOptionsPriorityWorkLoop, wl, &TESAction);
	assert(tes);
	err = wl->addEventSource(tes);
	assert(kIOReturnSuccess == err);
	clock_interval_to_deadline(100, kMillisecondScale, &gIOWorkLoopTestDeadline);
	for (idx = 0; mach_absolute_time() < gIOWorkLoopTestDeadline; idx++) {
		tes->setTimeout(idx & 1023, kNanosecondScale);
	}
	tes->cancelTimeout();
	wl->removeEventSource(tes);
	tes->release();

	int value = 3;

	tes = IOTimerEventSource::timerEventSource(kIOTimerEventSourceOptionsDefault, wl, ^(IOTimerEventSource * tes){
		kprintf("wl %p, value %d\n", wl, value);
	});
	err = wl->addEventSource(tes);
	assert(kIOReturnSuccess == err);

	value = 2;
	tes->setTimeout(1, kNanosecondScale);
	IOSleep(1);
	wl->removeEventSource(tes);
	tes->release();

	ies = IOInterruptEventSource::interruptEventSource(wl, NULL, 0, ^void (IOInterruptEventSource *sender, int count){
		kprintf("ies block %p, %d\n", sender, count);
	});

	assert(ies);
	kprintf("ies %p\n", ies);
	err = wl->addEventSource(ies);
	assert(kIOReturnSuccess == err);
	ies->interruptOccurred(NULL, NULL, 0);
	IOSleep(1);
	ies->interruptOccurred(NULL, NULL, 0);
	IOSleep(1);
	wl->removeEventSource(ies);
	ies->release();

	wl->release();

	return 0;
}

static int
OSCollectionTest(int newValue)
{
	OSArray * array = OSArray::withCapacity(8);
	array->setObject(kOSBooleanTrue);
	array->setObject(kOSBooleanFalse);
	array->setObject(kOSBooleanFalse);
	array->setObject(kOSBooleanTrue);
	array->setObject(kOSBooleanFalse);
	array->setObject(kOSBooleanTrue);

	__block unsigned int index;
	index = 0;
	array->iterateObjects(^bool (OSObject * obj) {
		kprintf("%d:%d ", index, (obj == kOSBooleanTrue) ? 1 : (obj == kOSBooleanFalse) ? 0 : 2);
		index++;
		return false;
	});
	kprintf("\n");
	array->release();

	OSDictionary * dict = IOService::resourceMatching("hello");
	assert(dict);
	index = 0;
	dict->iterateObjects(^bool (const OSSymbol * sym, OSObject * obj) {
		OSString * str = OSDynamicCast(OSString, obj);
		assert(str);
		kprintf("%d:%s=%s\n", index, sym->getCStringNoCopy(), str->getCStringNoCopy());
		index++;
		return false;
	});
	dict->release();

	OSSerializer * serializer = OSSerializer::withBlock(^bool (OSSerialize * s){
		return gIOBSDUnitKey->serialize(s);
	});
	assert(serializer);
	IOService::getPlatform()->setProperty("OSSerializer_withBlock", serializer);
	serializer->release();

	return 0;
}

#if 0
#include <IOKit/IOUserClient.h>
class TestUserClient : public IOUserClient
{
	OSDeclareDefaultStructors(TestUserClient);
	virtual void stop( IOService *provider) APPLE_KEXT_OVERRIDE;
	virtual bool finalize(IOOptionBits options) APPLE_KEXT_OVERRIDE;
	virtual IOReturn externalMethod( uint32_t selector,
	    IOExternalMethodArguments * arguments,
	    IOExternalMethodDispatch * dispatch,
	    OSObject * target,
	    void * reference ) APPLE_KEXT_OVERRIDE;
};

void
TestUserClient::stop( IOService *provider)
{
	kprintf("TestUserClient::stop\n");
}
bool
TestUserClient::finalize(IOOptionBits options)
{
	kprintf("TestUserClient::finalize\n");
	return true;
}
IOReturn
TestUserClient::externalMethod( uint32_t selector,
    IOExternalMethodArguments * arguments,
    IOExternalMethodDispatch * dispatch,
    OSObject * target,
    void * reference )
{
	getProvider()->terminate();
	IOSleep(500);
	return 0;
}
OSDefineMetaClassAndStructors(TestUserClient, IOUserClient);
#endif

static int
IOServiceTest(int newValue)
{
	OSDictionary      * matching;
	IONotifier        * note;
	__block IOService * found;

#if 0
	found = new IOService;
	found->init();
	found->setName("IOTestUserClientProvider");
	found->attach(IOService::getPlatform());
	found->setProperty("IOUserClientClass", "TestUserClient");
	found->registerService();
#endif

	matching = IOService::serviceMatching("IOPlatformExpert");
	assert(matching);
	found = nullptr;
	note = IOService::addMatchingNotification(gIOMatchedNotification, matching, 0,
	    ^bool (IOService * newService, IONotifier * notifier) {
		kprintf("found %s, %d\n", newService->getName(), newService->getRetainCount());
		found = newService;
		found->retain();
		return true;
	}
	    );
	assert(note);
	assert(found);
	matching->release();
	note->remove();

	note = found->registerInterest(gIOBusyInterest,
	    ^IOReturn (uint32_t messageType, IOService * provider,
	    void   * messageArgument, size_t argSize) {
		kprintf("%p messageType 0x%08x %p\n", provider, messageType, messageArgument);
		return kIOReturnSuccess;
	});
	assert(note);
	IOSleep(1 * 1000);
	note->remove();
	found->release();

	return 0;
}

#endif  /* DEVELOPMENT || DEBUG */

static int
sysctl_iokittest(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
{
	int error;
	int newValue, changed;

	error = sysctl_io_number(req, 0, sizeof(int), &newValue, &changed);
	if (error) {
		return error;
	}

#if DEVELOPMENT || DEBUG
	if (changed && (66 == newValue)) {
		IOReturn ret;
		IOWorkLoop * wl = IOWorkLoop::workLoop();
		IOCommandGate * cg = IOCommandGate::commandGate(wl);
		ret = wl->addEventSource(cg);

		struct x {
			uint64_t h;
			uint64_t l;
		};
		struct x y;

		y.h = 0x1111111122222222;
		y.l = 0x3333333344444444;

		kprintf("ret1 %d\n", ret);
		ret = cg->runActionBlock(^(){
			printf("hello %d 0x%qx\n", wl->inGate(), y.h);
			return 99;
		});
		kprintf("ret %d\n", ret);
	}

	if (changed && (999 == newValue)) {
		OSData * data = OSData::withCapacity(16);
		data->release();
		data->release();
	}

	if (changed && (newValue >= 6666) && (newValue <= 6669)) {
		OSIterator * iter;
		IOService  * service;

		service = NULL;
		iter = IOService::getMatchingServices(IOService::nameMatching("XHC1"));
		if (iter && (service = (IOService *) iter->getNextObject())) {
			if (newValue == 6666) {
				IOLog("terminating 0x%qx\n", service->getRegistryEntryID());
				service->terminate();
			} else if (newValue == 6667) {
				IOLog("register 0x%qx\n", service->getRegistryEntryID());
				service->registerService();
			}
		}
		OSSafeReleaseNULL(iter);
		if (service) {
			return 0;
		}
	}


	if (changed && newValue) {
		error = IOWorkLoopTest(newValue);
		assert(KERN_SUCCESS == error);
		error = IOServiceTest(newValue);
		assert(KERN_SUCCESS == error);
		error = OSCollectionTest(newValue);
		assert(KERN_SUCCESS == error);
		error = IOMemoryDescriptorTest(newValue);
		assert(KERN_SUCCESS == error);
	}
#endif  /* DEVELOPMENT || DEBUG */

	return error;
}

SYSCTL_PROC(_kern, OID_AUTO, iokittest,
    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
    NULL, 0, sysctl_iokittest, "I", "");
Commit	Line	Data
1c79356b	1	/*
d9a64523	2	* Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
0a7de745	5	*
2d21ac55 A	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.
0a7de745	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
2d21ac55 A	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
0a7de745	17	*
2d21ac55 A	18	* The Original Code and all software distributed under the License are
2d21ac55 A	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	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.
0a7de745	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	*
	30	*/
	31
d9a64523	32	#define TEST_HEADERS 0
1c79356b	33
3e170ce0	34	#if TEST_HEADERS
1c79356b	35
3e170ce0 A	36	#include <libkern/OSByteOrder.h>
	37	#include <libkern/c++/OSArray.h>
	38	#include <libkern/c++/OSBoolean.h>
	39	#include <libkern/c++/OSCollection.h>
	40	#include <libkern/c++/OSCollectionIterator.h>
	41	#include <libkern/c++/OSContainers.h>
	42	#include <libkern/c++/OSCPPDebug.h>
	43	#include <libkern/c++/OSData.h>
	44	#include <libkern/c++/OSDictionary.h>
	45	#include <libkern/c++/OSEndianTypes.h>
	46	#include <libkern/c++/OSIterator.h>
	47	#include <libkern/c++/OSKext.h>
	48	#include <libkern/c++/OSLib.h>
	49	#include <libkern/c++/OSMetaClass.h>
	50	#include <libkern/c++/OSNumber.h>
	51	#include <libkern/c++/OSObject.h>
	52	#include <libkern/c++/OSOrderedSet.h>
	53	#include <libkern/c++/OSSerialize.h>
	54	#include <libkern/c++/OSSet.h>
	55	#include <libkern/c++/OSString.h>
	56	#include <libkern/c++/OSSymbol.h>
	57	#include <libkern/c++/OSUnserialize.h>
	58	#include <libkern/crypto/aes.h>
	59	#include <libkern/crypto/aesxts.h>
	60	#include <libkern/crypto/crypto_internal.h>
	61	#include <libkern/crypto/des.h>
	62	#include <libkern/crypto/md5.h>
	63	#include <libkern/crypto/register_crypto.h>
	64	#include <libkern/crypto/sha1.h>
	65	#include <libkern/crypto/sha2.h>
	66	#include <libkern/kernel_mach_header.h>
	67	#include <libkern/kext_request_keys.h>
	68	#include <libkern/kxld.h>
	69	#include <libkern/kxld_types.h>
	70	#include <libkern/locks.h>
	71	#include <libkern/mkext.h>
	72	#include <libkern/OSAtomic.h>
	73	#include <libkern/OSBase.h>
	74	#include <libkern/OSDebug.h>
	75	#include <libkern/OSKextLib.h>
	76	#include <libkern/OSKextLibPrivate.h>
	77	#include <libkern/OSMalloc.h>
	78	#include <libkern/OSReturn.h>
	79	#include <libkern/OSSerializeBinary.h>
	80	#include <libkern/OSTypes.h>
	81	#include <libkern/prelink.h>
	82	#include <libkern/stack_protector.h>
	83	#include <libkern/sysctl.h>
	84	#include <libkern/tree.h>
	85	#include <libkern/zconf.h>
	86	#include <libkern/zlib.h>
	87
	88	#include <IOKit/AppleKeyStoreInterface.h>
	89	#include <IOKit/assert.h>
	90	#include <IOKit/IOBSD.h>
	91	#include <IOKit/IOBufferMemoryDescriptor.h>
	92	#include <IOKit/IOCatalogue.h>
	93	#include <IOKit/IOCommand.h>
	94	#include <IOKit/IOCommandGate.h>
	95	#include <IOKit/IOCommandPool.h>
	96	#include <IOKit/IOCommandQueue.h>
	97	#include <IOKit/IOConditionLock.h>
	98	#include <IOKit/IOCPU.h>
	99	//#include <IOKit/IODataQueue.h>
100	#include <IOKit/IODataQueueShared.h>
101	#include <IOKit/IODeviceMemory.h>
102	#include <IOKit/IODeviceTreeSupport.h>
103	#include <IOKit/IODMACommand.h>
104	#include <IOKit/IODMAController.h>
105	#include <IOKit/IODMAEventSource.h>
106	#include <IOKit/IOEventSource.h>
107	#include <IOKit/IOFilterInterruptEventSource.h>
108	#include <IOKit/IOHibernatePrivate.h>
109	#include <IOKit/IOInterleavedMemoryDescriptor.h>
110	#include <IOKit/IOInterruptAccounting.h>
111	#include <IOKit/IOInterruptAccountingPrivate.h>
112	#include <IOKit/IOInterruptController.h>
113	#include <IOKit/IOInterruptEventSource.h>
114	#include <IOKit/IOInterrupts.h>
115	#include <IOKit/IOKernelReporters.h>
116	#include <IOKit/IOKernelReportStructs.h>
117	#include <IOKit/IOKitDebug.h>
118	#include <IOKit/IOKitDiagnosticsUserClient.h>
119	#include <IOKit/IOKitKeys.h>
120	#include <IOKit/IOKitKeysPrivate.h>
121	#include <IOKit/IOKitServer.h>
122	#include <IOKit/IOLib.h>
123	#include <IOKit/IOLocks.h>
124	#include <IOKit/IOLocksPrivate.h>
125	#include <IOKit/IOMapper.h>
126	#include <IOKit/IOMemoryCursor.h>
127	#include <IOKit/IOMemoryDescriptor.h>
128	#include <IOKit/IOMessage.h>
129	#include <IOKit/IOMultiMemoryDescriptor.h>
130	#include <IOKit/IONotifier.h>
131	#include <IOKit/IONVRAM.h>
132	#include <IOKit/IOPlatformExpert.h>
133	#include <IOKit/IOPolledInterface.h>
134	#include <IOKit/IORangeAllocator.h>
135	#include <IOKit/IORegistryEntry.h>
136	#include <IOKit/IOReportMacros.h>
137	#include <IOKit/IOReportTypes.h>
138	#include <IOKit/IOReturn.h>
139	#include <IOKit/IOService.h>
140	#include <IOKit/IOServicePM.h>
141	#include <IOKit/IOSharedDataQueue.h>
142	#include <IOKit/IOSharedLock.h>
143	#include <IOKit/IOStatistics.h>
144	#include <IOKit/IOStatisticsPrivate.h>
145	#include <IOKit/IOSubMemoryDescriptor.h>
146	#include <IOKit/IOSyncer.h>
147	#include <IOKit/IOTimerEventSource.h>
148	#include <IOKit/IOTimeStamp.h>
149	#include <IOKit/IOTypes.h>
150	#include <IOKit/IOUserClient.h>
151	#include <IOKit/IOWorkLoop.h>
152	#include <IOKit/nvram/IONVRAMController.h>
153	#include <IOKit/OSMessageNotification.h>
154	#include <IOKit/platform/AppleMacIO.h>
155	#include <IOKit/platform/AppleMacIODevice.h>
156	#include <IOKit/platform/AppleNMI.h>
157	#include <IOKit/platform/ApplePlatformExpert.h>
158	#include <IOKit/power/IOPwrController.h>
159	#include <IOKit/pwr_mgt/IOPM.h>
160	#include <IOKit/pwr_mgt/IOPMinformee.h>
161	#include <IOKit/pwr_mgt/IOPMinformeeList.h>
162	#include <IOKit/pwr_mgt/IOPMLibDefs.h>
163	#include <IOKit/pwr_mgt/IOPMlog.h>
164	#include <IOKit/pwr_mgt/IOPMPowerSource.h>
165	#include <IOKit/pwr_mgt/IOPMPowerSourceList.h>
166	#include <IOKit/pwr_mgt/IOPMpowerState.h>
167	#include <IOKit/pwr_mgt/IOPMPrivate.h>
168	#include <IOKit/pwr_mgt/IOPowerConnection.h>
169	#include <IOKit/pwr_mgt/RootDomain.h>
170	#include <IOKit/rtc/IORTCController.h>
171	#include <IOKit/system.h>
172	#include <IOKit/system_management/IOWatchDogTimer.h>
173
174	#endif /* TEST_HEADERS */
175
176	#include <sys/sysctl.h>
177	#include <libkern/c++/OSData.h>
178	#include "Tests.h"
179
5ba3f43e A	180
	181	#if DEVELOPMENT \|\| DEBUG
	182
d9a64523 A	183	#include <IOKit/IOWorkLoop.h>
	184	#include <IOKit/IOTimerEventSource.h>
	185	#include <IOKit/IOInterruptEventSource.h>
	186	#include <IOKit/IOCommandGate.h>
	187	#include <IOKit/IOPlatformExpert.h>
	188	#include <libkern/Block.h>
	189	#include <libkern/Block_private.h>
	190
5ba3f43e A	191	static uint64_t gIOWorkLoopTestDeadline;
	192
	193	static void
	194	TESAction(OSObject * owner, IOTimerEventSource * tes)
	195	{
0a7de745 A	196	if (mach_absolute_time() < gIOWorkLoopTestDeadline) {
	197	tes->setTimeout(1, kMicrosecondScale);
	198	}
5ba3f43e A	199	}
	200
	201	static int
	202	IOWorkLoopTest(int newValue)
	203	{
0a7de745 A	204	IOReturn err;
	205	uint32_t idx;
	206	IOWorkLoop * wl;
	207	IOTimerEventSource * tes;
	208	IOInterruptEventSource * ies;
	209
	210	wl = IOWorkLoop::workLoop();
	211	assert(wl);
	212	tes = IOTimerEventSource::timerEventSource(kIOTimerEventSourceOptionsPriorityWorkLoop, wl, &TESAction);
	213	assert(tes);
	214	err = wl->addEventSource(tes);
	215	assert(kIOReturnSuccess == err);
	216	clock_interval_to_deadline(100, kMillisecondScale, &gIOWorkLoopTestDeadline);
	217	for (idx = 0; mach_absolute_time() < gIOWorkLoopTestDeadline; idx++) {
	218	tes->setTimeout(idx & 1023, kNanosecondScale);
	219	}
	220	tes->cancelTimeout();
	221	wl->removeEventSource(tes);
	222	tes->release();
	223
	224	int value = 3;
	225
	226	tes = IOTimerEventSource::timerEventSource(kIOTimerEventSourceOptionsDefault, wl, ^(IOTimerEventSource * tes){
	227	kprintf("wl %p, value %d\n", wl, value);
	228	});
	229	err = wl->addEventSource(tes);
	230	assert(kIOReturnSuccess == err);
	231
	232	value = 2;
	233	tes->setTimeout(1, kNanosecondScale);
	234	IOSleep(1);
	235	wl->removeEventSource(tes);
	236	tes->release();
	237
	238	ies = IOInterruptEventSource::interruptEventSource(wl, NULL, 0, ^void (IOInterruptEventSource *sender, int count){
	239	kprintf("ies block %p, %d\n", sender, count);
	240	});
	241
	242	assert(ies);
	243	kprintf("ies %p\n", ies);
	244	err = wl->addEventSource(ies);
	245	assert(kIOReturnSuccess == err);
	246	ies->interruptOccurred(NULL, NULL, 0);
	247	IOSleep(1);
	248	ies->interruptOccurred(NULL, NULL, 0);
	249	IOSleep(1);
	250	wl->removeEventSource(ies);
	251	ies->release();
	252
	253	wl->release();
	254
	255	return 0;
5ba3f43e A	256	}
5ba3f43e A	257
d9a64523 A	258	static int
	259	OSCollectionTest(int newValue)
	260	{
0a7de745 A	261	OSArray * array = OSArray::withCapacity(8);
	262	array->setObject(kOSBooleanTrue);
	263	array->setObject(kOSBooleanFalse);
	264	array->setObject(kOSBooleanFalse);
	265	array->setObject(kOSBooleanTrue);
	266	array->setObject(kOSBooleanFalse);
	267	array->setObject(kOSBooleanTrue);
	268
	269	__block unsigned int index;
	270	index = 0;
	271	array->iterateObjects(^bool (OSObject * obj) {
	272	kprintf("%d:%d ", index, (obj == kOSBooleanTrue) ? 1 : (obj == kOSBooleanFalse) ? 0 : 2);
	273	index++;
	274	return false;
	275	});
	276	kprintf("\n");
	277	array->release();
	278
	279	OSDictionary * dict = IOService::resourceMatching("hello");
	280	assert(dict);
	281	index = 0;
	282	dict->iterateObjects(^bool (const OSSymbol * sym, OSObject * obj) {
	283	OSString * str = OSDynamicCast(OSString, obj);
	284	assert(str);
	285	kprintf("%d:%s=%s\n", index, sym->getCStringNoCopy(), str->getCStringNoCopy());
	286	index++;
	287	return false;
	288	});
	289	dict->release();
	290
	291	OSSerializer * serializer = OSSerializer::withBlock(^bool (OSSerialize * s){
	292	return gIOBSDUnitKey->serialize(s);
	293	});
	294	assert(serializer);
	295	IOService::getPlatform()->setProperty("OSSerializer_withBlock", serializer);
	296	serializer->release();
	297
	298	return 0;
d9a64523 A	299	}
	300
	301	#if 0
	302	#include <IOKit/IOUserClient.h>
	303	class TestUserClient : public IOUserClient
	304	{
0a7de745 A	305	OSDeclareDefaultStructors(TestUserClient);
	306	virtual void stop( IOService *provider) APPLE_KEXT_OVERRIDE;
	307	virtual bool finalize(IOOptionBits options) APPLE_KEXT_OVERRIDE;
	308	virtual IOReturn externalMethod( uint32_t selector,
	309	IOExternalMethodArguments * arguments,
	310	IOExternalMethodDispatch * dispatch,
	311	OSObject * target,
	312	void * reference ) APPLE_KEXT_OVERRIDE;
d9a64523 A	313	};
d9a64523 A	314
0a7de745 A	315	void
0a7de745 A	316	TestUserClient::stop( IOService *provider)
d9a64523	317	{
0a7de745	318	kprintf("TestUserClient::stop\n");
d9a64523	319	}
0a7de745 A	320	bool
0a7de745 A	321	TestUserClient::finalize(IOOptionBits options)
d9a64523	322	{
0a7de745 A	323	kprintf("TestUserClient::finalize\n");
0a7de745 A	324	return true;
d9a64523	325	}
0a7de745 A	326	IOReturn
	327	TestUserClient::externalMethod( uint32_t selector,
	328	IOExternalMethodArguments * arguments,
	329	IOExternalMethodDispatch * dispatch,
	330	OSObject * target,
	331	void * reference )
d9a64523	332	{
0a7de745 A	333	getProvider()->terminate();
	334	IOSleep(500);
	335	return 0;
d9a64523 A	336	}
	337	OSDefineMetaClassAndStructors(TestUserClient, IOUserClient);
	338	#endif
	339
	340	static int
	341	IOServiceTest(int newValue)
	342	{
0a7de745 A	343	OSDictionary * matching;
	344	IONotifier * note;
	345	__block IOService * found;
d9a64523 A	346
d9a64523 A	347	#if 0
0a7de745 A	348	found = new IOService;
	349	found->init();
	350	found->setName("IOTestUserClientProvider");
	351	found->attach(IOService::getPlatform());
	352	found->setProperty("IOUserClientClass", "TestUserClient");
	353	found->registerService();
d9a64523 A	354	#endif
d9a64523 A	355
0a7de745 A	356	matching = IOService::serviceMatching("IOPlatformExpert");
	357	assert(matching);
	358	found = nullptr;
	359	note = IOService::addMatchingNotification(gIOMatchedNotification, matching, 0,
	360	^bool (IOService * newService, IONotifier * notifier) {
	361	kprintf("found %s, %d\n", newService->getName(), newService->getRetainCount());
	362	found = newService;
	363	found->retain();
	364	return true;
d9a64523	365	}
0a7de745 A	366	);
	367	assert(note);
	368	assert(found);
	369	matching->release();
	370	note->remove();
	371
	372	note = found->registerInterest(gIOBusyInterest,
	373	^IOReturn (uint32_t messageType, IOService * provider,
	374	void * messageArgument, size_t argSize) {
	375	kprintf("%p messageType 0x%08x %p\n", provider, messageType, messageArgument);
	376	return kIOReturnSuccess;
	377	});
	378	assert(note);
	379	IOSleep(1 * 1000);
	380	note->remove();
	381	found->release();
	382
	383	return 0;
d9a64523 A	384	}
d9a64523 A	385
5ba3f43e A	386	#endif /* DEVELOPMENT \|\| DEBUG */
5ba3f43e A	387
3e170ce0 A	388	static int
3e170ce0 A	389	sysctl_iokittest(__unused struct sysctl_oid oidp, __unused void arg1, __unused int arg2, struct sysctl_req *req)
1c79356b	390	{
0a7de745 A	391	int error;
0a7de745 A	392	int newValue, changed;
3e170ce0	393
0a7de745 A	394	error = sysctl_io_number(req, 0, sizeof(int), &newValue, &changed);
	395	if (error) {
	396	return error;
	397	}
3e170ce0 A	398
3e170ce0 A	399	#if DEVELOPMENT \|\| DEBUG
0a7de745 A	400	if (changed && (66 == newValue)) {
	401	IOReturn ret;
	402	IOWorkLoop * wl = IOWorkLoop::workLoop();
	403	IOCommandGate * cg = IOCommandGate::commandGate(wl);
	404	ret = wl->addEventSource(cg);
	405
	406	struct x {
	407	uint64_t h;
	408	uint64_t l;
	409	};
	410	struct x y;
	411
	412	y.h = 0x1111111122222222;
	413	y.l = 0x3333333344444444;
	414
	415	kprintf("ret1 %d\n", ret);
	416	ret = cg->runActionBlock(^(){
	417	printf("hello %d 0x%qx\n", wl->inGate(), y.h);
	418	return 99;
	419	});
	420	kprintf("ret %d\n", ret);
	421	}
	422
	423	if (changed && (999 == newValue)) {
	424	OSData * data = OSData::withCapacity(16);
	425	data->release();
	426	data->release();
	427	}
	428
cb323159 A	429	if (changed && (newValue >= 6666) && (newValue <= 6669)) {
	430	OSIterator * iter;
	431	IOService * service;
	432
	433	service = NULL;
	434	iter = IOService::getMatchingServices(IOService::nameMatching("XHC1"));
	435	if (iter && (service = (IOService *) iter->getNextObject())) {
	436	if (newValue == 6666) {
	437	IOLog("terminating 0x%qx\n", service->getRegistryEntryID());
	438	service->terminate();
	439	} else if (newValue == 6667) {
	440	IOLog("register 0x%qx\n", service->getRegistryEntryID());
	441	service->registerService();
	442	}
	443	}
	444	OSSafeReleaseNULL(iter);
	445	if (service) {
	446	return 0;
	447	}
	448	}
	449
0a7de745 A	450
	451	if (changed && newValue) {
	452	error = IOWorkLoopTest(newValue);
	453	assert(KERN_SUCCESS == error);
	454	error = IOServiceTest(newValue);
	455	assert(KERN_SUCCESS == error);
	456	error = OSCollectionTest(newValue);
	457	assert(KERN_SUCCESS == error);
	458	error = IOMemoryDescriptorTest(newValue);
	459	assert(KERN_SUCCESS == error);
	460	}
3e170ce0	461	#endif /* DEVELOPMENT \|\| DEBUG */
1c79356b	462
0a7de745	463	return error;
1c79356b A	464	}
1c79356b A	465
3e170ce0	466	SYSCTL_PROC(_kern, OID_AUTO, iokittest,
0a7de745	467	CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_NOAUTO \| CTLFLAG_KERN \| CTLFLAG_LOCKED,
cb323159	468	NULL, 0, sysctl_iokittest, "I", "");