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

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

#ifndef _IOPOLLEDINTERFACE_H_
#define _IOPOLLEDINTERFACE_H_

enum
{
    kIOPolledPreflightState           = 1,
    kIOPolledBeforeSleepState         = 2,
    kIOPolledAfterSleepState          = 3,
    kIOPolledPostflightState          = 4,

    kIOPolledPreflightCoreDumpState   = 5,
    kIOPolledPostflightCoreDumpState  = 6,

    kIOPolledBeforeSleepStateAborted  = 7,
};

#if defined(__cplusplus)

#include <libkern/c++/OSObject.h>
#include <IOKit/IOMemoryDescriptor.h>

#define kIOPolledInterfaceSupportKey "IOPolledInterface"
#define kIOPolledInterfaceActiveKey  "IOPolledInterfaceActive"
#define kIOPolledInterfaceStackKey   "IOPolledInterfaceStack"

enum
{
    kIOPolledWrite = 1,
    kIOPolledRead  = 2,
    kIOPolledFlush = 3
};

typedef void (*IOPolledCompletionAction)( void *   target,
                                          void *   parameter,
                                          IOReturn status,
                                          uint64_t actualByteCount);
struct IOPolledCompletion
{
    void *                    target;
    IOPolledCompletionAction  action;
    void *                    parameter;
};

class IOPolledInterface : public OSObject
{
    OSDeclareAbstractStructors(IOPolledInterface);

protected:
    struct ExpansionData { };
    ExpansionData * reserved;

public:
    virtual IOReturn probe(IOService * target) = 0;

    virtual IOReturn open( IOOptionBits state, IOMemoryDescriptor * buffer) = 0;
    virtual IOReturn close(IOOptionBits state) = 0;

    virtual IOReturn startIO(uint32_t 	        operation,
                             uint32_t           bufferOffset,
                             uint64_t	        deviceOffset,
                             uint64_t	        length,
                             IOPolledCompletion completion) = 0;

    virtual IOReturn checkForWork(void) = 0;

    virtual IOReturn setEncryptionKey(const uint8_t * key, size_t keySize);

    OSMetaClassDeclareReservedUsed(IOPolledInterface, 0);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 1);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 2);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 3);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 4);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 5);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 6);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 7);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 8);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 9);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 10);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 11);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 12);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 13);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 14);
    OSMetaClassDeclareReservedUnused(IOPolledInterface, 15);
};

#endif /* defined(__cplusplus) */

#ifdef XNU_KERNEL_PRIVATE

#include <libkern/crypto/aes.h>
#include <IOKit/IOTypes.h>
#include <IOKit/IOHibernatePrivate.h>

enum
{
    kIOPolledFileSSD = 0x00000001
};

#if !defined(__cplusplus)
typedef struct IORegistryEntry IORegistryEntry;
typedef struct OSData OSData;
typedef struct OSArray OSArray;
typedef struct IOMemoryDescriptor IOMemoryDescriptor;
typedef struct IOPolledFilePollers IOPolledFilePollers;
#else
class IOPolledFilePollers;
#endif

struct IOPolledFileIOVars
{
    IOPolledFilePollers              *  pollers;
    struct kern_direct_file_io_ref_t *	fileRef;
    OSData *		 		fileExtents;
    uint64_t				block0;
    IOByteCount				blockSize;
    uint64_t			        maxiobytes;
    IOByteCount 			bufferLimit;
    uint8_t *  				buffer;
    IOByteCount 			bufferSize;
    IOByteCount 			bufferOffset;
    IOByteCount 			bufferHalf;
    IOByteCount				extentRemaining;
    IOByteCount				lastRead;
    IOByteCount				readEnd;
    uint32_t                            flags;
    uint64_t				fileSize;
    uint64_t				position;
    uint64_t				extentPosition;
    uint64_t				encryptStart;
    uint64_t				encryptEnd;
    uint64_t                            cryptBytes;
    AbsoluteTime                        cryptTime;
    IOPolledFileExtent * 		extentMap;
    IOPolledFileExtent * 		currentExtent;
    bool				allocated;
};

typedef struct IOPolledFileIOVars IOPolledFileIOVars;

struct IOPolledFileCryptVars
{
    uint8_t aes_iv[AES_BLOCK_SIZE];
    aes_ctx ctx;
};
typedef struct IOPolledFileCryptVars IOPolledFileCryptVars;

#if defined(__cplusplus)

IOReturn IOPolledFileOpen(const char * filename, 
			  uint64_t setFileSize, uint64_t fsFreeSize,
			  void * write_file_addr, size_t write_file_len,
			  IOPolledFileIOVars ** fileVars,
			  OSData ** imagePath,
			  uint8_t * volumeCryptKey, size_t * keySize);

