[apple/xnu.git] / iokit / IOKit / IOHibernatePrivate.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@
 */

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef KERNEL
#include <libkern/crypto/aes.h>
#include <uuid/uuid.h>
#endif

#ifndef __IOKIT_IOHIBERNATEPRIVATE_H
#define __IOKIT_IOHIBERNATEPRIVATE_H

struct IOPolledFileExtent
{
    uint64_t	start;
    uint64_t	length;
};
typedef struct IOPolledFileExtent IOPolledFileExtent;

struct IOHibernateImageHeader
{
    uint64_t	imageSize;
    uint64_t	image1Size;
    
    uint32_t	restore1CodePhysPage;
    uint32_t    reserved1;
    uint64_t	restore1CodeVirt;
    uint32_t	restore1PageCount;
    uint32_t	restore1CodeOffset;
    uint32_t	restore1StackOffset;
    
    uint32_t	pageCount;
    uint32_t	bitmapSize;

    uint32_t	restore1Sum;
    uint32_t	image1Sum;
    uint32_t	image2Sum;

    uint32_t	actualRestore1Sum;
    uint32_t	actualImage1Sum;
    uint32_t	actualImage2Sum;

    uint32_t	actualUncompressedPages;
    uint32_t	conflictCount;
    uint32_t	nextFree;

    uint32_t	signature;
    uint32_t	processorFlags;

    uint32_t    runtimePages;
    uint32_t    runtimePageCount;
    uint64_t    runtimeVirtualPages __attribute__ ((packed));

    uint32_t    performanceDataStart;
    uint32_t    performanceDataSize;
    
    uint64_t	encryptStart __attribute__ ((packed));
    uint64_t	machineSignature __attribute__ ((packed));

    uint32_t    previewSize;
    uint32_t    previewPageListSize;

    uint32_t	diag[4];

    uint32_t    handoffPages;
    uint32_t    handoffPageCount;

    uint32_t    systemTableOffset;

    uint32_t	debugFlags;
    uint32_t	options;
    uint32_t	sleepTime;
    uint32_t    compression;

    uint32_t	reserved[58];		// make sizeof == 512
    uint32_t	booterTime0;
    uint32_t	booterTime1;
    uint32_t	booterTime2;

    uint32_t	booterStart;
    uint32_t	smcStart;
    uint32_t	connectDisplayTime;
    uint32_t	splashTime;
    uint32_t	booterTime;
    uint32_t	trampolineTime;

    uint64_t	encryptEnd __attribute__ ((packed));
    uint64_t	deviceBase __attribute__ ((packed));
    uint32_t	deviceBlockSize;

    uint32_t		fileExtentMapSize;
    IOPolledFileExtent	fileExtentMap[2];
};
typedef struct IOHibernateImageHeader IOHibernateImageHeader;

enum
{
    kIOHibernateDebugRestoreLogs = 0x00000001
};

// options & IOHibernateOptions property
enum
{
    kIOHibernateOptionSSD           = 0x00000001,
    kIOHibernateOptionColor         = 0x00000002,
    kIOHibernateOptionProgress      = 0x00000004,
    kIOHibernateOptionDarkWake      = 0x00000008,
};

struct hibernate_bitmap_t
{
    uint32_t	first_page;
    uint32_t	last_page;
    uint32_t	bitmapwords;
    uint32_t	bitmap[0];
};
typedef struct hibernate_bitmap_t hibernate_bitmap_t;

struct hibernate_page_list_t
{
    uint32_t		  list_size;
    uint32_t		  page_count;
    uint32_t		  bank_count;
    hibernate_bitmap_t    bank_bitmap[0];
};
typedef struct hibernate_page_list_t hibernate_page_list_t;

#if defined(_AES_H)

struct hibernate_cryptwakevars_t
{
    uint8_t aes_iv[AES_BLOCK_SIZE];
};
typedef struct hibernate_cryptwakevars_t hibernate_cryptwakevars_t;

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

#endif /* defined(_AES_H) */

enum 
{
    kIOHibernateHandoffType                 = 0x686f0000,
    kIOHibernateHandoffTypeEnd              = kIOHibernateHandoffType + 0,
    kIOHibernateHandoffTypeGraphicsInfo     = kIOHibernateHandoffType + 1,
    kIOHibernateHandoffTypeCryptVars        = kIOHibernateHandoffType + 2,
    kIOHibernateHandoffTypeMemoryMap        = kIOHibernateHandoffType + 3,
    kIOHibernateHandoffTypeDeviceTree       = kIOHibernateHandoffType + 4,
    kIOHibernateHandoffTypeDeviceProperties = kIOHibernateHandoffType + 5,
    kIOHibernateHandoffTypeKeyStore         = kIOHibernateHandoffType + 6,
};

struct IOHibernateHandoff
{
    uint32_t type;
    uint32_t bytecount;
    uint8_t  data[];
};
typedef struct IOHibernateHandoff IOHibernateHandoff;

enum 
{
    kIOHibernateProgressCount         = 19,
    kIOHibernateProgressWidth         = 7,
    kIOHibernateProgressHeight        = 16,
    kIOHibernateProgressSpacing       = 3,
    kIOHibernateProgressOriginY       = 81,

