[apple/xnu.git] / iokit / IOKit / IOUserServer.h

/*
 * Copyright (c) 2019 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@
 */


#ifndef _IOUSERSERVER_H
#define _IOUSERSERVER_H

#include <IOKit/IORPC.h>

#define kIOUserClassKey        "IOUserClass"
#define kIOUserServerClassKey  "IOUserServer"
#define kIOUserServerNameKey   "IOUserServerName"
#define kIOUserServerTagKey    "IOUserServerTag"
// the expected cdhash value of the userspace driver executable
#define kIOUserServerCDHashKey "IOUserServerCDHash"

#if DRIVERKIT_PRIVATE

enum{
	kIOKitUserServerClientType  = 0x99000003,
};

enum{
	kIOUserServerMethodRegisterClass = 0x0001000,
	kIOUserServerMethodStart         = 0x0001001,
	kIOUserServerMethodRegister      = 0x0001002,
};


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

class OSObject;

#define OSObject_Instantiate_ID       0x0000000100000001ULL

enum {
	kOSObjectRPCRemote = 0x00000001,
	kOSObjectRPCKernel = 0x00000002,
};

struct OSObject_Instantiate_Msg_Content {
	IORPCMessage __hdr;
	OSObjectRef  __object;
};

struct OSObject_Instantiate_Rpl_Content {
	IORPCMessage  __hdr;
	kern_return_t __result;
	uint32_t      __pad;
	uint64_t      flags;
	char          classname[128];
	uint64_t      methods[0];
};

#pragma pack(4)
struct OSObject_Instantiate_Msg {
	IORPCMessageMach mach;
	mach_msg_port_descriptor_t __object__descriptor;
	OSObject_Instantiate_Msg_Content content;
};
struct OSObject_Instantiate_Rpl {
	IORPCMessageMach mach;
	OSObject_Instantiate_Rpl_Content content;
};
#pragma pack()

typedef uint64_t IOTrapMessageBuffer[256];

#endif /* DRIVERKIT_PRIVATE */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifdef XNU_KERNEL_PRIVATE

#include <IOKit/IOService.h>
#include <IOKit/IOUserClient.h>
#include <DriverKit/IOUserServer.h>
#include <libkern/c++/OSPtr.h>
#include <libkern/c++/OSKext.h>

class IOUserServer;
class OSUserMetaClass;
class IODispatchQueue;
class IODispatchSource;
class IOInterruptDispatchSource;
class IOTimerDispatchSource;
class IOUserServerCheckInToken;
struct IOPStrings;

struct OSObjectUserVars {
	IOUserServer     * userServer;
	IODispatchQueue ** queueArray;
	OSUserMetaClass  * userMeta;
	OSArray          * openProviders;
	IOService        * controllingDriver;
	unsigned long      willPowerState;
	bool               willTerminate;
	bool               didTerminate;
	bool               serverDied;
	bool               started;
	bool               stopped;
	bool               userServerPM;
	bool               willPower;
	uint32_t           powerOverride;
};

extern IOLock *        gIOUserServerLock;

typedef struct ipc_kmsg * ipc_kmsg_t;

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

namespace IOServicePH
{
void serverAdd(IOUserServer * server);
void serverRemove(IOUserServer * server);
void serverAck(IOUserServer * server);
bool serverSlept(void);
void systemHalt(void);
};

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

class IOUserServer : public IOUserClient
{
	OSDeclareDefaultStructorsWithDispatch(IOUserServer);

	IOLock       *        fLock;
	IOSimpleLock *        fInterruptLock;
	task_t                fOwningTask;
	OSDictionary  *       fEntitlements;
	OSDictionary  *       fClasses;
	IODispatchQueue     * fRootQueue;
	OSArray             * fServices;

	uint64_t              fPowerStates;
	uint8_t               fRootNotifier;
	uint8_t               fSystemPowerAck;
	uint8_t               fSystemOff;
	IOUserServerCheckInToken * fCheckInToken;

public:

	static  IOUserClient * withTask(task_t owningTask);
	virtual IOReturn       clientClose(void) APPLE_KEXT_OVERRIDE;
	virtual bool           finalize(IOOptionBits options) APPLE_KEXT_OVERRIDE;
	virtual void           stop(IOService * provider) APPLE_KEXT_OVERRIDE;
	virtual void           free() APPLE_KEXT_OVERRIDE;