IOReturn IOPolledFileClose(IOPolledFileIOVars ** pVars,
			   off_t write_offset, void * addr, size_t write_length,
			   off_t discard_offset, off_t discard_end);

IOReturn IOPolledFilePollersSetup(IOPolledFileIOVars * vars, uint32_t openState);

IOMemoryDescriptor * IOPolledFileGetIOBuffer(IOPolledFileIOVars * vars);

#endif /* defined(__cplusplus) */

#if defined(__cplusplus)
#define __C	"C"
#else
#define __C
#endif

extern __C IOReturn IOPolledFileSeek(IOPolledFileIOVars * vars, uint64_t position);

extern __C IOReturn IOPolledFileWrite(IOPolledFileIOVars * vars,
			   const uint8_t * bytes, IOByteCount size,
			   IOPolledFileCryptVars * cryptvars);
extern __C IOReturn IOPolledFileRead(IOPolledFileIOVars * vars,
			  uint8_t * bytes, IOByteCount size,
			  IOPolledFileCryptVars * cryptvars);

extern __C IOReturn IOPolledFileFlush(IOPolledFileIOVars * vars);

extern __C IOReturn IOPolledFilePollersOpen(IOPolledFileIOVars * vars, uint32_t state, bool abortable);

extern __C IOReturn IOPolledFilePollersClose(IOPolledFileIOVars * vars, uint32_t state);

extern __C IOReturn IOPolledFilePollersSetEncryptionKey(IOPolledFileIOVars * vars,
				    const uint8_t * key, size_t keySize);

extern __C IOPolledFileIOVars * gCoreFileVars;

#ifdef _SYS_CONF_H_

__BEGIN_DECLS

typedef void (*kern_get_file_extents_callback_t)(void * ref, uint64_t start, uint64_t size);

struct kern_direct_file_io_ref_t *
kern_open_file_for_direct_io(const char * name, boolean_t create_file,
			     kern_get_file_extents_callback_t callback, 
			     void * callback_ref,
                             off_t set_file_size,
                             off_t fs_free_size,
                             off_t write_file_offset,
                             void * write_file_addr,
                             size_t write_file_len,
			     dev_t * partition_device_result,
			     dev_t * image_device_result,
                             uint64_t * partitionbase_result,
                             uint64_t * maxiocount_result,
                             uint32_t * oflags);
void
kern_close_file_for_direct_io(struct kern_direct_file_io_ref_t * ref,
			      off_t write_offset, void * addr, size_t write_length,
			      off_t discard_offset, off_t discard_end);
int
kern_write_file(struct kern_direct_file_io_ref_t * ref, off_t offset, void * addr, size_t len, int ioflag);
int
kern_read_file(struct kern_direct_file_io_ref_t * ref, off_t offset, void * addr, size_t len, int ioflag);

struct mount *
kern_file_mount(struct kern_direct_file_io_ref_t * ref);

enum 
{
    kIOPolledFileMountChangeMount = 0x00000101,
    kIOPolledFileMountChangeUnmount = 0x00000102,
    kIOPolledFileMountChangeWillResize = 0x00000201,
    kIOPolledFileMountChangeDidResize = 0x00000202,
};
extern void IOPolledFileMountChange(struct mount * mp, uint32_t op);

__END_DECLS

#endif /* _SYS_CONF_H_ */

#endif /* XNU_KERNEL_PRIVATE */

#endif /* _IOPOLLEDINTERFACE_H_ */
Commit	Line	Data
91447636 A	1	/*
	2	* Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
91447636	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.
8f6c56a5	14	*
2d21ac55 A	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
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.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
91447636 A	27	*/
91447636 A	28
2d21ac55 A	29	#ifndef _IOPOLLEDINTERFACE_H_
	30	#define _IOPOLLEDINTERFACE_H_
	31
91447636 A	32	enum
91447636 A	33	{
490019cf A	34	kIOPolledPreflightState = 1,
	35	kIOPolledBeforeSleepState = 2,
	36	kIOPolledAfterSleepState = 3,
	37	kIOPolledPostflightState = 4,
3e170ce0 A	38
3e170ce0 A	39	kIOPolledPreflightCoreDumpState = 5,
490019cf	40	kIOPolledPostflightCoreDumpState = 6,
ecc0ceb4 A	41
ecc0ceb4 A	42	kIOPolledBeforeSleepStateAborted = 7,
91447636 A	43	};
91447636 A	44
3e170ce0 A	45	#if defined(__cplusplus)
	46
	47	#include <libkern/c++/OSObject.h>
	48	#include <IOKit/IOMemoryDescriptor.h>
	49
	50	#define kIOPolledInterfaceSupportKey "IOPolledInterface"
	51	#define kIOPolledInterfaceActiveKey "IOPolledInterfaceActive"
	52	#define kIOPolledInterfaceStackKey "IOPolledInterfaceStack"
	53