    kIOHibernateProgressSaveUnderSize = 2*5+14*2,

    kIOHibernateProgressLightGray     = 230,
    kIOHibernateProgressMidGray       = 174,
    kIOHibernateProgressDarkGray      = 92
};

enum
{
    kIOHibernatePostWriteSleep   = 0,
    kIOHibernatePostWriteWake    = 1,
    kIOHibernatePostWriteHalt    = 2,
    kIOHibernatePostWriteRestart = 3
};


struct hibernate_graphics_t
{
    uint32_t physicalAddress;	// Base address of video memory
    int32_t  gfxStatus;         // EFI config restore status
    uint32_t rowBytes;   		// Number of bytes per pixel row
    uint32_t width;      		// Width
    uint32_t height;     		// Height
    uint32_t depth;      		// Pixel Depth

    uint8_t progressSaveUnder[kIOHibernateProgressCount][kIOHibernateProgressSaveUnderSize];
};
typedef struct hibernate_graphics_t hibernate_graphics_t;

#define DECLARE_IOHIBERNATEPROGRESSALPHA				\
static const uint8_t gIOHibernateProgressAlpha			\
[kIOHibernateProgressHeight][kIOHibernateProgressWidth] = 	\
{								\
    { 0x00,0x63,0xd8,0xf0,0xd8,0x63,0x00 },			\
    { 0x51,0xff,0xff,0xff,0xff,0xff,0x51 },			\
    { 0xae,0xff,0xff,0xff,0xff,0xff,0xae },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },			\
    { 0xae,0xff,0xff,0xff,0xff,0xff,0xae },			\
    { 0x54,0xff,0xff,0xff,0xff,0xff,0x54 },			\
    { 0x00,0x66,0xdb,0xf3,0xdb,0x66,0x00 }			\
};

struct hibernate_preview_t
{
    uint32_t  imageCount;	// Number of images
    uint32_t  width;      	// Width
    uint32_t  height;     	// Height
    uint32_t  depth;      	// Pixel Depth
    uint32_t  lockTime;     // Lock time
    uint32_t  reservedG[8]; // reserved
    uint32_t  reservedK[8]; // reserved
};
typedef struct hibernate_preview_t hibernate_preview_t;

struct hibernate_statistics_t
{
    uint64_t image1Size;
    uint64_t imageSize;
    uint32_t image1Pages;
    uint32_t imagePages;
    uint32_t booterStart;
    uint32_t smcStart;
    uint32_t booterDuration;
    uint32_t booterConnectDisplayDuration;
    uint32_t booterSplashDuration;
    uint32_t booterDuration0;
    uint32_t booterDuration1;
    uint32_t booterDuration2;
    uint32_t trampolineDuration;
    uint32_t kernelImageReadDuration;

    uint32_t graphicsReadyTime;
    uint32_t wakeNotificationTime;
    uint32_t lockScreenReadyTime;
    uint32_t hidReadyTime;

    uint32_t wakeCapability;
    uint32_t resvA[15];
};
typedef struct hibernate_statistics_t hibernate_statistics_t;

#define kIOSysctlHibernateStatistics	"kern.hibernatestatistics"
#define kIOSysctlHibernateGraphicsReady	"kern.hibernategraphicsready"
#define kIOSysctlHibernateWakeNotify	"kern.hibernatewakenotification"
#define kIOSysctlHibernateScreenReady	"kern.hibernatelockscreenready"
#define kIOSysctlHibernateHIDReady	"kern.hibernatehidready"

#ifdef KERNEL

#ifdef __cplusplus

void     IOHibernateSystemInit(IOPMrootDomain * rootDomain);

IOReturn IOHibernateSystemSleep(void);
void     IOOpenDebugDataFile(const char *fname, uint64_t size);
IOReturn IOHibernateIOKitSleep(void);
IOReturn IOHibernateSystemHasSlept(void);
IOReturn IOHibernateSystemWake(void);
IOReturn IOHibernateSystemPostWake(void);
bool     IOHibernateWasScreenLocked(void);
void     IOHibernateSetScreenLocked(uint32_t lockState);
void     IOHibernateSetWakeCapabilities(uint32_t capability);
void     IOHibernateSystemRestart(void);

#endif /* __cplusplus */

void
vm_compressor_do_warmup(void);


hibernate_page_list_t *
hibernate_page_list_allocate(boolean_t log);

kern_return_t 
hibernate_alloc_page_lists(
		hibernate_page_list_t ** page_list_ret,
		hibernate_page_list_t ** page_list_wired_ret,
		hibernate_page_list_t ** page_list_pal_ret);

kern_return_t 
hibernate_setup(IOHibernateImageHeader * header,
                        boolean_t vmflush,
			hibernate_page_list_t * page_list,
			hibernate_page_list_t * page_list_wired,
			hibernate_page_list_t * page_list_pal);

kern_return_t 
hibernate_teardown(hibernate_page_list_t * page_list,
                    hibernate_page_list_t * page_list_wired,
                    hibernate_page_list_t * page_list_pal);