	virtual IOReturn       setProperties(OSObject * properties) APPLE_KEXT_OVERRIDE;
	virtual IOReturn       externalMethod(uint32_t selector, IOExternalMethodArguments * args,
	    IOExternalMethodDispatch * dispatch,
	    OSObject * target, void * reference) APPLE_KEXT_OVERRIDE;

	virtual IOExternalTrap * getTargetAndTrapForIndex(IOService ** targetP, UInt32 index) APPLE_KEXT_OVERRIDE;

	IOReturn               serviceAttach(IOService * service, IOService * provider);
	IOReturn               serviceStop(IOService * service, IOService * provider);
	void                   serviceFree(IOService * service);
	IOReturn               serviceStarted(IOService * service, IOService * provider, bool result);
	static void            serviceWillTerminate(IOService * client, IOService * provider, IOOptionBits options);
	static void            serviceDidTerminate(IOService * client, IOService * provider, IOOptionBits options, bool * defer);
	static void            serviceDidStop(IOService * client, IOService * provider);
	IOReturn               serviceOpen(IOService * provider, IOService * client);
	IOReturn               serviceClose(IOService * provider, IOService * client);
	IOReturn               serviceSetPowerState(IOService * controllingDriver, IOService * service, IOPMPowerFlags flags, IOPMPowerStateIndex powerState);
	IOReturn               serviceNewUserClient(IOService * service, task_t owningTask, void * securityID,
	    uint32_t type, OSDictionary * properties, IOUserClient ** handler);
	IOReturn               serviceNewUserClient(IOService * service, task_t owningTask, void * securityID,
	    uint32_t type, OSDictionary * properties, OSSharedPtr<IOUserClient>& handler);
	IOReturn               exit(const char * reason);

	bool                   serviceMatchesCheckInToken(IOUserServerCheckInToken *token);
	bool                   checkEntitlements(IOService * provider, IOService * dext);
	bool                   checkEntitlements(OSDictionary * entitlements, OSObject * prop,
	    IOService * provider, IOService * dext);

	void                   setTaskLoadTag(OSKext *kext);
	void                   setDriverKitUUID(OSKext *kext);
	void                   setCheckInToken(IOUserServerCheckInToken *token);
	void                   systemPower(bool powerOff);
	void                               systemHalt(void);
	IOReturn                                setPowerState(unsigned long state, IOService * service) APPLE_KEXT_OVERRIDE;
	IOReturn                                powerStateWillChangeTo(IOPMPowerFlags flags, unsigned long state, IOService * service) APPLE_KEXT_OVERRIDE;
	IOReturn                                powerStateDidChangeTo(IOPMPowerFlags flags, unsigned long state, IOService * service) APPLE_KEXT_OVERRIDE;

	IOPStrings *           copyInStringArray(const char * string, uint32_t userSize);
	uint32_t               stringArrayIndex(IOPStrings * array, const char * look);
	IOReturn               registerClass(OSClassDescription * desc, uint32_t size, OSUserMetaClass ** cls);
	IOReturn               registerClass(OSClassDescription * desc, uint32_t size, OSSharedPtr<OSUserMetaClass>& cls);
	IOReturn               setRootQueue(IODispatchQueue * queue);

	OSObjectUserVars     * varsForObject(OSObject * obj);
	LIBKERN_RETURNS_NOT_RETAINED IODispatchQueue      * queueForObject(OSObject * obj, uint64_t msgid);

	static ipc_port_t      copySendRightForObject(OSObject * object, natural_t /* ipc_kobject_type_t */ type);
	static OSObject      * copyObjectForSendRight(ipc_port_t port, natural_t /* ipc_kobject_type_t */ type);

	IOReturn               copyOutObjects(IORPCMessageMach * mach, IORPCMessage * message,
	    size_t size, bool consume);
	IOReturn               copyInObjects(IORPCMessageMach * mach, IORPCMessage * message,
	    size_t size, bool copyObjects, bool consumePorts);

	IOReturn               consumeObjects(IORPCMessage * message, size_t messageSize);