91447636 A	54	enum
	55	{
	56	kIOPolledWrite = 1,
5ba3f43e A	57	kIOPolledRead = 2,
5ba3f43e A	58	kIOPolledFlush = 3
91447636 A	59	};
	60
	61	typedef void (IOPolledCompletionAction)( void target,
	62	void * parameter,
	63	IOReturn status,
	64	uint64_t actualByteCount);
	65	struct IOPolledCompletion
	66	{
	67	void * target;
	68	IOPolledCompletionAction action;
	69	void * parameter;
	70	};
	71
	72	class IOPolledInterface : public OSObject
	73	{
	74	OSDeclareAbstractStructors(IOPolledInterface);
	75
	76	protected:
	77	struct ExpansionData { };
	78	ExpansionData * reserved;
	79
	80	public:
	81	virtual IOReturn probe(IOService * target) = 0;
	82
	83	virtual IOReturn open( IOOptionBits state, IOMemoryDescriptor * buffer) = 0;
	84	virtual IOReturn close(IOOptionBits state) = 0;
	85
	86	virtual IOReturn startIO(uint32_t operation,
	87	uint32_t bufferOffset,
	88	uint64_t deviceOffset,
	89	uint64_t length,
	90	IOPolledCompletion completion) = 0;
	91
	92	virtual IOReturn checkForWork(void) = 0;
	93
a39ff7e2 A	94	virtual IOReturn setEncryptionKey(const uint8_t * key, size_t keySize);
	95
	96	OSMetaClassDeclareReservedUsed(IOPolledInterface, 0);
91447636 A	97	OSMetaClassDeclareReservedUnused(IOPolledInterface, 1);
	98	OSMetaClassDeclareReservedUnused(IOPolledInterface, 2);
	99	OSMetaClassDeclareReservedUnused(IOPolledInterface, 3);
	100	OSMetaClassDeclareReservedUnused(IOPolledInterface, 4);
	101	OSMetaClassDeclareReservedUnused(IOPolledInterface, 5);
	102	OSMetaClassDeclareReservedUnused(IOPolledInterface, 6);
	103	OSMetaClassDeclareReservedUnused(IOPolledInterface, 7);
	104	OSMetaClassDeclareReservedUnused(IOPolledInterface, 8);
	105	OSMetaClassDeclareReservedUnused(IOPolledInterface, 9);
	106	OSMetaClassDeclareReservedUnused(IOPolledInterface, 10);
	107	OSMetaClassDeclareReservedUnused(IOPolledInterface, 11);
	108	OSMetaClassDeclareReservedUnused(IOPolledInterface, 12);
	109	OSMetaClassDeclareReservedUnused(IOPolledInterface, 13);
	110	OSMetaClassDeclareReservedUnused(IOPolledInterface, 14);
	111	OSMetaClassDeclareReservedUnused(IOPolledInterface, 15);
	112	};
	113
3e170ce0 A	114	#endif /* defined(__cplusplus) */
	115
	116	#ifdef XNU_KERNEL_PRIVATE
	117
	118	#include <libkern/crypto/aes.h>
	119	#include <IOKit/IOTypes.h>
	120	#include <IOKit/IOHibernatePrivate.h>
	121
	122	enum
	123	{
	124	kIOPolledFileSSD = 0x00000001
	125	};
	126
	127	#if !defined(__cplusplus)
	128	typedef struct IORegistryEntry IORegistryEntry;
	129	typedef struct OSData OSData;
	130	typedef struct OSArray OSArray;
	131	typedef struct IOMemoryDescriptor IOMemoryDescriptor;
	132	typedef struct IOPolledFilePollers IOPolledFilePollers;
	133	#else
	134	class IOPolledFilePollers;
	135	#endif
	136
	137	struct IOPolledFileIOVars
	138	{
	139	IOPolledFilePollers * pollers;
	140	struct kern_direct_file_io_ref_t * fileRef;
	141	OSData * fileExtents;
	142	uint64_t block0;
	143	IOByteCount blockSize;
	144	uint64_t maxiobytes;
	145	IOByteCount bufferLimit;
	146	uint8_t * buffer;
	147	IOByteCount bufferSize;
	148	IOByteCount bufferOffset;
	149	IOByteCount bufferHalf;
	150	IOByteCount extentRemaining;
	151	IOByteCount lastRead;
	152	IOByteCount readEnd;
	153	uint32_t flags;
	154	uint64_t fileSize;
	155	uint64_t position;
	156	uint64_t extentPosition;
	157	uint64_t encryptStart;
	158	uint64_t encryptEnd;
	159	uint64_t cryptBytes;
	160	AbsoluteTime cryptTime;
	161	IOPolledFileExtent * extentMap;
	162	IOPolledFileExtent * currentExtent;
	163	bool allocated;
	164	};
	165
	166	typedef struct IOPolledFileIOVars IOPolledFileIOVars;
	167
	168	struct IOPolledFileCryptVars
	169	{
	170	uint8_t aes_iv[AES_BLOCK_SIZE];
	171	aes_ctx ctx;
	172	};
	173	typedef struct IOPolledFileCryptVars IOPolledFileCryptVars;
	174
	175	#if defined(__cplusplus)
	176
	177	IOReturn IOPolledFileOpen(const char * filename,
178	uint64_t setFileSize, uint64_t fsFreeSize,
179	void * write_file_addr, size_t write_file_len,
180	IOPolledFileIOVars ** fileVars,
181	OSData ** imagePath,
a39ff7e2	182	uint8_t * volumeCryptKey, size_t * keySize);
3e170ce0 A	183
	184	IOReturn IOPolledFileClose(IOPolledFileIOVars ** pVars,
	185	off_t write_offset, void * addr, size_t write_length,
	186	off_t discard_offset, off_t discard_end);
	187
	188	IOReturn IOPolledFilePollersSetup(IOPolledFileIOVars * vars, uint32_t openState);
	189
	190	IOMemoryDescriptor * IOPolledFileGetIOBuffer(IOPolledFileIOVars * vars);
	191
	192	#endif /* defined(__cplusplus) */
	193
	194	#if defined(__cplusplus)
	195	#define __C "C"
	196	#else
	197	#define __C
	198	#endif
	199
	200	extern __C IOReturn IOPolledFileSeek(IOPolledFileIOVars * vars, uint64_t position);
	201
	202	extern __C IOReturn IOPolledFileWrite(IOPolledFileIOVars * vars,
	203	const uint8_t * bytes, IOByteCount size,
	204	IOPolledFileCryptVars * cryptvars);
	205	extern __C IOReturn IOPolledFileRead(IOPolledFileIOVars * vars,
	206	uint8_t * bytes, IOByteCount size,
	207	IOPolledFileCryptVars * cryptvars);
	208