kern_return_t 
hibernate_processor_setup(IOHibernateImageHeader * header);

void
hibernate_gobble_pages(uint32_t gobble_count, uint32_t free_page_time);
void
hibernate_free_gobble_pages(void);

void
hibernate_vm_lock_queues(void);
void
hibernate_vm_unlock_queues(void);

void
hibernate_vm_lock(void);
void
hibernate_vm_unlock(void);

// mark pages not to be saved, based on VM system accounting
void
hibernate_page_list_setall(hibernate_page_list_t * page_list,
			   hibernate_page_list_t * page_list_wired,
			   hibernate_page_list_t * page_list_pal,
			   boolean_t preflight, 
			   boolean_t discard_all,
			   uint32_t * pagesOut);

// mark pages to be saved, or pages not to be saved but available 
// for scratch usage during restore
void
hibernate_page_list_setall_machine(hibernate_page_list_t * page_list,
                                    hibernate_page_list_t * page_list_wired,
                                    boolean_t preflight,
                                    uint32_t * pagesOut);

// mark pages not to be saved and not for scratch usage during restore
void
hibernate_page_list_set_volatile( hibernate_page_list_t * page_list,
				  hibernate_page_list_t * page_list_wired,
				  uint32_t * pagesOut);

void
hibernate_page_list_discard(hibernate_page_list_t * page_list);

int
hibernate_should_abort(void);

void
hibernate_set_page_state(hibernate_page_list_t * page_list, hibernate_page_list_t * page_list_wired,
				vm_offset_t ppnum, vm_offset_t count, uint32_t kind);

void 
hibernate_page_bitset(hibernate_page_list_t * list, boolean_t set, uint32_t page);

boolean_t 
hibernate_page_bittst(hibernate_page_list_t * list, uint32_t page);

hibernate_bitmap_t *
hibernate_page_bitmap_pin(hibernate_page_list_t * list, uint32_t * page);

uint32_t
hibernate_page_bitmap_count(hibernate_bitmap_t * bitmap, uint32_t set, uint32_t page);

uintptr_t 
hibernate_restore_phys_page(uint64_t src, uint64_t dst, uint32_t len, uint32_t procFlags);

void
hibernate_machine_init(void);

uint32_t
hibernate_write_image(void);

long
hibernate_machine_entrypoint(uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4);
long
hibernate_kernel_entrypoint(uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4);
void
hibernate_newruntime_map(void * map, vm_size_t map_size, 
			    uint32_t system_table_offset);


extern uint32_t    gIOHibernateState;
extern uint32_t    gIOHibernateMode;
extern uint32_t    gIOHibernateDebugFlags;
extern uint32_t    gIOHibernateFreeTime;	// max time to spend freeing pages (ms)
extern uint8_t     gIOHibernateRestoreStack[];
extern uint8_t     gIOHibernateRestoreStackEnd[];
extern IOHibernateImageHeader *    gIOHibernateCurrentHeader;

