Index: branches/ErmaC/Enoch/i386/boot2/resume.c =================================================================== --- branches/ErmaC/Enoch/i386/boot2/resume.c (revision 2363) +++ branches/ErmaC/Enoch/i386/boot2/resume.c (revision 2364) @@ -37,6 +37,63 @@ return 0x10000000; } +static void WakeKernelSnow(IOHibernateImageHeaderSnow * header) +{ + uint32_t proc; + unsigned long cnt, newSP; + unsigned long *src, *dst; + unsigned int count; + unsigned int page; + unsigned int compressedSize; + int32_t byteCnt; + u_int32_t lowHalf, highHalf; + u_int32_t sum; + + printf("\nWake Kernel!\n"); + + dst = (unsigned long *) (header->restore1CodePhysPage << 12); + count = header->restore1PageCount; + proc = (header->restore1CodeOffset + ((uint32_t) dst)); + newSP = header->restore1StackOffset + (header->restore1CodePhysPage << 12); + + src = (unsigned long *) (((u_int32_t) &header->fileExtentMap[0]) + + header->fileExtentMapSize); + sum = 0; + + for (page = 0; page < count; page++) + { + compressedSize = 4096; + + lowHalf = 1; + highHalf = 0; + + for (cnt = 0; cnt < compressedSize; cnt += 0x20) { + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + dst[3] = src[3]; + dst[4] = src[4]; + dst[5] = src[5]; + dst[6] = src[6]; + dst[7] = src[7]; + for (byteCnt = 0; byteCnt < 0x20; byteCnt++) { + lowHalf += ((u_int8_t *) dst)[byteCnt]; + highHalf += lowHalf; + } + src += 8; + dst += 8; + } + + lowHalf %= 65521L; + highHalf %= 65521L; + sum += (highHalf << 16) | lowHalf; + } + header->actualRestore1Sum = sum; + startprog (proc, header); + + return; +} + static void WakeKernel(IOHibernateImageHeader * header) { uint32_t proc; @@ -51,11 +108,12 @@ printf("\nWake Kernel!\n"); - dst = (unsigned long *) (header->restore1CodePage << 12); + dst = (unsigned long *) (header->restore1CodePhysPage << 12); count = header->restore1PageCount; proc = (header->restore1CodeOffset + ((uint32_t) dst)); - newSP = header->restore1StackOffset + (header->restore1CodePage << 12); + newSP = header->restore1StackOffset + (header->restore1CodePhysPage << 12); + src = (unsigned long *) (((u_int32_t) &header->fileExtentMap[0]) + header->fileExtentMapSize); sum = 0; @@ -107,6 +165,125 @@ imageSize = header->image1Size; codeSize = header->restore1PageCount << 12; + if (kIOHibernateHeaderSignature != header->signature) + { + printf ("Incorrect image signature, expected version 10.7\n"); + getchar(); + return; + } + if (header->encryptStart) + { + printf ("Resuming from Encrypted image is unsupported.\n" + "Uncheck \"Use secure virtual memory\" in \"Security\" pane on system preferences.\n" + "Press any key to proceed with normal boot.\n"); + getchar(); + return; + } +// depends on NVRAM +#if 0 + { + uint32_t machineSignature; + size = GetProp(gChosenPH, kIOHibernateMachineSignatureKey, + (char *)&machineSignature, sizeof(machineSignature)); + if (size != sizeof(machineSignature)) machineSignature = 0; + if (machineSignature != header->machineSignature) + break; + } +#endif + + allocSize = imageSize + ((4095 + sizeof(hibernate_graphics_t)) & ~4095); + + mem_base = (long)(getmemorylimit() - allocSize);//TODO: lower this + + printf("mem_base %x\n", mem_base); + + bcopy(header, (void *) mem_base, sizeof(IOHibernateImageHeader)); + header = (IOHibernateImageHeader *) mem_base; + + imageSize -= sizeof(IOHibernateImageHeader); + buffer = (long)(header + 1); + + if (header->previewSize) + { + uint64_t preview_offset = header->fileExtentMapSize - sizeof(header->fileExtentMap) + codeSize; + uint8_t progressSaveUnder[kIOHibernateProgressCount][kIOHibernateProgressSaveUnderSize]; + + ReadFileAtOffset (image_filename, (char *)buffer, sizeof(IOHibernateImageHeader), preview_offset+header->previewSize); + drawPreview ((void *)(long)(buffer+preview_offset + header->previewPageListSize), &(progressSaveUnder[0][0])); + previewTotalSectors = (int)(imageSize-(preview_offset+header->previewSize))/512; + previewLoadedSectors = 0; + previewSaveunder = &(progressSaveUnder[0][0]); + if (preview_offset+header->previewSizepreviewSize), + sizeof(IOHibernateImageHeader)+preview_offset+header->previewSize, + imageSize-(preview_offset+header->previewSize)); + previewTotalSectors = 0; + previewLoadedSectors = 0; + previewSaveunder = 0; +#if 0 + /* AsereBLN: + check_vga_nvidia() didn't work as expected (recursion level > 0 & return value). + Unforutnaltely I cannot find a note why to switch back to text mode for nVidia cards only + and because it check_vga_nvidia does not work (cards normally are behind a bridge) I will + remove it completely */ + setVideoMode( VGA_TEXT_MODE, 0 ); +#endif + } + else + ReadFileAtOffset (image_filename, (char *)buffer, sizeof(IOHibernateImageHeader), imageSize); + +// Depends on NVRAM +#if 0 + if (header->encryptStart) { + // decryption data + static const unsigned char first_iv[AES_BLOCK_SIZE] + = { 0xa3, 0x63, 0x65, 0xa9, 0x0b, 0x71, 0x7b, 0x1c, + 0xdf, 0x9e, 0x5f, 0x32, 0xd7, 0x61, 0x63, 0xda }; + hibernate_cryptvars_t _cryptvars; + hibernate_cryptvars_t * cryptvars = &_cryptvars; + + aes_decrypt_key(&decryptkey, + decryptkeysize, + &cryptvars->ctx.decrypt); + + // set the vector for the following decryptions + bcopy(((uint8_t *) header) + header->image1Size - AES_BLOCK_SIZE, + &cryptvars->aes_iv[0], AES_BLOCK_SIZE); + + // decrypt the buffer + uint32_t len = (uint32_t)(header->image1Size - header->encryptStart); + aes_decrypt_cbc(((uint8_t *) header) + header->encryptStart, + &first_iv[0], + len >> 4, + ((uint8_t *) header) + header->encryptStart, + &cryptvars->ctx.decrypt); + bzero(&cryptvars->aes_iv[0], sizeof(cryptvars)); + bzero(&decryptkey, sizeof(decryptkey)); + } +#endif + + WakeKernel(header); +} + +void HibernateBootSnow(char *image_filename) +{ + long long size, imageSize, codeSize, allocSize; + long mem_base; + IOHibernateImageHeaderSnow _header; + IOHibernateImageHeaderSnow * header = &_header; + long buffer; + + if(gMacOSVersion[3] >= '7') // TODO: unlocked, but please check the compatibility with the 10.8 + { + HibernateBoot(image_filename); + return; + } + + size = ReadFileAtOffset (image_filename, header, 0, sizeof(IOHibernateImageHeaderSnow)); + printf("header read size %x\n", size); + + imageSize = header->image1Size; + codeSize = header->restore1PageCount << 12; if (kIOHibernateHeaderSignature != header->signature) { printf ("Incorrect image signature\n"); return; @@ -135,7 +312,7 @@ allocSize = imageSize + ((4095 + sizeof(hibernate_graphics_t)) & ~4095); - mem_base = getmemorylimit() - allocSize;//TODO: lower this + mem_base = (long)(getmemorylimit() - allocSize);//TODO: lower this printf("mem_base %x\n", mem_base); if (((long long)mem_base + allocSize) < (1024 * bootInfo->extmem + 0x100000)) { @@ -144,24 +321,24 @@ return; } - bcopy(header, (void *) mem_base, sizeof(IOHibernateImageHeader)); - header = (IOHibernateImageHeader *) mem_base; + bcopy(header, (void *) mem_base, sizeof(IOHibernateImageHeaderSnow)); + header = (IOHibernateImageHeaderSnow *) mem_base; - imageSize -= sizeof(IOHibernateImageHeader); + imageSize -= sizeof(IOHibernateImageHeaderSnow); buffer = (long)(header + 1); if (header->previewSize) { uint64_t preview_offset = header->fileExtentMapSize - sizeof(header->fileExtentMap) + codeSize; uint8_t progressSaveUnder[kIOHibernateProgressCount][kIOHibernateProgressSaveUnderSize]; - ReadFileAtOffset (image_filename, (char *)buffer, sizeof(IOHibernateImageHeader), preview_offset+header->previewSize); + ReadFileAtOffset (image_filename, (char *)buffer, sizeof(IOHibernateImageHeaderSnow), preview_offset+header->previewSize); drawPreview ((void *)(long)(buffer+preview_offset + header->previewPageListSize), &(progressSaveUnder[0][0])); previewTotalSectors = (imageSize-(preview_offset+header->previewSize))/512; previewLoadedSectors = 0; previewSaveunder = &(progressSaveUnder[0][0]); if (preview_offset+header->previewSizepreviewSize), - sizeof(IOHibernateImageHeader)+preview_offset+header->previewSize, + sizeof(IOHibernateImageHeaderSnow)+preview_offset+header->previewSize, imageSize-(preview_offset+header->previewSize)); } previewTotalSectors = 0; @@ -176,7 +353,7 @@ // setVideoMode( VGA_TEXT_MODE, 0 ); #endif } else { - ReadFileAtOffset (image_filename, (char *)buffer, sizeof(IOHibernateImageHeader), imageSize); + ReadFileAtOffset (image_filename, (char *)buffer, sizeof(IOHibernateImageHeaderSnow), imageSize); } // Depends on NVRAM #if 0 @@ -208,5 +385,5 @@ } #endif - WakeKernel(header); + WakeKernelSnow(header); } Index: branches/ErmaC/Enoch/i386/boot2/boot.h =================================================================== --- branches/ErmaC/Enoch/i386/boot2/boot.h (revision 2363) +++ branches/ErmaC/Enoch/i386/boot2/boot.h (revision 2364) @@ -328,6 +328,7 @@ /* resume.c */ void HibernateBoot(char *boot_device); +void HibernateBootSnow(char *boot_device); /* bmdecompress.c */ void * DecompressData(void *srcbase, int *dw, int *dh, int *bytesPerPixel); Index: branches/ErmaC/Enoch/i386/boot2/IOHibernatePrivate.h =================================================================== --- branches/ErmaC/Enoch/i386/boot2/IOHibernatePrivate.h (revision 2363) +++ branches/ErmaC/Enoch/i386/boot2/IOHibernatePrivate.h (revision 2364) @@ -2,7 +2,7 @@ * 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 @@ -34,6 +34,9 @@ #include #endif +#ifndef __IOKIT_IOHIBERNATEPRIVATE_H +#define __IOKIT_IOHIBERNATEPRIVATE_H + struct IOPolledFileExtent { uint64_t start; @@ -43,10 +46,86 @@ struct IOHibernateImageHeader { + uint64_t imageSize; // 0 + uint64_t image1Size; // 8 + + uint32_t restore1CodePhysPage; // 10 + uint32_t reserved1; // 14 + uint64_t restore1CodeVirt; // 18 + uint32_t restore1PageCount; // 20 + 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; + +struct IOHibernateImageHeaderSnow +{ uint64_t imageSize; uint64_t image1Size; - uint32_t restore1CodePage; + uint32_t restore1CodePhysPage; uint32_t restore1PageCount; uint32_t restore1CodeOffset; @@ -94,9 +173,22 @@ uint32_t fileExtentMapSize; IOPolledFileExtent fileExtentMap[2]; }; -typedef struct IOHibernateImageHeader IOHibernateImageHeader; +typedef struct IOHibernateImageHeaderSnow IOHibernateImageHeaderSnow; +enum +{ + kIOHibernateDebugRestoreLogs = 0x00000001 +}; +// options & IOHibernateOptions property +enum +{ + kIOHibernateOptionSSD = 0x00000001, + kIOHibernateOptionColor = 0x00000002, + kIOHibernateOptionProgress = 0x00000004, + kIOHibernateOptionDarkWake = 0x00000008, +}; + struct hibernate_bitmap_t { uint32_t first_page; @@ -132,9 +224,28 @@ #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, +}; -enum +struct IOHibernateHandoff { + uint32_t type; + uint32_t bytecount; + uint8_t data[]; +}; +typedef struct IOHibernateHandoff IOHibernateHandoff; + +enum +{ kIOHibernateProgressCount = 19, kIOHibernateProgressWidth = 7, kIOHibernateProgressHeight = 16, @@ -159,7 +270,8 @@ struct hibernate_graphics_t { - uint32_t physicalAddress; // Base address of video memory + uint32_t physicalAddress; // Base address of video memory + int32_t gfxStatus; // EFI config restore status uint32_t mode; // uint32_t rowBytes; // Number of bytes per pixel row uint32_t width; // Width @@ -192,6 +304,51 @@ { 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 @@ -199,9 +356,14 @@ void IOHibernateSystemInit(IOPMrootDomain * rootDomain); IOReturn IOHibernateSystemSleep(void); +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 */ @@ -209,37 +371,64 @@ 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, - kern_get_file_extents_callback_t callback, - void * callback_ref, - dev_t * device, - uint64_t * partitionbase_result, - uint64_t * maxiocount_result); +kern_open_file_for_direct_io(const char * name, + kern_get_file_extents_callback_t callback, + void * callback_ref, + + off_t set_file_size, + + off_t write_file_offset, + caddr_t write_file_addr, + vm_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); -int -kern_write_file(struct kern_direct_file_io_ref_t * ref, off_t offset, caddr_t addr, vm_size_t len); -int get_kernel_symfile(struct proc *p, char const **symfile); +kern_close_file_for_direct_io(struct kern_direct_file_io_ref_t * ref, + off_t write_offset, caddr_t addr, vm_size_t write_length, + off_t discard_offset, off_t discard_end); #endif /* _SYS_CONF_H_ */ hibernate_page_list_t * -hibernate_page_list_allocate(void); +hibernate_page_list_allocate(boolean_t log); -kern_return_t +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, - uint32_t free_page_ratio, - uint32_t free_page_time, - hibernate_page_list_t ** page_list_ret, - hibernate_page_list_t ** page_list_wired_ret, - boolean_t * encryptedswap); -kern_return_t + uint32_t free_page_ratio, + uint32_t free_page_time, + 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_wired, + hibernate_page_list_t * page_list_pal); -kern_return_t +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); @@ -248,13 +437,17 @@ 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 +// 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 @@ -266,6 +459,9 @@ 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); @@ -282,7 +478,7 @@ uint32_t hibernate_page_bitmap_count(hibernate_bitmap_t * bitmap, uint32_t set, uint32_t page); -void +uintptr_t hibernate_restore_phys_page(uint64_t src, uint64_t dst, uint32_t len, uint32_t procFlags); void @@ -292,9 +488,9 @@ hibernate_write_image(void); long -hibernate_machine_entrypoint(IOHibernateImageHeader * header, void * p2, void * p3, void * p4); +hibernate_machine_entrypoint(uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4); long -hibernate_kernel_entrypoint(IOHibernateImageHeader * header, void * p2, void * p3, void * p4); +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); @@ -302,6 +498,7 @@ 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[]; @@ -310,50 +507,54 @@ extern hibernate_cryptwakevars_t * gIOHibernateCryptWakeVars; #define HIBLOG(fmt, args...) \ - { kprintf(fmt, ## args); printf(fmt, ## args); } + { kprintf(fmt, ## args); printf(fmt, ## args); } #define HIBPRINT(fmt, args...) \ - { kprintf(fmt, ## args); } + { kprintf(fmt, ## args); } #endif /* KERNEL */ // gIOHibernateState, kIOHibernateStateKey enum { - kIOHibernateStateInactive = 0, - kIOHibernateStateHibernating = 1, /* writing image */ - kIOHibernateStateWakingFromHibernate = 2 /* booted and restored image */ + 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 + 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 + kIOHibernateHeaderSignature = 0x73696d65, + kIOHibernateHeaderInvalidSignature = 0x7a7a7a7a }; // kind for hibernate_set_page_state() enum { - kIOHibernatePageStateFree = 0, - kIOHibernatePageStateWiredSave = 1, - kIOHibernatePageStateUnwiredSave = 2 + 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" @@ -361,13 +562,21 @@ #define kIOHibernateFeatureKey "Hibernation" #define kIOHibernatePreviewBufferKey "IOPreviewBuffer" +#ifndef kIOHibernatePreviewActiveKey #define kIOHibernatePreviewActiveKey "IOHibernatePreviewActive" // values for kIOHibernatePreviewActiveKey enum { - kIOHibernatePreviewActive = 0x00000001, - kIOHibernatePreviewUpdates = 0x00000002 + 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" @@ -377,10 +586,31 @@ #define kIOHibernateMachineSignatureKey "machine-signature" #define kIOHibernateRTCVariablesKey "IOHibernateRTCVariables" +#define kIOHibernateSMCVariablesKey "IOHibernateSMCVariables" -#define kIOHibernateBootSwitchVarsKey "boot-switch-vars" +#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