iokit/IOKit/IOHibernatePrivate.h

   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 #include <stdint.h>
  30
  31 #ifdef __cplusplus
  32 extern "C" {
  33 #endif
  34
  35 #ifdef KERNEL
  36 #include <crypto/aes.h>
  37 #endif
  38
  39 struct IOPolledFileExtent
  40 {
  41     uint64_t    start;
  42     uint64_t    length;
  43 };
  44 typedef struct IOPolledFileExtent IOPolledFileExtent;
  45
  46 struct IOHibernateImageHeader
  47 {
  48     uint64_t    imageSize;
  49     uint64_t    image1Size;
  50
  51     uint32_t    restore1CodePage;
  52     uint32_t    restore1PageCount;
  53     uint32_t    restore1CodeOffset;
  54     uint32_t    restore1StackOffset;
  55
  56     uint32_t    pageCount;
  57     uint32_t    bitmapSize;
  58
  59     uint32_t    restore1Sum;
  60     uint32_t    image1Sum;
  61     uint32_t    image2Sum;
  62
  63     uint32_t    actualRestore1Sum;
  64     uint32_t    actualImage1Sum;
  65     uint32_t    actualImage2Sum;
  66
  67     uint32_t    actualUncompressedPages;
  68     uint32_t    conflictCount;
  69     uint32_t    nextFree;
  70
  71     uint32_t    signature;
  72     uint32_t    processorFlags;
  73
  74     uint32_t    runtimePages;
  75     uint32_t    runtimePageCount;
  76     uint64_t    runtimeVirtualPages __attribute__ ((packed));
  77
  78     uint32_t    performanceDataStart;
  79     uint32_t    performanceDataSize;
  80
  81     uint64_t    encryptStart __attribute__ ((packed));
  82     uint64_t    machineSignature __attribute__ ((packed));
  83
  84     uint32_t    previewSize;
  85     uint32_t    previewPageListSize;
  86
  87     uint32_t    diag[4];
  88
  89     int32_t     graphicsInfoOffset;
  90     int32_t     cryptVarsOffset;
  91     int32_t     memoryMapOffset;
  92     uint32_t    memoryMapSize;
  93     uint32_t    systemTableOffset;
  94
  95     uint32_t    debugFlags;
  96     uint32_t    options;
  97
  98     uint32_t    reserved[71];           // make sizeof == 512
  99
 100     uint64_t    encryptEnd __attribute__ ((packed));
 101     uint64_t    deviceBase __attribute__ ((packed));
 102
 103     uint32_t            fileExtentMapSize;
 104     IOPolledFileExtent  fileExtentMap[2];
 105 };
 106 typedef struct IOHibernateImageHeader IOHibernateImageHeader;
 107
 108 enum
 109 {
 110     kIOHibernateDebugRestoreLogs = 0x00000001
 111 };
 112
 113 // options & IOHibernateOptions property
 114 enum
 115 {
 116     kIOHibernateOptionSSD           = 0x00000001,
 117     kIOHibernateOptionColor         = 0x00000002,
 118     kIOHibernateOptionProgress      = 0x00000004,
 119     kIOHibernateOptionDarkWake      = 0x00000008,
 120 };
 121
 122 struct hibernate_bitmap_t
 123 {
 124     uint32_t    first_page;
 125     uint32_t    last_page;
 126     uint32_t    bitmapwords;
 127     uint32_t    bitmap[0];
 128 };
 129 typedef struct hibernate_bitmap_t hibernate_bitmap_t;
 130
 131 struct hibernate_page_list_t
 132 {
 133     uint32_t              list_size;
 134     uint32_t              page_count;
 135     uint32_t              bank_count;
 136     hibernate_bitmap_t    bank_bitmap[0];
 137 };
 138 typedef struct hibernate_page_list_t hibernate_page_list_t;
 139
 140 #if defined(_AES_H)
 141
 142 struct hibernate_cryptwakevars_t
 143 {
 144     uint8_t aes_iv[AES_BLOCK_SIZE];
 145 };
 146 typedef struct hibernate_cryptwakevars_t hibernate_cryptwakevars_t;
 147
 148 struct hibernate_cryptvars_t
 149 {
 150     uint8_t aes_iv[AES_BLOCK_SIZE];
 151     aes_ctx ctx;
 152 };
 153 typedef struct hibernate_cryptvars_t hibernate_cryptvars_t;
 154
 155 #endif /* defined(_AES_H) */
 156
 157
 158 enum
 159 {
 160     kIOHibernateProgressCount         = 19,
 161     kIOHibernateProgressWidth         = 7,
 162     kIOHibernateProgressHeight        = 16,
 163     kIOHibernateProgressSpacing       = 3,
 164     kIOHibernateProgressOriginY       = 81,
 165
 166     kIOHibernateProgressSaveUnderSize = 2*5+14*2,
 167
 168     kIOHibernateProgressLightGray     = 230,
 169     kIOHibernateProgressMidGray       = 174,
 170     kIOHibernateProgressDarkGray      = 92
 171 };
 172
 173 enum
 174 {
 175     kIOHibernatePostWriteSleep   = 0,
 176     kIOHibernatePostWriteWake    = 1,
 177     kIOHibernatePostWriteHalt    = 2,
 178     kIOHibernatePostWriteRestart = 3
 179 };
 180
 181
 182 struct hibernate_graphics_t
 183 {
 184     uint32_t physicalAddress;   // Base address of video memory
 185     int32_t  gfxStatus;         // EFI config restore status
 186     uint32_t rowBytes;                  // Number of bytes per pixel row
 187     uint32_t width;                     // Width
 188     uint32_t height;                    // Height
 189     uint32_t depth;                     // Pixel Depth
 190
 191     uint8_t progressSaveUnder[kIOHibernateProgressCount][kIOHibernateProgressSaveUnderSize];
 192 };
 193 typedef struct hibernate_graphics_t hibernate_graphics_t;
 194
 195 #define DECLARE_IOHIBERNATEPROGRESSALPHA                                \
 196 static const uint8_t gIOHibernateProgressAlpha                  \
 197 [kIOHibernateProgressHeight][kIOHibernateProgressWidth] =       \
 198 {                                                               \
 199     { 0x00,0x63,0xd8,0xf0,0xd8,0x63,0x00 },                     \
 200     { 0x51,0xff,0xff,0xff,0xff,0xff,0x51 },                     \
 201     { 0xae,0xff,0xff,0xff,0xff,0xff,0xae },                     \
 202     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 203     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 204     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 205     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 206     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 207     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 208     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 209     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 210     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 211     { 0xc3,0xff,0xff,0xff,0xff,0xff,0xc3 },                     \
 212     { 0xae,0xff,0xff,0xff,0xff,0xff,0xae },                     \
 213     { 0x54,0xff,0xff,0xff,0xff,0xff,0x54 },                     \
 214     { 0x00,0x66,0xdb,0xf3,0xdb,0x66,0x00 }                      \
 215 };
 216
 217 #ifdef KERNEL
 218
 219 #ifdef __cplusplus
 220
 221 void     IOHibernateSystemInit(IOPMrootDomain * rootDomain);
 222
 223 IOReturn IOHibernateSystemSleep(void);
 224 IOReturn IOHibernateSystemHasSlept(void);
 225 IOReturn IOHibernateSystemWake(void);
 226 IOReturn IOHibernateSystemPostWake(void);
 227
 228 #endif /* __cplusplus */
 229
 230 #ifdef _SYS_CONF_H_
 231 typedef void (*kern_get_file_extents_callback_t)(void * ref, uint64_t start, uint64_t size);
 232
 233 struct kern_direct_file_io_ref_t *
 234 kern_open_file_for_direct_io(const char * name,
 235                              kern_get_file_extents_callback_t callback,
 236                              void *      callback_ref,
 237                              dev_t *     device_result,
 238                              uint64_t *  partitionbase_result,
 239                              uint64_t *  maxiocount_result,
 240                              boolean_t * solid_state);
 241
 242
 243 void
 244 kern_close_file_for_direct_io(struct kern_direct_file_io_ref_t * ref);
 245 int
 246 kern_write_file(struct kern_direct_file_io_ref_t * ref, off_t offset, caddr_t addr, vm_size_t len);
 247 int get_kernel_symfile(struct proc *p, char const **symfile);
 248 #endif /* _SYS_CONF_H_ */
 249
 250 hibernate_page_list_t *
 251 hibernate_page_list_allocate(void);
 252
 253 kern_return_t
 254 hibernate_setup(IOHibernateImageHeader * header,
 255                         uint32_t  free_page_ratio,
 256                         uint32_t  free_page_time,
 257                         boolean_t vmflush,
 258                         hibernate_page_list_t ** page_list_ret,
 259                         hibernate_page_list_t ** page_list_wired_ret,
 260                         boolean_t * encryptedswap);
 261 kern_return_t
 262 hibernate_teardown(hibernate_page_list_t * page_list,
 263                     hibernate_page_list_t * page_list_wired);
 264
 265 kern_return_t
 266 hibernate_processor_setup(IOHibernateImageHeader * header);
 267
 268 void
 269 hibernate_gobble_pages(uint32_t gobble_count, uint32_t free_page_time);
 270 void
 271 hibernate_free_gobble_pages(void);
 272
 273 void
 274 hibernate_vm_lock(void);
 275 void
 276 hibernate_vm_unlock(void);
 277
 278 // mark pages not to be saved, based on VM system accounting
 279 void
 280 hibernate_page_list_setall(hibernate_page_list_t * page_list,
 281                            hibernate_page_list_t * page_list_wired,
 282                            uint32_t * pagesOut);
 283
 284 // mark pages to be saved, or pages not to be saved but available
 285 // for scratch usage during restore
 286 void
 287 hibernate_page_list_setall_machine(hibernate_page_list_t * page_list,
 288                                     hibernate_page_list_t * page_list_wired,
 289                                     uint32_t * pagesOut);
 290
 291 // mark pages not to be saved and not for scratch usage during restore
 292 void
 293 hibernate_page_list_set_volatile( hibernate_page_list_t * page_list,
 294                                   hibernate_page_list_t * page_list_wired,
 295                                   uint32_t * pagesOut);
 296
 297 void
 298 hibernate_page_list_discard(hibernate_page_list_t * page_list);
 299
 300 int
 301 hibernate_should_abort(void);
 302
 303 void
 304 hibernate_set_page_state(hibernate_page_list_t * page_list, hibernate_page_list_t * page_list_wired,
 305                                 vm_offset_t ppnum, vm_offset_t count, uint32_t kind);
 306
 307 void
 308 hibernate_page_bitset(hibernate_page_list_t * list, boolean_t set, uint32_t page);
 309
 310 boolean_t
 311 hibernate_page_bittst(hibernate_page_list_t * list, uint32_t page);
 312
 313 hibernate_bitmap_t *
 314 hibernate_page_bitmap_pin(hibernate_page_list_t * list, uint32_t * page);
 315
 316 uint32_t
 317 hibernate_page_bitmap_count(hibernate_bitmap_t * bitmap, uint32_t set, uint32_t page);
 318
 319 void
 320 hibernate_restore_phys_page(uint64_t src, uint64_t dst, uint32_t len, uint32_t procFlags);
 321
 322 void
 323 hibernate_machine_init(void);
 324
 325 uint32_t
 326 hibernate_write_image(void);
 327
 328 long
 329 hibernate_machine_entrypoint(IOHibernateImageHeader * header, void * p2, void * p3, void * p4);
 330 long
 331 hibernate_kernel_entrypoint(IOHibernateImageHeader * header, void * p2, void * p3, void * p4);
 332 void
 333 hibernate_newruntime_map(void * map, vm_size_t map_size,
 334                             uint32_t system_table_offset);
 335
 336
 337 extern uint32_t    gIOHibernateState;
 338 extern uint32_t    gIOHibernateMode;
 339 extern uint32_t    gIOHibernateDebugFlags;
 340 extern uint32_t    gIOHibernateFreeTime;        // max time to spend freeing pages (ms)
 341 extern uint8_t     gIOHibernateRestoreStack[];
 342 extern uint8_t     gIOHibernateRestoreStackEnd[];
 343 extern IOHibernateImageHeader *    gIOHibernateCurrentHeader;
 344 extern hibernate_graphics_t *      gIOHibernateGraphicsInfo;
 345 extern hibernate_cryptwakevars_t * gIOHibernateCryptWakeVars;
 346
 347 #define HIBLOG(fmt, args...)    \
 348     { kprintf(fmt, ## args); printf(fmt, ## args); }
 349
 350 #define HIBPRINT(fmt, args...)  \
 351     { kprintf(fmt, ## args); }
 352
 353 #endif /* KERNEL */
 354
 355 // gIOHibernateState, kIOHibernateStateKey
 356 enum
 357 {
 358     kIOHibernateStateInactive            = 0,
 359     kIOHibernateStateHibernating         = 1,   /* writing image */
 360     kIOHibernateStateWakingFromHibernate = 2    /* booted and restored image */
 361 };
 362
 363 // gIOHibernateMode, kIOHibernateModeKey
 364 enum
 365 {
 366     kIOHibernateModeOn      = 0x00000001,
 367     kIOHibernateModeSleep   = 0x00000002,
 368     kIOHibernateModeEncrypt = 0x00000004,
 369     kIOHibernateModeDiscardCleanInactive = 0x00000008,
 370     kIOHibernateModeDiscardCleanActive   = 0x00000010,
 371     kIOHibernateModeSwitch      = 0x00000020,
 372     kIOHibernateModeRestart     = 0x00000040,
 373     kIOHibernateModeSSDInvert   = 0x00000080,
 374 };
 375
 376 // IOHibernateImageHeader.signature
 377 enum
 378 {
 379     kIOHibernateHeaderSignature        = 0x73696d65,
 380     kIOHibernateHeaderInvalidSignature = 0x7a7a7a7a
 381 };
 382
 383 // kind for hibernate_set_page_state()
 384 enum
 385 {
 386     kIOHibernatePageStateFree        = 0,
 387     kIOHibernatePageStateWiredSave   = 1,
 388     kIOHibernatePageStateUnwiredSave = 2
 389 };
 390
 391 #define kIOHibernateModeKey             "Hibernate Mode"
 392 #define kIOHibernateFileKey             "Hibernate File"
 393 #define kIOHibernateFreeRatioKey        "Hibernate Free Ratio"
 394 #define kIOHibernateFreeTimeKey         "Hibernate Free Time"
 395
 396 #define kIOHibernateStateKey            "IOHibernateState"
 397 #define kIOHibernateFeatureKey          "Hibernation"
 398 #define kIOHibernatePreviewBufferKey    "IOPreviewBuffer"
 399
 400 #define kIOHibernatePreviewActiveKey    "IOHibernatePreviewActive"
 401 // values for kIOHibernatePreviewActiveKey
 402 enum {
 403     kIOHibernatePreviewActive  = 0x00000001,
 404     kIOHibernatePreviewUpdates = 0x00000002
 405 };
 406
 407 #define kIOHibernateOptionsKey      "IOHibernateOptions"
 408 #define kIOHibernateGfxStatusKey    "IOHibernateGfxStatus"
 409 enum {
 410     kIOHibernateGfxStatusUnknown = ((int32_t) 0xFFFFFFFF)
 411 };
 412
 413 #define kIOHibernateBootImageKey        "boot-image"
 414 #define kIOHibernateBootImageKeyKey     "boot-image-key"
 415 #define kIOHibernateBootSignatureKey    "boot-signature"
 416
 417 #define kIOHibernateMemorySignatureKey    "memory-signature"
 418 #define kIOHibernateMemorySignatureEnvKey "mem-sig"
 419 #define kIOHibernateMachineSignatureKey   "machine-signature"
 420
 421 #define kIOHibernateRTCVariablesKey     "IOHibernateRTCVariables"
 422
 423 #define kIOHibernateBootSwitchVarsKey                   "boot-switch-vars"
 424
 425
 426 #ifdef __cplusplus
 427 }
 428 #endif