#define HIBLOG(fmt, args...)	\
    { kprintf(fmt, ## args); printf(fmt, ## args); }

#define HIBPRINT(fmt, args...)	\
    { kprintf(fmt, ## args); }

#endif /* KERNEL */

// gIOHibernateState, kIOHibernateStateKey
enum
{
    kIOHibernateStateInactive            = 0,
    kIOHibernateStateHibernating 	 = 1,	/* writing image */
    kIOHibernateStateWakingFromHibernate = 2	/* booted and restored image */
};

// gIOHibernateMode, kIOHibernateModeKey
enum
{
    kIOHibernateModeOn      = 0x00000001,
    kIOHibernateModeSleep   = 0x00000002,
    kIOHibernateModeEncrypt = 0x00000004,
    kIOHibernateModeDiscardCleanInactive = 0x00000008,
    kIOHibernateModeDiscardCleanActive   = 0x00000010,
    kIOHibernateModeSwitch	= 0x00000020,
    kIOHibernateModeRestart	= 0x00000040,
    kIOHibernateModeSSDInvert	= 0x00000080,
    kIOHibernateModeFileResize	= 0x00000100,
};

// IOHibernateImageHeader.signature
enum
{
    kIOHibernateHeaderSignature        = 0x73696d65,
    kIOHibernateHeaderInvalidSignature = 0x7a7a7a7a,
    kIOHibernateHeaderOpenSignature    = 0xf1e0be9d,
    kIOHibernateHeaderDebugDataSignature = 0xfcddfcdd
};

// kind for hibernate_set_page_state()
enum
{
    kIOHibernatePageStateFree        = 0,
    kIOHibernatePageStateWiredSave   = 1,
    kIOHibernatePageStateUnwiredSave = 2
};

#define kIOHibernateModeKey		"Hibernate Mode"
#define kIOHibernateFileKey		"Hibernate File"
#define kIOHibernateFileMinSizeKey	"Hibernate File Min"
#define kIOHibernateFileMaxSizeKey	"Hibernate File Max"
#define kIOHibernateFreeRatioKey	"Hibernate Free Ratio"
#define kIOHibernateFreeTimeKey		"Hibernate Free Time"

#define kIOHibernateStateKey		"IOHibernateState"
#define kIOHibernateFeatureKey		"Hibernation"
#define kIOHibernatePreviewBufferKey	"IOPreviewBuffer"

#ifndef kIOHibernatePreviewActiveKey
#define kIOHibernatePreviewActiveKey	"IOHibernatePreviewActive"
// values for kIOHibernatePreviewActiveKey
enum {
    kIOHibernatePreviewActive  = 0x00000001,
    kIOHibernatePreviewUpdates = 0x00000002
};
#endif

#define kIOHibernateOptionsKey      "IOHibernateOptions"
#define kIOHibernateGfxStatusKey    "IOHibernateGfxStatus"
enum {
    kIOHibernateGfxStatusUnknown = ((int32_t) 0xFFFFFFFF)
};

#define kIOHibernateBootImageKey	"boot-image"
#define kIOHibernateBootImageKeyKey	"boot-image-key"
#define kIOHibernateBootSignatureKey	"boot-signature"

#define kIOHibernateMemorySignatureKey	  "memory-signature"
#define kIOHibernateMemorySignatureEnvKey "mem-sig"
#define kIOHibernateMachineSignatureKey	  "machine-signature"

#define kIOHibernateRTCVariablesKey	"IOHibernateRTCVariables"
#define kIOHibernateSMCVariablesKey	"IOHibernateSMCVariables"

#define kIOHibernateBootSwitchVarsKey	"boot-switch-vars"

#define kIOHibernateBootNoteKey		"boot-note"


#define kIOHibernateUseKernelInterpreter    0x80000000

enum
{
	kIOPreviewImageIndexDesktop = 0, 
	kIOPreviewImageIndexLockScreen = 1, 
	kIOPreviewImageCount = 2
};

enum
{
	kIOScreenLockNoLock          = 1,
	kIOScreenLockUnlocked        = 2,
	kIOScreenLockLocked          = 3,
	kIOScreenLockFileVaultDialog = 4,
};	

#define kIOScreenLockStateKey      "IOScreenLockState"

#endif /* ! __IOKIT_IOHIBERNATEPRIVATE_H */

#ifdef __cplusplus
}
#endif
Commit	Line	Data
3a60a9f5 A	1	/*
	2	* Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
3a60a9f5	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@
3a60a9f5 A	27	*/
	28
	29	#include <stdint.h>
	30
	31	#ifdef __cplusplus
	32	extern "C" {
	33	#endif
	34
	35	#ifdef KERNEL
316670eb	36	#include <libkern/crypto/aes.h>
6d2010ae	37	#include <uuid/uuid.h>
3a60a9f5 A	38	#endif
3a60a9f5 A	39
316670eb A	40	#ifndef __IOKIT_IOHIBERNATEPRIVATE_H
	41	#define __IOKIT_IOHIBERNATEPRIVATE_H
	42
3a60a9f5 A	43	struct IOPolledFileExtent
	44	{
	45	uint64_t start;
	46	uint64_t length;
	47	};
	48	typedef struct IOPolledFileExtent IOPolledFileExtent;
	49
	50	struct IOHibernateImageHeader
	51	{
	52	uint64_t imageSize;
	53	uint64_t image1Size;
	54
6d2010ae A	55	uint32_t restore1CodePhysPage;
	56	uint32_t reserved1;
	57	uint64_t restore1CodeVirt;
3a60a9f5 A	58	uint32_t restore1PageCount;
	59	uint32_t restore1CodeOffset;
	60	uint32_t restore1StackOffset;
	61
	62	uint32_t pageCount;
	63	uint32_t bitmapSize;
	64
	65	uint32_t restore1Sum;
	66	uint32_t image1Sum;
	67	uint32_t image2Sum;
	68
	69	uint32_t actualRestore1Sum;
	70	uint32_t actualImage1Sum;
	71	uint32_t actualImage2Sum;
	72
	73	uint32_t actualUncompressedPages;
	74	uint32_t conflictCount;
	75	uint32_t nextFree;
	76
	77	uint32_t signature;
	78	uint32_t processorFlags;
	79
0c530ab8 A	80	uint32_t runtimePages;
0c530ab8 A	81	uint32_t runtimePageCount;
b0d623f7	82	uint64_t runtimeVirtualPages __attribute__ ((packed));
d1ecb069 A	83
	84	uint32_t performanceDataStart;
	85	uint32_t performanceDataSize;
3a60a9f5	86
b0d623f7 A	87	uint64_t encryptStart __attribute__ ((packed));
b0d623f7 A	88	uint64_t machineSignature __attribute__ ((packed));
3a60a9f5 A	89
	90	uint32_t previewSize;
	91	uint32_t previewPageListSize;
	92
	93	uint32_t diag[4];
	94
6d2010ae A	95	uint32_t handoffPages;
	96	uint32_t handoffPageCount;
	97
0c530ab8 A	98	uint32_t systemTableOffset;
0c530ab8 A	99
b0d623f7	100	uint32_t debugFlags;
0b4c1975	101	uint32_t options;
316670eb	102	uint32_t sleepTime;
db609669	103	uint32_t compression;
b0d623f7	104
39236c6e A	105	uint32_t reserved[58]; // make sizeof == 512
	106	uint32_t booterTime0;
	107	uint32_t booterTime1;
	108	uint32_t booterTime2;
	109
	110	uint32_t booterStart;
	111	uint32_t smcStart;
	112	uint32_t connectDisplayTime;
	113	uint32_t splashTime;
	114	uint32_t booterTime;
	115	uint32_t trampolineTime;
0b4c1975 A	116
	117	uint64_t encryptEnd __attribute__ ((packed));
	118	uint64_t deviceBase __attribute__ ((packed));
39236c6e	119	uint32_t deviceBlockSize;
3a60a9f5 A	120
	121	uint32_t fileExtentMapSize;
	122	IOPolledFileExtent fileExtentMap[2];
	123	};
	124	typedef struct IOHibernateImageHeader IOHibernateImageHeader;
	125
b0d623f7 A	126	enum
	127	{
	128	kIOHibernateDebugRestoreLogs = 0x00000001
	129	};
3a60a9f5	130
0b4c1975 A	131	// options & IOHibernateOptions property
	132	enum
	133	{
	134	kIOHibernateOptionSSD = 0x00000001,
	135	kIOHibernateOptionColor = 0x00000002,
	136	kIOHibernateOptionProgress = 0x00000004,
	137	kIOHibernateOptionDarkWake = 0x00000008,
	138	};
	139
3a60a9f5 A	140	struct hibernate_bitmap_t
	141	{
	142	uint32_t first_page;
	143	uint32_t last_page;
	144	uint32_t bitmapwords;
	145	uint32_t bitmap[0];
	146	};
	147	typedef struct hibernate_bitmap_t hibernate_bitmap_t;
	148
	149	struct hibernate_page_list_t
	150	{
	151	uint32_t list_size;
	152	uint32_t page_count;
	153	uint32_t bank_count;
	154	hibernate_bitmap_t bank_bitmap[0];
	155	};
	156	typedef struct hibernate_page_list_t hibernate_page_list_t;
	157
2d21ac55 A	158	#if defined(_AES_H)
2d21ac55 A	159
3a60a9f5 A	160	struct hibernate_cryptwakevars_t
3a60a9f5 A	161	{
3a60a9f5	162	uint8_t aes_iv[AES_BLOCK_SIZE];
3a60a9f5 A	163	};
	164	typedef struct hibernate_cryptwakevars_t hibernate_cryptwakevars_t;
	165
	166	struct hibernate_cryptvars_t
	167	{
3a60a9f5 A	168	uint8_t aes_iv[AES_BLOCK_SIZE];
3a60a9f5 A	169	aes_ctx ctx;
3a60a9f5 A	170	};
	171	typedef struct hibernate_cryptvars_t hibernate_cryptvars_t;
	172
2d21ac55 A	173	#endif /* defined(_AES_H) */
2d21ac55 A	174
6d2010ae A	175	enum
	176	{
	177	kIOHibernateHandoffType = 0x686f0000,
	178	kIOHibernateHandoffTypeEnd = kIOHibernateHandoffType + 0,
	179	kIOHibernateHandoffTypeGraphicsInfo = kIOHibernateHandoffType + 1,
	180	kIOHibernateHandoffTypeCryptVars = kIOHibernateHandoffType + 2,
	181	kIOHibernateHandoffTypeMemoryMap = kIOHibernateHandoffType + 3,
	182	kIOHibernateHandoffTypeDeviceTree = kIOHibernateHandoffType + 4,
	183	kIOHibernateHandoffTypeDeviceProperties = kIOHibernateHandoffType + 5,
	184	kIOHibernateHandoffTypeKeyStore = kIOHibernateHandoffType + 6,
	185	};
	186
	187	struct IOHibernateHandoff
	188	{
	189	uint32_t type;
	190	uint32_t bytecount;
	191	uint8_t data[];
	192	};
	193	typedef struct IOHibernateHandoff IOHibernateHandoff;
3a60a9f5 A	194
	195	enum
	196	{
	197	kIOHibernateProgressCount = 19,
	198	kIOHibernateProgressWidth = 7,
	199	kIOHibernateProgressHeight = 16,
	200	kIOHibernateProgressSpacing = 3,
	201	kIOHibernateProgressOriginY = 81,
	202
	203	kIOHibernateProgressSaveUnderSize = 25+142,
	204
	205	kIOHibernateProgressLightGray = 230,
	206	kIOHibernateProgressMidGray = 174,
	207	kIOHibernateProgressDarkGray = 92
	208	};
	209
2d21ac55 A	210	enum
	211	{
	212	kIOHibernatePostWriteSleep = 0,
	213	kIOHibernatePostWriteWake = 1,
	214	kIOHibernatePostWriteHalt = 2,
	215	kIOHibernatePostWriteRestart = 3
	216	};
	217
	218
3a60a9f5 A	219	struct hibernate_graphics_t
3a60a9f5 A	220	{
0b4c1975 A	221	uint32_t physicalAddress; // Base address of video memory
0b4c1975 A	222	int32_t gfxStatus; // EFI config restore status
0c530ab8 A	223	uint32_t rowBytes; // Number of bytes per pixel row
	224	uint32_t width; // Width
	225	uint32_t height; // Height
	226	uint32_t depth; // Pixel Depth
	227
	228	uint8_t progressSaveUnder[kIOHibernateProgressCount][kIOHibernateProgressSaveUnderSize];
3a60a9f5 A	229	};
	230	typedef struct hibernate_graphics_t hibernate_graphics_t;
	231
	232	#define DECLARE_IOHIBERNATEPROGRESSALPHA \
	233	static const uint8_t gIOHibernateProgressAlpha \
	234	[kIOHibernateProgressHeight][kIOHibernateProgressWidth] = \
	235	{ \
	236	{ 0x00,0x63,0xd8,0xf0,0xd8,0x63,0x00 }, \
	237	{ 0x51,0xff,0xff,0xff,0xff,0xff,0x51 }, \
	238	{ 0xae,0xff,0xff,0xff,0xff,0xff,0xae }, \
	239	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	240	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	241	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	242	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	243	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	244	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	245	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	246	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	247	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	248	{ 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 }, \
	249	{ 0xae,0xff,0xff,0xff,0xff,0xff,0xae }, \
	250	{ 0x54,0xff,0xff,0xff,0xff,0xff,0x54 }, \
	251	{ 0x00,0x66,0xdb,0xf3,0xdb,0x66,0x00 } \
	252	};
	253
316670eb A	254	struct hibernate_preview_t
	255	{
	256	uint32_t imageCount; // Number of images
	257	uint32_t width; // Width
	258	uint32_t height; // Height
	259	uint32_t depth; // Pixel Depth
	260	uint32_t lockTime; // Lock time
	261	uint32_t reservedG[8]; // reserved
	262	uint32_t reservedK[8]; // reserved
	263	};
	264	typedef struct hibernate_preview_t hibernate_preview_t;
	265
39236c6e A	266	struct hibernate_statistics_t
	267	{
	268	uint64_t image1Size;
	269	uint64_t imageSize;
	270	uint32_t image1Pages;
	271	uint32_t imagePages;
	272	uint32_t booterStart;
	273	uint32_t smcStart;
	274	uint32_t booterDuration;
	275	uint32_t booterConnectDisplayDuration;
	276	uint32_t booterSplashDuration;
	277	uint32_t booterDuration0;
	278	uint32_t booterDuration1;
	279	uint32_t booterDuration2;
	280	uint32_t trampolineDuration;
	281	uint32_t kernelImageReadDuration;
	282
	283	uint32_t graphicsReadyTime;
	284	uint32_t wakeNotificationTime;
	285	uint32_t lockScreenReadyTime;
	286	uint32_t hidReadyTime;
	287
	288	uint32_t wakeCapability;
	289	uint32_t resvA[15];
	290	};
	291	typedef struct hibernate_statistics_t hibernate_statistics_t;
	292
	293	#define kIOSysctlHibernateStatistics "kern.hibernatestatistics"
	294	#define kIOSysctlHibernateGraphicsReady "kern.hibernategraphicsready"
	295	#define kIOSysctlHibernateWakeNotify "kern.hibernatewakenotification"
	296	#define kIOSysctlHibernateScreenReady "kern.hibernatelockscreenready"
	297	#define kIOSysctlHibernateHIDReady "kern.hibernatehidready"
	298
3a60a9f5 A	299	#ifdef KERNEL
	300
	301	#ifdef __cplusplus
	302
	303	void IOHibernateSystemInit(IOPMrootDomain * rootDomain);
	304
	305	IOReturn IOHibernateSystemSleep(void);
3e170ce0	306	void IOOpenDebugDataFile(const char *fname, uint64_t size);
316670eb	307	IOReturn IOHibernateIOKitSleep(void);
3a60a9f5 A	308	IOReturn IOHibernateSystemHasSlept(void);
	309	IOReturn IOHibernateSystemWake(void);
	310	IOReturn IOHibernateSystemPostWake(void);
316670eb A	311	bool IOHibernateWasScreenLocked(void);
316670eb A	312	void IOHibernateSetScreenLocked(uint32_t lockState);
39236c6e	313	void IOHibernateSetWakeCapabilities(uint32_t capability);
99c3a104	314	void IOHibernateSystemRestart(void);
3a60a9f5 A	315
	316	#endif /* __cplusplus */
	317
8a3053a0 A	318	void
	319	vm_compressor_do_warmup(void);
	320
fe8ab488	321
3a60a9f5	322	hibernate_page_list_t *
db609669	323	hibernate_page_list_allocate(boolean_t log);
3a60a9f5	324
39236c6e A	325	kern_return_t
	326	hibernate_alloc_page_lists(
	327	hibernate_page_list_t ** page_list_ret,
	328	hibernate_page_list_t ** page_list_wired_ret,
	329	hibernate_page_list_t ** page_list_pal_ret);
	330
3a60a9f5 A	331	kern_return_t
3a60a9f5 A	332	hibernate_setup(IOHibernateImageHeader * header,
0b4c1975	333	boolean_t vmflush,
39236c6e A	334	hibernate_page_list_t * page_list,
	335	hibernate_page_list_t * page_list_wired,
	336	hibernate_page_list_t * page_list_pal);
	337
3a60a9f5 A	338	kern_return_t
3a60a9f5 A	339	hibernate_teardown(hibernate_page_list_t * page_list,
99c3a104 A	340	hibernate_page_list_t * page_list_wired,
99c3a104 A	341	hibernate_page_list_t * page_list_pal);
3a60a9f5 A	342
	343	kern_return_t
	344	hibernate_processor_setup(IOHibernateImageHeader * header);
	345
b0d623f7 A	346	void
	347	hibernate_gobble_pages(uint32_t gobble_count, uint32_t free_page_time);
	348	void
	349	hibernate_free_gobble_pages(void);
	350
db609669 A	351	void
	352	hibernate_vm_lock_queues(void);
	353	void
	354	hibernate_vm_unlock_queues(void);
	355
3a60a9f5 A	356	void
	357	hibernate_vm_lock(void);
	358	void
	359	hibernate_vm_unlock(void);
	360
0c530ab8	361	// mark pages not to be saved, based on VM system accounting
3a60a9f5 A	362	void
	363	hibernate_page_list_setall(hibernate_page_list_t * page_list,
	364	hibernate_page_list_t * page_list_wired,
6d2010ae	365	hibernate_page_list_t * page_list_pal,
39236c6e A	366	boolean_t preflight,
39236c6e A	367	boolean_t discard_all,
3a60a9f5 A	368	uint32_t * pagesOut);
3a60a9f5 A	369
0c530ab8 A	370	// mark pages to be saved, or pages not to be saved but available
0c530ab8 A	371	// for scratch usage during restore
3a60a9f5 A	372	void
	373	hibernate_page_list_setall_machine(hibernate_page_list_t * page_list,
	374	hibernate_page_list_t * page_list_wired,
db609669	375	boolean_t preflight,
3a60a9f5	376	uint32_t * pagesOut);
0c530ab8 A	377
	378	// mark pages not to be saved and not for scratch usage during restore
	379	void
	380	hibernate_page_list_set_volatile( hibernate_page_list_t * page_list,
	381	hibernate_page_list_t * page_list_wired,
	382	uint32_t * pagesOut);
	383
3a60a9f5 A	384	void
	385	hibernate_page_list_discard(hibernate_page_list_t * page_list);
	386
0b4c1975 A	387	int
	388	hibernate_should_abort(void);
	389
3a60a9f5 A	390	void
	391	hibernate_set_page_state(hibernate_page_list_t * page_list, hibernate_page_list_t * page_list_wired,
	392	vm_offset_t ppnum, vm_offset_t count, uint32_t kind);
	393
	394	void
	395	hibernate_page_bitset(hibernate_page_list_t * list, boolean_t set, uint32_t page);
0c530ab8	396
3a60a9f5 A	397	boolean_t
	398	hibernate_page_bittst(hibernate_page_list_t * list, uint32_t page);
	399
0c530ab8 A	400	hibernate_bitmap_t *
	401	hibernate_page_bitmap_pin(hibernate_page_list_t * list, uint32_t * page);
	402
3a60a9f5	403	uint32_t
0c530ab8	404	hibernate_page_bitmap_count(hibernate_bitmap_t * bitmap, uint32_t set, uint32_t page);
3a60a9f5	405
6d2010ae	406	uintptr_t
3a60a9f5 A	407	hibernate_restore_phys_page(uint64_t src, uint64_t dst, uint32_t len, uint32_t procFlags);
	408
	409	void
	410	hibernate_machine_init(void);
2d21ac55 A	411
2d21ac55 A	412	uint32_t
3a60a9f5 A	413	hibernate_write_image(void);
	414
	415	long
7ddcb079	416	hibernate_machine_entrypoint(uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4);
3a60a9f5	417	long
7ddcb079	418	hibernate_kernel_entrypoint(uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4);
0c530ab8 A	419	void
	420	hibernate_newruntime_map(void * map, vm_size_t map_size,
	421	uint32_t system_table_offset);
	422
3a60a9f5 A	423
	424	extern uint32_t gIOHibernateState;
	425	extern uint32_t gIOHibernateMode;
b0d623f7	426	extern uint32_t gIOHibernateDebugFlags;
3a60a9f5 A	427	extern uint32_t gIOHibernateFreeTime; // max time to spend freeing pages (ms)
	428	extern uint8_t gIOHibernateRestoreStack[];
	429	extern uint8_t gIOHibernateRestoreStackEnd[];
	430	extern IOHibernateImageHeader * gIOHibernateCurrentHeader;
3a60a9f5 A	431
	432	#define HIBLOG(fmt, args...) \
	433	{ kprintf(fmt, ## args); printf(fmt, ## args); }
	434
	435	#define HIBPRINT(fmt, args...) \
	436	{ kprintf(fmt, ## args); }
	437
	438	#endif /* KERNEL */
	439
	440	// gIOHibernateState, kIOHibernateStateKey
	441	enum
	442	{
	443	kIOHibernateStateInactive = 0,
	444	kIOHibernateStateHibernating = 1, /* writing image */
	445	kIOHibernateStateWakingFromHibernate = 2 /* booted and restored image */
	446	};
	447
	448	// gIOHibernateMode, kIOHibernateModeKey
	449	enum
	450	{
	451	kIOHibernateModeOn = 0x00000001,
	452	kIOHibernateModeSleep = 0x00000002,
	453	kIOHibernateModeEncrypt = 0x00000004,
3a60a9f5	454	kIOHibernateModeDiscardCleanInactive = 0x00000008,
2d21ac55 A	455	kIOHibernateModeDiscardCleanActive = 0x00000010,
2d21ac55 A	456	kIOHibernateModeSwitch = 0x00000020,
0b4c1975 A	457	kIOHibernateModeRestart = 0x00000040,
0b4c1975 A	458	kIOHibernateModeSSDInvert = 0x00000080,
db609669	459	kIOHibernateModeFileResize = 0x00000100,
3a60a9f5 A	460	};
	461
	462	// IOHibernateImageHeader.signature
	463	enum
	464	{
	465	kIOHibernateHeaderSignature = 0x73696d65,
fe8ab488 A	466	kIOHibernateHeaderInvalidSignature = 0x7a7a7a7a,
	467	kIOHibernateHeaderOpenSignature = 0xf1e0be9d,
	468	kIOHibernateHeaderDebugDataSignature = 0xfcddfcdd
3a60a9f5 A	469	};
	470
	471	// kind for hibernate_set_page_state()
	472	enum
	473	{
	474	kIOHibernatePageStateFree = 0,
	475	kIOHibernatePageStateWiredSave = 1,
	476	kIOHibernatePageStateUnwiredSave = 2
	477	};
	478
	479	#define kIOHibernateModeKey "Hibernate Mode"
	480	#define kIOHibernateFileKey "Hibernate File"
db609669 A	481	#define kIOHibernateFileMinSizeKey "Hibernate File Min"
db609669 A	482	#define kIOHibernateFileMaxSizeKey "Hibernate File Max"
3a60a9f5 A	483	#define kIOHibernateFreeRatioKey "Hibernate Free Ratio"
	484	#define kIOHibernateFreeTimeKey "Hibernate Free Time"
	485
	486	#define kIOHibernateStateKey "IOHibernateState"
	487	#define kIOHibernateFeatureKey "Hibernation"
	488	#define kIOHibernatePreviewBufferKey "IOPreviewBuffer"
	489
316670eb	490	#ifndef kIOHibernatePreviewActiveKey
2d21ac55 A	491	#define kIOHibernatePreviewActiveKey "IOHibernatePreviewActive"
	492	// values for kIOHibernatePreviewActiveKey
	493	enum {
	494	kIOHibernatePreviewActive = 0x00000001,
	495	kIOHibernatePreviewUpdates = 0x00000002
	496	};
316670eb	497	#endif
2d21ac55	498
0b4c1975 A	499	#define kIOHibernateOptionsKey "IOHibernateOptions"
	500	#define kIOHibernateGfxStatusKey "IOHibernateGfxStatus"
	501	enum {
	502	kIOHibernateGfxStatusUnknown = ((int32_t) 0xFFFFFFFF)
	503	};
	504
3a60a9f5 A	505	#define kIOHibernateBootImageKey "boot-image"
	506	#define kIOHibernateBootImageKeyKey "boot-image-key"
	507	#define kIOHibernateBootSignatureKey "boot-signature"
	508
	509	#define kIOHibernateMemorySignatureKey "memory-signature"
	510	#define kIOHibernateMemorySignatureEnvKey "mem-sig"
	511	#define kIOHibernateMachineSignatureKey "machine-signature"
	512
0c530ab8	513	#define kIOHibernateRTCVariablesKey "IOHibernateRTCVariables"
6d2010ae	514	#define kIOHibernateSMCVariablesKey "IOHibernateSMCVariables"
0c530ab8	515
99c3a104 A	516	#define kIOHibernateBootSwitchVarsKey "boot-switch-vars"
	517
	518	#define kIOHibernateBootNoteKey "boot-note"
	519
2d21ac55	520
6d2010ae	521	#define kIOHibernateUseKernelInterpreter 0x80000000
2d21ac55	522
316670eb A	523	enum
	524	{
	525	kIOPreviewImageIndexDesktop = 0,
	526	kIOPreviewImageIndexLockScreen = 1,
	527	kIOPreviewImageCount = 2
	528	};
	529
	530	enum
	531	{
	532	kIOScreenLockNoLock = 1,
	533	kIOScreenLockUnlocked = 2,
	534	kIOScreenLockLocked = 3,
	535	kIOScreenLockFileVaultDialog = 4,
	536	};
	537
	538	#define kIOScreenLockStateKey "IOScreenLockState"
	539
	540	#endif /* ! __IOKIT_IOHIBERNATEPRIVATE_H */
	541
3a60a9f5 A	542	#ifdef __cplusplus
	543	}
	544	#endif