	IOReturn               objectInstantiate(OSObject * obj, IORPC rpc, IORPCMessage * message);
	IOReturn               kernelDispatch(OSObject * obj, IORPC rpc);
	static OSObject      * target(OSAction * action, IORPCMessage * message);

	IOReturn               rpc(IORPC rpc);
	IOReturn               server(ipc_kmsg_t requestkmsg, ipc_kmsg_t * preply);
	kern_return_t          waitInterruptTrap(void * p1, void * p2, void * p3, void * p4, void * p5, void * p6);
};

typedef void (*IOUserServerCheckInNotificationHandler)(class IOUserServerCheckInToken*, void*);

class IOUserServerCheckInToken : public OSObject
{
	OSDeclareDefaultStructors(IOUserServerCheckInToken);
public:
	static IOUserServerCheckInToken * create();
	void setNoSendersNotification(IOUserServerCheckInNotificationHandler handler, void *handlerArgs);
	void clearNotification();
	static void notifyNoSenders(IOUserServerCheckInToken * token);
private:
	IOUserServerCheckInNotificationHandler handler;
	void *handlerArgs;
};

extern "C" kern_return_t
IOUserServerUEXTTrap(OSObject * object, void * p1, void * p2, void * p3, void * p4, void * p5, void * p6);

#endif /* XNU_KERNEL_PRIVATE */
#endif /* _IOUSERSERVER_H */
Commit	Line	Data
cb323159 A	1	/*
	2	* Copyright (c) 2019 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
	30	#ifndef _IOUSERSERVER_H
	31	#define _IOUSERSERVER_H
	32
	33	#include <IOKit/IORPC.h>
	34
	35	#define kIOUserClassKey "IOUserClass"
	36	#define kIOUserServerClassKey "IOUserServer"
	37	#define kIOUserServerNameKey "IOUserServerName"
	38	#define kIOUserServerTagKey "IOUserServerTag"
	39	// the expected cdhash value of the userspace driver executable
	40	#define kIOUserServerCDHashKey "IOUserServerCDHash"
	41
	42	#if DRIVERKIT_PRIVATE
	43
	44	enum{
	45	kIOKitUserServerClientType = 0x99000003,
	46	};
	47
	48	enum{
	49	kIOUserServerMethodRegisterClass = 0x0001000,
	50	kIOUserServerMethodStart = 0x0001001,
	51	kIOUserServerMethodRegister = 0x0001002,
	52	};
	53
	54
	55	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	56
	57	class OSObject;
	58
	59	#define OSObject_Instantiate_ID 0x0000000100000001ULL
	60
	61	enum {
	62	kOSObjectRPCRemote = 0x00000001,
	63	kOSObjectRPCKernel = 0x00000002,
	64	};
65
66	struct OSObject_Instantiate_Msg_Content {
67	IORPCMessage __hdr;
68	OSObjectRef __object;
69	};
70
71	struct OSObject_Instantiate_Rpl_Content {
72	IORPCMessage __hdr;
73	kern_return_t __result;
74	uint32_t __pad;
75	uint64_t flags;
f427ee49	76	char classname[128];
cb323159 A	77	uint64_t methods[0];
	78	};
	79
	80	#pragma pack(4)
	81	struct OSObject_Instantiate_Msg {
	82	IORPCMessageMach mach;
	83	mach_msg_port_descriptor_t __object__descriptor;
	84	OSObject_Instantiate_Msg_Content content;
	85	};
	86	struct OSObject_Instantiate_Rpl {
	87	IORPCMessageMach mach;
	88	OSObject_Instantiate_Rpl_Content content;
	89	};
	90	#pragma pack()
	91
	92	typedef uint64_t IOTrapMessageBuffer[256];
	93
	94	#endif /* DRIVERKIT_PRIVATE */
	95
	96	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	97	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	98
	99	#ifdef XNU_KERNEL_PRIVATE
	100
	101	#include <IOKit/IOService.h>
	102	#include <IOKit/IOUserClient.h>
	103	#include <DriverKit/IOUserServer.h>
f427ee49	104	#include <libkern/c++/OSPtr.h>
cb323159 A	105	#include <libkern/c++/OSKext.h>
	106
	107	class IOUserServer;
	108	class OSUserMetaClass;
	109	class IODispatchQueue;
	110	class IODispatchSource;
	111	class IOInterruptDispatchSource;
	112	class IOTimerDispatchSource;
