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
57extern 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
63struct IOHibernateHibSegment {
64 uint32_t iBootMemoryRegion;
65 uint32_t physPage;
66 uint32_t pageCount;
67 uint32_t protection;
68};
69typedef struct IOHibernateHibSegment IOHibernateHibSegment;
70
71#define NUM_HIBSEGINFO_SEGMENTS 10
72struct IOHibernateHibSegInfo {
73 struct IOHibernateHibSegment segments[NUM_HIBSEGINFO_SEGMENTS];
74 uint8_t hmac[HIBERNATE_HMAC_SIZE];
75};
76typedef struct IOHibernateHibSegInfo IOHibernateHibSegInfo;
77
78struct IOPolledFileExtent {
79 uint64_t start;
80 uint64_t length;
81};
82typedef struct IOPolledFileExtent IOPolledFileExtent;
83
84struct 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};
178typedef struct IOHibernateImageHeader IOHibernateImageHeader;
179
180enum{
181 kIOHibernateDebugRestoreLogs = 0x00000001
182};
183
184// options & IOHibernateOptions property
185enum{
186 kIOHibernateOptionSSD = 0x00000001,
187 kIOHibernateOptionColor = 0x00000002,
188 kIOHibernateOptionProgress = 0x00000004,
189 kIOHibernateOptionDarkWake = 0x00000008,
190 kIOHibernateOptionHWEncrypt = 0x00000010,
191};
192
193struct hibernate_bitmap_t {
194 uint32_t first_page;
195 uint32_t last_page;
196 uint32_t bitmapwords;
197 uint32_t bitmap[0];
198};
199typedef struct hibernate_bitmap_t hibernate_bitmap_t;
200
201struct 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};
207typedef struct hibernate_page_list_t hibernate_page_list_t;
208
209#if defined(_AES_H)
210
211struct hibernate_cryptwakevars_t {
212 uint8_t aes_iv[AES_BLOCK_SIZE];
213};
214typedef struct hibernate_cryptwakevars_t hibernate_cryptwakevars_t;
215
216struct hibernate_cryptvars_t {
217 uint8_t aes_iv[AES_BLOCK_SIZE];
218 aes_ctx ctx;
219};
220typedef struct hibernate_cryptvars_t hibernate_cryptvars_t;
221
222#endif /* defined(_AES_H) */
223
224enum{
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
236struct IOHibernateHandoff {
237 uint32_t type;
238 uint32_t bytecount;
239 uint8_t data[];
240};
241typedef struct IOHibernateHandoff IOHibernateHandoff;
242
243enum{
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
257enum{
258 kIOHibernatePostWriteSleep = 0,
259 kIOHibernatePostWriteWake = 1,
260 kIOHibernatePostWriteHalt = 2,
261 kIOHibernatePostWriteRestart = 3
262};
263
264
265struct 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};
275typedef struct hibernate_graphics_t hibernate_graphics_t;
276
277#define DECLARE_IOHIBERNATEPROGRESSALPHA \
278static 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
299struct 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};
308typedef struct hibernate_preview_t hibernate_preview_t;
309
310struct 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};
335typedef 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
351void IOHibernateSystemInit(IOPMrootDomain * rootDomain);
352
353IOReturn IOHibernateSystemSleep(void);
354IOReturn IOHibernateIOKitSleep(void);
355IOReturn IOHibernateSystemHasSlept(void);
356IOReturn IOHibernateSystemWake(void);
357IOReturn IOHibernateSystemPostWake(bool now);
358uint32_t IOHibernateWasScreenLocked(void);
359void IOHibernateSetScreenLocked(uint32_t lockState);
360void IOHibernateSetWakeCapabilities(uint32_t capability);
361void IOHibernateSystemRestart(void);
362
363#endif /* __cplusplus */
364
365struct 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};
374typedef struct hibernate_scratch hibernate_scratch_t;
375
376void
377vm_compressor_do_warmup(void);
378
379
380hibernate_page_list_t *
381hibernate_page_list_allocate(boolean_t log);
382
383kern_return_t
384hibernate_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
389kern_return_t
390hibernate_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
396kern_return_t
397hibernate_teardown(hibernate_page_list_t * page_list,
398 hibernate_page_list_t * page_list_wired,
399 hibernate_page_list_t * page_list_pal);
400
401kern_return_t
402hibernate_pin_swap(boolean_t begin);
403
404kern_return_t
405hibernate_processor_setup(IOHibernateImageHeader * header);
406
407void
408hibernate_gobble_pages(uint32_t gobble_count, uint32_t free_page_time);
409void
410hibernate_free_gobble_pages(void);
411
412void
413hibernate_vm_lock_queues(void);
414void
415hibernate_vm_unlock_queues(void);
416
417void
418hibernate_vm_lock(void);
419void
420hibernate_vm_unlock(void);
421void
422hibernate_vm_lock_end(void);
423boolean_t
424hibernate_vm_locks_are_safe(void);
425
426// mark pages not to be saved, based on VM system accounting
427void
428hibernate_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
437void
438hibernate_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
444void
445hibernate_page_list_set_volatile( hibernate_page_list_t * page_list,
446 hibernate_page_list_t * page_list_wired,
447 uint32_t * pagesOut);
448
449void
450hibernate_page_list_discard(hibernate_page_list_t * page_list);
451
452int
453hibernate_should_abort(void);
454
455void
456hibernate_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
459void
460hibernate_page_bitset(hibernate_page_list_t * list, boolean_t set, uint32_t page);
461
462boolean_t
463hibernate_page_bittst(hibernate_page_list_t * list, uint32_t page);
464
465hibernate_bitmap_t *
466hibernate_page_bitmap_pin(hibernate_page_list_t * list, uint32_t * page);
467
468uint32_t
469hibernate_page_bitmap_count(hibernate_bitmap_t * bitmap, uint32_t set, uint32_t page);
470
471uintptr_t
472hibernate_restore_phys_page(uint64_t src, uint64_t dst, uint32_t len, uint32_t procFlags);
473
474void
475hibernate_scratch_init(hibernate_scratch_t * scratch, hibernate_page_list_t * map, uint32_t * nextFree);
476
477void
478hibernate_scratch_start_read(hibernate_scratch_t * scratch);
479
480void
481hibernate_scratch_write(hibernate_scratch_t * scratch, const void * buffer, size_t size);
482
483void
484hibernate_scratch_read(hibernate_scratch_t * scratch, void * buffer, size_t size);
485
486void
487hibernate_machine_init(void);
488
489uint32_t
490hibernate_write_image(void);
491
492ppnum_t
493hibernate_page_list_grab(hibernate_page_list_t * list, uint32_t * pNextFree);
494
495void
496hibernate_reserve_restore_pages(uint64_t headerPhys, IOHibernateImageHeader *header, hibernate_page_list_t * map);
497
498long
499hibernate_machine_entrypoint(uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4);
500long
501hibernate_kernel_entrypoint(uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4);
502void
503hibernate_newruntime_map(void * map, vm_size_t map_size,
504 uint32_t system_table_offset);
505
506
507extern uint32_t gIOHibernateState;
508extern uint32_t gIOHibernateMode;
509extern uint32_t gIOHibernateDebugFlags;
510extern uint32_t gIOHibernateFreeTime; // max time to spend freeing pages (ms)
511extern boolean_t gIOHibernateStandbyDisabled;
512#if !defined(__arm64__)
513extern uint8_t gIOHibernateRestoreStack[];
514extern uint8_t gIOHibernateRestoreStackEnd[];
515#endif /* !defined(__arm64__) */
516extern 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
531enum{
532 kIOHibernateStateInactive = 0,
533 kIOHibernateStateHibernating = 1,/* writing image */
534 kIOHibernateStateWakingFromHibernate = 2 /* booted and restored image */
535};
536
537// gIOHibernateMode, kIOHibernateModeKey
538enum{
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
551enum{
552 kIOHibernateHeaderSignature = 0x73696d65U,
553 kIOHibernateHeaderInvalidSignature = 0x7a7a7a7aU,
554 kIOHibernateHeaderOpenSignature = 0xf1e0be9dU,
555 kIOHibernateHeaderDebugDataSignature = 0xfcddfcddU
556};
557
558// kind for hibernate_set_page_state()
559enum{
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
579enum {
580 kIOHibernatePreviewActive = 0x00000001,
581 kIOHibernatePreviewUpdates = 0x00000002
582};
583#endif
584
585#define kIOHibernateOptionsKey "IOHibernateOptions"
586#define kIOHibernateGfxStatusKey "IOHibernateGfxStatus"
587enum {
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
609enum{
610 kIOPreviewImageIndexDesktop = 0,
611 kIOPreviewImageIndexLockScreen = 1,
612 kIOPreviewImageCount = 2
613};
614
615enum{
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 */
630