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