f427ee49	113	class IOUserServerCheckInToken;
cb323159 A	114	struct IOPStrings;
	115
	116	struct OSObjectUserVars {
	117	IOUserServer * userServer;
	118	IODispatchQueue ** queueArray;
	119	OSUserMetaClass * userMeta;
	120	OSArray * openProviders;
f427ee49 A	121	IOService * controllingDriver;
f427ee49 A	122	unsigned long willPowerState;
cb323159 A	123	bool willTerminate;
	124	bool didTerminate;
	125	bool serverDied;
	126	bool started;
	127	bool stopped;
	128	bool userServerPM;
	129	bool willPower;
	130	uint32_t powerOverride;
	131	};
	132
	133	extern IOLock * gIOUserServerLock;
	134
	135	typedef struct ipc_kmsg * ipc_kmsg_t;
	136
	137	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	138
	139	namespace IOServicePH
	140	{
	141	void serverAdd(IOUserServer * server);
	142	void serverRemove(IOUserServer * server);
	143	void serverAck(IOUserServer * server);
f427ee49	144	bool serverSlept(void);
c3c9b80d	145	void systemHalt(void);
cb323159 A	146	};
	147
	148	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	149
	150	class IOUserServer : public IOUserClient
	151	{
	152	OSDeclareDefaultStructorsWithDispatch(IOUserServer);
	153
	154	IOLock * fLock;
	155	IOSimpleLock * fInterruptLock;
	156	task_t fOwningTask;
	157	OSDictionary * fEntitlements;
	158	OSDictionary * fClasses;
	159	IODispatchQueue * fRootQueue;
	160	OSArray * fServices;
	161
	162	uint64_t fPowerStates;
	163	uint8_t fRootNotifier;
	164	uint8_t fSystemPowerAck;
	165	uint8_t fSystemOff;
f427ee49	166	IOUserServerCheckInToken * fCheckInToken;
cb323159 A	167
	168	public:
	169
	170	static IOUserClient * withTask(task_t owningTask);
	171	virtual IOReturn clientClose(void) APPLE_KEXT_OVERRIDE;
	172	virtual bool finalize(IOOptionBits options) APPLE_KEXT_OVERRIDE;
	173	virtual void stop(IOService * provider) APPLE_KEXT_OVERRIDE;
	174	virtual void free() APPLE_KEXT_OVERRIDE;
	175
	176	virtual IOReturn setProperties(OSObject * properties) APPLE_KEXT_OVERRIDE;
	177	virtual IOReturn externalMethod(uint32_t selector, IOExternalMethodArguments * args,
	178	IOExternalMethodDispatch * dispatch,
	179	OSObject * target, void * reference) APPLE_KEXT_OVERRIDE;
	180
	181	virtual IOExternalTrap * getTargetAndTrapForIndex(IOService ** targetP, UInt32 index) APPLE_KEXT_OVERRIDE;
	182
	183	IOReturn serviceAttach(IOService * service, IOService * provider);
	184	IOReturn serviceStop(IOService * service, IOService * provider);
	185	void serviceFree(IOService * service);
	186	IOReturn serviceStarted(IOService * service, IOService * provider, bool result);
	187	static void serviceWillTerminate(IOService * client, IOService * provider, IOOptionBits options);
	188	static void serviceDidTerminate(IOService * client, IOService * provider, IOOptionBits options, bool * defer);
	189	static void serviceDidStop(IOService * client, IOService * provider);
	190	IOReturn serviceOpen(IOService * provider, IOService * client);
	191	IOReturn serviceClose(IOService * provider, IOService * client);
f427ee49	192	IOReturn serviceSetPowerState(IOService * controllingDriver, IOService * service, IOPMPowerFlags flags, IOPMPowerStateIndex powerState);
cb323159 A	193	IOReturn serviceNewUserClient(IOService * service, task_t owningTask, void * securityID,
cb323159 A	194	uint32_t type, OSDictionary * properties, IOUserClient ** handler);
f427ee49 A	195	IOReturn serviceNewUserClient(IOService * service, task_t owningTask, void * securityID,
f427ee49 A	196	uint32_t type, OSDictionary * properties, OSSharedPtr<IOUserClient>& handler);
cb323159 A	197	IOReturn exit(const char * reason);
cb323159 A	198
f427ee49	199	bool serviceMatchesCheckInToken(IOUserServerCheckInToken *token);
cb323159 A	200	bool checkEntitlements(IOService * provider, IOService * dext);
	201	bool checkEntitlements(OSDictionary * entitlements, OSObject * prop,
	202	IOService * provider, IOService * dext);
	203
	204	void setTaskLoadTag(OSKext *kext);
	205	void setDriverKitUUID(OSKext *kext);
f427ee49	206	void setCheckInToken(IOUserServerCheckInToken *token);
cb323159	207	void systemPower(bool powerOff);
c3c9b80d	208	void systemHalt(void);
cb323159 A	209	IOReturn setPowerState(unsigned long state, IOService * service) APPLE_KEXT_OVERRIDE;
	210	IOReturn powerStateWillChangeTo(IOPMPowerFlags flags, unsigned long state, IOService * service) APPLE_KEXT_OVERRIDE;
	211	IOReturn powerStateDidChangeTo(IOPMPowerFlags flags, unsigned long state, IOService * service) APPLE_KEXT_OVERRIDE;
	212
	213	IOPStrings * copyInStringArray(const char * string, uint32_t userSize);
	214	uint32_t stringArrayIndex(IOPStrings * array, const char * look);
	215	IOReturn registerClass(OSClassDescription * desc, uint32_t size, OSUserMetaClass ** cls);
f427ee49	216	IOReturn registerClass(OSClassDescription * desc, uint32_t size, OSSharedPtr<OSUserMetaClass>& cls);
cb323159 A	217	IOReturn setRootQueue(IODispatchQueue * queue);
	218
	219	OSObjectUserVars * varsForObject(OSObject * obj);
	220	LIBKERN_RETURNS_NOT_RETAINED IODispatchQueue * queueForObject(OSObject * obj, uint64_t msgid);
	221
	222	static ipc_port_t copySendRightForObject(OSObject * object, natural_t /* ipc_kobject_type_t */ type);
	223	static OSObject * copyObjectForSendRight(ipc_port_t port, natural_t /* ipc_kobject_type_t */ type);
	224
	225	IOReturn copyOutObjects(IORPCMessageMach * mach, IORPCMessage * message,
	226	size_t size, bool consume);
	227	IOReturn copyInObjects(IORPCMessageMach * mach, IORPCMessage * message,
	228	size_t size, bool copyObjects, bool consumePorts);
	229
	230	IOReturn consumeObjects(IORPCMessage * message, size_t messageSize);
	231
	232	IOReturn objectInstantiate(OSObject * obj, IORPC rpc, IORPCMessage * message);
	233	IOReturn kernelDispatch(OSObject * obj, IORPC rpc);
	234	static OSObject * target(OSAction * action, IORPCMessage * message);
	235
	236	IOReturn rpc(IORPC rpc);
	237	IOReturn server(ipc_kmsg_t requestkmsg, ipc_kmsg_t * preply);
	238	kern_return_t waitInterruptTrap(void * p1, void * p2, void * p3, void * p4, void * p5, void * p6);
	239	};
	240
f427ee49 A	241	typedef void (IOUserServerCheckInNotificationHandler)(class IOUserServerCheckInToken, void*);
	242
	243	class IOUserServerCheckInToken : public OSObject
	244	{
	245	OSDeclareDefaultStructors(IOUserServerCheckInToken);
	246	public:
	247	static IOUserServerCheckInToken * create();
	248	void setNoSendersNotification(IOUserServerCheckInNotificationHandler handler, void *handlerArgs);
	249	void clearNotification();
	250	static void notifyNoSenders(IOUserServerCheckInToken * token);
	251	private:
	252	IOUserServerCheckInNotificationHandler handler;
	253	void *handlerArgs;
	254	};
	255
cb323159 A	256	extern "C" kern_return_t
	257	IOUserServerUEXTTrap(OSObject * object, void * p1, void * p2, void * p3, void * p4, void * p5, void * p6);
	258
	259	#endif /* XNU_KERNEL_PRIVATE */
	260	#endif /* _IOUSERSERVER_H */