5ba3f43e A	209	extern __C IOReturn IOPolledFileFlush(IOPolledFileIOVars * vars);
5ba3f43e A	210
3e170ce0 A	211	extern __C IOReturn IOPolledFilePollersOpen(IOPolledFileIOVars * vars, uint32_t state, bool abortable);
	212
	213	extern __C IOReturn IOPolledFilePollersClose(IOPolledFileIOVars * vars, uint32_t state);
	214
a39ff7e2 A	215	extern __C IOReturn IOPolledFilePollersSetEncryptionKey(IOPolledFileIOVars * vars,
	216	const uint8_t * key, size_t keySize);
	217
3e170ce0 A	218	extern __C IOPolledFileIOVars * gCoreFileVars;
	219
	220	#ifdef _SYS_CONF_H_
	221
	222	__BEGIN_DECLS
	223
	224	typedef void (kern_get_file_extents_callback_t)(void ref, uint64_t start, uint64_t size);
	225
	226	struct kern_direct_file_io_ref_t *
	227	kern_open_file_for_direct_io(const char * name, boolean_t create_file,
	228	kern_get_file_extents_callback_t callback,
	229	void * callback_ref,
	230	off_t set_file_size,
	231	off_t fs_free_size,
	232	off_t write_file_offset,
	233	void * write_file_addr,
	234	size_t write_file_len,
	235	dev_t * partition_device_result,
	236	dev_t * image_device_result,
	237	uint64_t * partitionbase_result,
	238	uint64_t * maxiocount_result,
	239	uint32_t * oflags);
	240	void
	241	kern_close_file_for_direct_io(struct kern_direct_file_io_ref_t * ref,
	242	off_t write_offset, void * addr, size_t write_length,
	243	off_t discard_offset, off_t discard_end);
	244	int
	245	kern_write_file(struct kern_direct_file_io_ref_t * ref, off_t offset, void * addr, size_t len, int ioflag);
	246	int
	247	kern_read_file(struct kern_direct_file_io_ref_t * ref, off_t offset, void * addr, size_t len, int ioflag);
	248
	249	struct mount *
	250	kern_file_mount(struct kern_direct_file_io_ref_t * ref);
	251
	252	enum
	253	{
	254	kIOPolledFileMountChangeMount = 0x00000101,
	255	kIOPolledFileMountChangeUnmount = 0x00000102,
	256	kIOPolledFileMountChangeWillResize = 0x00000201,
	257	kIOPolledFileMountChangeDidResize = 0x00000202,
	258	};
	259	extern void IOPolledFileMountChange(struct mount * mp, uint32_t op);
	260
	261	__END_DECLS
	262
	263	#endif /* _SYS_CONF_H_ */
	264
	265	#endif /* XNU_KERNEL_PRIVATE */
	266
2d21ac55	267	#endif /* _IOPOLLEDINTERFACE_H_ */