]> git.saurik.com Git - apple/xnu.git/blobdiff - iokit/Kernel/IOHibernateRestoreKernel.c
projects / apple / xnu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xnu-1504.15.3.tar.gz
[apple/xnu.git] / iokit / Kernel / IOHibernateRestoreKernel.c
diff --git a/iokit/Kernel/IOHibernateRestoreKernel.c b/iokit/Kernel/IOHibernateRestoreKernel.c
index 16d60cb0516c9d7c2f16f5620297f0e0a5f4d345..280b8c430797371ea82b92a295faa70cff71f22d 100644 (file)
--- a/iokit/Kernel/IOHibernateRestoreKernel.c
+++ b/iokit/Kernel/IOHibernateRestoreKernel.c
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2004-2006 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
@@ -30,8 +30,10 @@
 #include <mach/mach_types.h>
 #include <mach/vm_param.h>
 #include <IOKit/IOHibernatePrivate.h>
 #include <mach/mach_types.h>
 #include <mach/vm_param.h>
 #include <IOKit/IOHibernatePrivate.h>
+#include <IOKit/IOLib.h>
 #include <pexpert/boot.h>
 #include <crypto/aes.h>
 #include <pexpert/boot.h>
 #include <crypto/aes.h>
+#include <libkern/libkern.h>
 
 #include "WKdm.h"
 #include "IOHibernateInternal.h"
 
 #include "WKdm.h"
 #include "IOHibernateInternal.h"
@@ -45,6 +47,8 @@ it calls or references needs to be careful to only touch memory also in the "__H
 
 uint32_t gIOHibernateState;
 
 
 uint32_t gIOHibernateState;
 
+uint32_t gIOHibernateDebugFlags;
+
 static IOHibernateImageHeader _hibernateHeader;
 IOHibernateImageHeader * gIOHibernateCurrentHeader = &_hibernateHeader;
 
 static IOHibernateImageHeader _hibernateHeader;
 IOHibernateImageHeader * gIOHibernateCurrentHeader = &_hibernateHeader;
 
@@ -54,73 +58,171 @@ hibernate_graphics_t * gIOHibernateGraphicsInfo = &_hibernateGraphics;
 static hibernate_cryptwakevars_t _cryptWakeVars;
 hibernate_cryptwakevars_t * gIOHibernateCryptWakeVars = &_cryptWakeVars;
 
 static hibernate_cryptwakevars_t _cryptWakeVars;
 hibernate_cryptwakevars_t * gIOHibernateCryptWakeVars = &_cryptWakeVars;
 
-#if __i386__
-extern void   acpi_wake_prot_entry(void);
-#endif
+vm_offset_t gIOHibernateWakeMap;           // ppnum
+vm_size_t   gIOHibernateWakeMapSize;
 
 
 
 
+#if CONFIG_SLEEP
+#if defined(__i386__) || defined(__x86_64__)
+extern void acpi_wake_prot_entry(void);
+#endif
+#endif
+
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#define BASE 65521L /* largest prime smaller than 65536 */
-#define NMAX 5000  
-// NMAX (was 5521) the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+#if defined(__i386__) || defined(__x86_64__)
+
+#define DBGLOG 1
+
+#include <architecture/i386/pio.h>
+
+/* standard port addresses */
+enum {
+    COM1_PORT_ADDR = 0x3f8,
+    COM2_PORT_ADDR = 0x2f8
+};
+
+/* UART register offsets */
+enum {
+    UART_RBR = 0,  /* receive buffer Register   (R) */
+    UART_THR = 0,  /* transmit holding register (W) */
+    UART_DLL = 0,  /* DLAB = 1, divisor latch (LSB) */
+    UART_IER = 1,  /* interrupt enable register     */
+    UART_DLM = 1,  /* DLAB = 1, divisor latch (MSB) */
+    UART_IIR = 2,  /* interrupt ident register (R)  */
+    UART_FCR = 2,  /* fifo control register (W)     */
+    UART_LCR = 3,  /* line control register         */
+    UART_MCR = 4,  /* modem control register        */
+    UART_LSR = 5,  /* line status register          */
+    UART_MSR = 6,  /* modem status register         */
+    UART_SCR = 7   /* scratch register              */
+};
+
+enum {
+    UART_LCR_8BITS = 0x03,
+    UART_LCR_DLAB  = 0x80
+};
+
+enum {
+    UART_MCR_DTR   = 0x01,
+    UART_MCR_RTS   = 0x02,
+    UART_MCR_OUT1  = 0x04,
+    UART_MCR_OUT2  = 0x08,
+    UART_MCR_LOOP  = 0x10
+};
+
+enum {
+    UART_LSR_DR    = 0x01,
+    UART_LSR_OE    = 0x02,
+    UART_LSR_PE    = 0x04,
+    UART_LSR_FE    = 0x08,
+    UART_LSR_THRE  = 0x20
+};
+
+static void uart_putc(char c)
+{
+    while (!(inb(COM1_PORT_ADDR + UART_LSR) & UART_LSR_THRE))
+       {}
+    outb(COM1_PORT_ADDR + UART_THR, c);
+}
 
 
-#define DO1(buf,i)  {s1 += buf[i]; s2 += s1;}
-#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
-#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
-#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
-#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+static int debug_probe( void )
+{
+    /* Verify that the Scratch Register is accessible */
+    outb(COM1_PORT_ADDR + UART_SCR, 0x5a);
+    if (inb(COM1_PORT_ADDR + UART_SCR) != 0x5a) return false;
+    outb(COM1_PORT_ADDR + UART_SCR, 0xa5);
+    if (inb(COM1_PORT_ADDR + UART_SCR) != 0xa5) return false;
+    uart_putc('\n');
+    return true;
+}
 
 
-uint32_t
-hibernate_sum(uint8_t *buf, int32_t len)
+static void uart_puthex(uint64_t num)
 {
 {
-    unsigned long s1 = 1; // adler & 0xffff;
-    unsigned long s2 = 0; // (adler >> 16) & 0xffff;
-    int k;
-
-    while (len > 0) {
-        k = len < NMAX ? len : NMAX;
-        len -= k;
-        while (k >= 16) {
-            DO16(buf);
-           buf += 16;
-            k -= 16;
-        }
-        if (k != 0) do {
-            s1 += *buf++;
-           s2 += s1;
-        } while (--k);
-        s1 %= BASE;
-        s2 %= BASE;
+    int bit;
+    char c;
+    bool leading = true;
+
+    for (bit = 60; bit >= 0; bit -= 4)
+    {
+       c = 0xf & (num >> bit);
+       if (c)
+           leading = false;
+       else if (leading)
+           continue;
+       if (c <= 9)
+           c += '0';
+       else
+           c+= 'a' - 10;
+       uart_putc(c);
     }
     }
-    return (s2 << 16) | s1;
 }
 
 }
 
+static void debug_code(uint32_t code, uint64_t value)
+{
+    int bit;
+    char c;
+
+    if (!(kIOHibernateDebugRestoreLogs & gIOHibernateDebugFlags))
+       return;
+
+    for (bit = 24; bit >= 0; bit -= 8)
+    {
+       c = 0xFF & (code >> bit);
+       if (c)
+           uart_putc(c);
+    }
+    uart_putc('=');
+    uart_puthex(value);
+    uart_putc('\n');
+    uart_putc('\r');
+}
+
+#endif /* defined(__i386__) || defined(__x86_64__) */
+
+#if !defined(DBGLOG)
+#define debug_probe()      (false)
+#define debug_code(c, v)    {}
+#endif
+
+enum
+{
+    kIOHibernateRestoreCodeImageStart      = 'imgS',
+    kIOHibernateRestoreCodeImageEnd        = 'imgE',
+    kIOHibernateRestoreCodePageIndexStart   = 'pgiS',
+    kIOHibernateRestoreCodePageIndexEnd            = 'pgiE',
+    kIOHibernateRestoreCodeMapStart        = 'mapS',
+    kIOHibernateRestoreCodeMapEnd          = 'mapE',
+    kIOHibernateRestoreCodeWakeMapSize     = 'wkms',
+    kIOHibernateRestoreCodeConflictPage            = 'cfpg',
+    kIOHibernateRestoreCodeConflictSource   = 'cfsr',
+    kIOHibernateRestoreCodeNoMemory         = 'nomm'
+};
+
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#if __ppc__
-static __inline__ unsigned int cntlzw(unsigned int num)
+
+static void fatal(void)
 {
 {
-  unsigned int result;
-  __asm__ volatile("cntlzw %0, %1" : "=r" (result) : "r" (num));
-  return result;
+#if defined(__i386__) || defined(__x86_64__)
+    outb(0xcf9, 6);
+#else
+    while (true) {}
+#endif
 }
 }
-#elif __i386__
-static __inline__ unsigned int cntlzw(unsigned int num)
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+uint32_t
+hibernate_sum_page(uint8_t *buf, uint32_t ppnum)
 {
 {
-    unsigned int result;
-    __asm__ volatile(  "bsrl   %1, %0\n\t"
-                       "cmovel %2, %0"
-                     : "=r" (result)
-                     : "rm" (num), "r" (63));
-    return 31 ^ result;
+    return (((uint32_t *)buf)[((PAGE_SIZE >> 2) - 1) & ppnum]);
 }
 }
-#else
-#error arch
-#endif
 
 
-void 
-hibernate_page_bitset(hibernate_page_list_t * list, boolean_t set, uint32_t page)
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+static hibernate_bitmap_t *
+hibernate_page_bitmap(hibernate_page_list_t * list, uint32_t page)
 {
     uint32_t             bank;
     hibernate_bitmap_t * bitmap = &list->bank_bitmap[0];
 {
     uint32_t             bank;
     hibernate_bitmap_t * bitmap = &list->bank_bitmap[0];
@@ -128,117 +230,133 @@ hibernate_page_bitset(hibernate_page_list_t * list, boolean_t set, uint32_t page
     for (bank = 0; bank < list->bank_count; bank++)
     {
        if ((page >= bitmap->first_page) && (page <= bitmap->last_page))
     for (bank = 0; bank < list->bank_count; bank++)
     {
        if ((page >= bitmap->first_page) && (page <= bitmap->last_page))
-       {
-           page -= bitmap->first_page;
-           if (set)
-               bitmap->bitmap[page >> 5] |= (0x80000000 >> (page & 31));
-               //setbit(page - bitmap->first_page, (int *) &bitmap->bitmap[0]);
-           else
-               bitmap->bitmap[page >> 5] &= ~(0x80000000 >> (page & 31));
-               //clrbit(page - bitmap->first_page, (int *) &bitmap->bitmap[0]);
            break;
            break;
-       }
        bitmap = (hibernate_bitmap_t *) &bitmap->bitmap[bitmap->bitmapwords];
     }
        bitmap = (hibernate_bitmap_t *) &bitmap->bitmap[bitmap->bitmapwords];
     }
+    if (bank == list->bank_count)
+       bitmap = NULL;
+       
+    return (bitmap);
 }
 
 }
 
-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 * pPage)
 {
 {
-    boolean_t           result = TRUE;
-    uint32_t             bank;
+    uint32_t             bank, page = *pPage;
     hibernate_bitmap_t * bitmap = &list->bank_bitmap[0];
 
     for (bank = 0; bank < list->bank_count; bank++)
     {
     hibernate_bitmap_t * bitmap = &list->bank_bitmap[0];
 
     for (bank = 0; bank < list->bank_count; bank++)
     {
-       if ((page >= bitmap->first_page) && (page <= bitmap->last_page))
+       if (page <= bitmap->first_page)
        {
        {
-           page -= bitmap->first_page;
-            result = (0 != (bitmap->bitmap[page >> 5] & (0x80000000 >> (page & 31))));
+           *pPage = bitmap->first_page;
            break;
        }
            break;
        }
+       if (page <= bitmap->last_page)
+           break;
        bitmap = (hibernate_bitmap_t *) &bitmap->bitmap[bitmap->bitmapwords];
     }
        bitmap = (hibernate_bitmap_t *) &bitmap->bitmap[bitmap->bitmapwords];
     }
+    if (bank == list->bank_count)
+       bitmap = NULL;
+       
+    return (bitmap);
+}
+
+void 
+hibernate_page_bitset(hibernate_page_list_t * list, boolean_t set, uint32_t page)
+{
+    hibernate_bitmap_t * bitmap;
+
+    bitmap = hibernate_page_bitmap(list, page);
+    if (bitmap)
+    {
+       page -= bitmap->first_page;
+       if (set)
+           bitmap->bitmap[page >> 5] |= (0x80000000 >> (page & 31));
+           //setbit(page - bitmap->first_page, (int *) &bitmap->bitmap[0]);
+       else
+           bitmap->bitmap[page >> 5] &= ~(0x80000000 >> (page & 31));
+           //clrbit(page - bitmap->first_page, (int *) &bitmap->bitmap[0]);
+    }
+}
+
+boolean_t 
+hibernate_page_bittst(hibernate_page_list_t * list, uint32_t page)
+{
+    boolean_t           result = TRUE;
+    hibernate_bitmap_t * bitmap;
+
+    bitmap = hibernate_page_bitmap(list, page);
+    if (bitmap)
+    {
+       page -= bitmap->first_page;
+       result = (0 != (bitmap->bitmap[page >> 5] & (0x80000000 >> (page & 31))));
+    }
     return (result);
 }
 
     return (result);
 }
 
-// count bits clear or set (set == TRUE) starting at index page.
+// count bits clear or set (set == TRUE) starting at page.
 uint32_t
 uint32_t
-hibernate_page_list_count(hibernate_page_list_t * list, uint32_t set, uint32_t page)
+hibernate_page_bitmap_count(hibernate_bitmap_t * bitmap, uint32_t set, uint32_t page)
 {
 {
-    uint32_t                   bank, count;
-    hibernate_bitmap_t *       bitmap;
+    uint32_t index, bit, bits;
+    uint32_t count;
 
 
-    bitmap = &list->bank_bitmap[0];
-    count  = 0;
+    count = 0;
 
 
-    for (bank = 0; bank < list->bank_count; bank++)
+    index = (page - bitmap->first_page) >> 5;
+    bit = (page - bitmap->first_page) & 31;
+
+    bits = bitmap->bitmap[index];
+    if (set)
+       bits = ~bits;
+    bits = (bits << bit);
+    if (bits)
+       count += __builtin_clz(bits);
+    else
     {
     {
-       // bits between banks are "set"
-       if (set && (page < bitmap->first_page))
+       count += 32 - bit;
+       while (++index < bitmap->bitmapwords)
        {
        {
-           count += bitmap->first_page - page;
-           page  = bitmap->first_page;
-       }
-       if ((page >= bitmap->first_page) && (page <= bitmap->last_page))
-       {
-           uint32_t index, bit, bits;
-       
-           index = (page - bitmap->first_page) >> 5;
-           bit = (page - bitmap->first_page) & 31;
-       
-           while (TRUE)
+           bits = bitmap->bitmap[index];
+           if (set)
+               bits = ~bits;
+           if (bits)
            {
            {
-               bits = bitmap->bitmap[index];
-               if (set)
-                   bits = ~bits;
-               bits = (bits << bit);
-               count += cntlzw(bits);
-               if (bits)
-                   break;
-               count -= bit;
-           
-               while (++index < bitmap->bitmapwords)
-               {
-                   bits = bitmap->bitmap[index];
-                   if (set)
-                       bits = ~bits;
-                   count += cntlzw(bits);
-                   if (bits)
-                       break;
-               }
-               if (bits)
-                   break;
-               if (!set)
-                   break;
-               // bits between banks are "set"
-               bank++;
-               if (bank >= list->bank_count)
-                   break;
-               count -= (bitmap->last_page + 1);
-               bitmap = (hibernate_bitmap_t *) &bitmap->bitmap[bitmap->bitmapwords];
-               count += bitmap->first_page;
-               index = 0;
-               bit = 0;                            
+               count += __builtin_clz(bits);
+               break;
            }
            }
-           break;
+           count += 32;
        }
        }
-       bitmap = (hibernate_bitmap_t *) &bitmap->bitmap[bitmap->bitmapwords];
     }
 
     return (count);
 }
 
     }
 
     return (count);
 }
 
-
-static uint32_t
-hibernate_page_list_grab(hibernate_page_list_t * map, uint32_t * _nextFree)
+static vm_offset_t
+hibernate_page_list_grab(hibernate_page_list_t * list, uint32_t * pNextFree)
 {
 {
-    uint32_t nextFree = *_nextFree;
+    uint32_t            nextFree = *pNextFree;
+    uint32_t            nextFreeInBank;
+    hibernate_bitmap_t * bitmap;
 
 
-    if (!nextFree)
-       nextFree = hibernate_page_list_count(map, 0, 0);
+    nextFreeInBank = nextFree + 1;
+    while ((bitmap = hibernate_page_bitmap_pin(list, &nextFreeInBank)))
+    {
+       nextFreeInBank += hibernate_page_bitmap_count(bitmap, FALSE, nextFreeInBank);
+       if (nextFreeInBank <= bitmap->last_page)
+       {
+           *pNextFree = nextFreeInBank;
+           break;
+       }
+    }
 
 
-    *_nextFree = nextFree + 1 + hibernate_page_list_count(map, 0, nextFree + 1);
+    if (!bitmap) 
+    {
+       debug_code(kIOHibernateRestoreCodeNoMemory, nextFree);
+       fatal();
+       nextFree = 0;
+    }
 
     return (nextFree);
 }
 
     return (nextFree);
 }
@@ -251,14 +369,8 @@ store_one_page(uint32_t procFlags, uint32_t * src, uint32_t compressedSize,
     uint32_t sum;
 
     dst = ptoa_64(ppnum);
     uint32_t sum;
 
     dst = ptoa_64(ppnum);
-#if __ppc__
     if (ppnum < 0x00100000)
     if (ppnum < 0x00100000)
-       buffer = (uint32_t *) (uint32_t) dst;
-#elif __i386__
-    if (ppnum < atop_32(0xC0000000)) {
-        buffer = (uint32_t *) (uint32_t) dst;
-    }
-#endif
+       buffer = (uint32_t *) (uintptr_t) dst;
 
     if (compressedSize != PAGE_SIZE)
     {
 
     if (compressedSize != PAGE_SIZE)
     {
@@ -266,16 +378,17 @@ store_one_page(uint32_t procFlags, uint32_t * src, uint32_t compressedSize,
        src = buffer;
     }
 
        src = buffer;
     }
 
-    sum = hibernate_sum((uint8_t *) src, PAGE_SIZE);
+    sum = hibernate_sum_page((uint8_t *) src, ppnum);
 
 
-    if (((uint64_t) (uint32_t) src) == dst)
+    if (((uint64_t) (uintptr_t) src) == dst)
        src = 0;
 
        src = 0;
 
-    hibernate_restore_phys_page((uint64_t) (uint32_t) src, dst, PAGE_SIZE, procFlags);
+    hibernate_restore_phys_page((uint64_t) (uintptr_t) src, dst, PAGE_SIZE, procFlags);
 
     return (sum);
 }
 
 
     return (sum);
 }
 
+// used only for small struct copies
 static void 
 bcopy_internal(const void *src, void *dst, uint32_t len)
 {
 static void 
 bcopy_internal(const void *src, void *dst, uint32_t len)
 {
@@ -290,11 +403,12 @@ bcopy_internal(const void *src, void *dst, uint32_t len)
     }
 }
 
     }
 }
 
+#define C_ASSERT(e) typedef char    __C_ASSERT__[(e) ? 1 : -1]
+
 long 
 hibernate_kernel_entrypoint(IOHibernateImageHeader * header, 
 long 
 hibernate_kernel_entrypoint(IOHibernateImageHeader * header, 
-                            void * p2, void * p3, __unused void * p4)
+                            void * p2, void * p3, void * p4)
 {
 {
-    typedef void (*ResetProc)(void);
     uint32_t idx;
     uint32_t * src;
     uint32_t * buffer;
     uint32_t idx;
     uint32_t * src;
     uint32_t * buffer;
@@ -315,11 +429,23 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
     uint32_t lastMapPage;
     uint32_t lastPageIndexPage;
 
     uint32_t lastMapPage;
     uint32_t lastPageIndexPage;
 
+    C_ASSERT(sizeof(IOHibernateImageHeader) == 512);
+
+    if ((kIOHibernateDebugRestoreLogs & gIOHibernateDebugFlags) && !debug_probe())
+       gIOHibernateDebugFlags &= ~kIOHibernateDebugRestoreLogs;
+
+    debug_code(kIOHibernateRestoreCodeImageStart, (uintptr_t) header);
 
     bcopy_internal(header, 
                 gIOHibernateCurrentHeader, 
                 sizeof(IOHibernateImageHeader));
 
 
     bcopy_internal(header, 
                 gIOHibernateCurrentHeader, 
                 sizeof(IOHibernateImageHeader));
 
+    if (!p2)
+    {
+       count = header->graphicsInfoOffset;
+       if (count)
+           p2 = (void *)(((uintptr_t) header) - count);
+    }
     if (p2) 
         bcopy_internal(p2, 
                 gIOHibernateGraphicsInfo, 
     if (p2) 
         bcopy_internal(p2, 
                 gIOHibernateGraphicsInfo, 
@@ -327,46 +453,72 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
     else
         gIOHibernateGraphicsInfo->physicalAddress = gIOHibernateGraphicsInfo->depth = 0;
 
     else
         gIOHibernateGraphicsInfo->physicalAddress = gIOHibernateGraphicsInfo->depth = 0;
 
+    if (!p3)
+    {
+       count = header->cryptVarsOffset;
+       if (count)
+           p3 = (void *)(((uintptr_t) header) - count);
+    }
     if (p3)
         bcopy_internal(p3, 
                 gIOHibernateCryptWakeVars, 
     if (p3)
         bcopy_internal(p3, 
                 gIOHibernateCryptWakeVars, 
-                sizeof(hibernate_cryptvars_t));
+                sizeof(hibernate_cryptwakevars_t));
 
     src = (uint32_t *)
 
     src = (uint32_t *)
-                (((uint32_t) &header->fileExtentMap[0]) 
+                (((uintptr_t) &header->fileExtentMap[0]) 
                             + header->fileExtentMapSize 
                             + ptoa_32(header->restore1PageCount));
 
     if (header->previewSize)
     {
         pageIndexSource = src;
                             + header->fileExtentMapSize 
                             + ptoa_32(header->restore1PageCount));
 
     if (header->previewSize)
     {
         pageIndexSource = src;
-        map = (hibernate_page_list_t *)(((uint32_t) pageIndexSource) + header->previewSize);
-        src = (uint32_t *) (((uint32_t) pageIndexSource) + header->previewPageListSize);
+        map = (hibernate_page_list_t *)(((uintptr_t) pageIndexSource) + header->previewSize);
+        src = (uint32_t *) (((uintptr_t) pageIndexSource) + header->previewPageListSize);
     }
     else
     {
         pageIndexSource = 0;
         map = (hibernate_page_list_t *) src;
     }
     else
     {
         pageIndexSource = 0;
         map = (hibernate_page_list_t *) src;
-        src = (uint32_t *) (((uint32_t) map) + header->bitmapSize);
+        src = (uint32_t *) (((uintptr_t) map) + header->bitmapSize);
     }
 
     }
 
-    lastPageIndexPage = atop_32(src);
+    lastPageIndexPage = atop_32((uintptr_t) src);
+
+    lastImagePage = atop_32(((uintptr_t) header) + header->image1Size);
 
 
-    lastImagePage = atop_32(((uint32_t) header) + header->image1Size);
+    lastMapPage = atop_32(((uintptr_t) map) + header->bitmapSize);
 
 
-    lastMapPage = atop_32(((uint32_t) map) + header->bitmapSize);
+    debug_code(kIOHibernateRestoreCodeImageEnd,       ptoa_64(lastImagePage));
+    debug_code(kIOHibernateRestoreCodePageIndexStart, (uintptr_t) pageIndexSource);
+    debug_code(kIOHibernateRestoreCodePageIndexEnd,   ptoa_64(lastPageIndexPage));
+    debug_code(kIOHibernateRestoreCodeMapStart,       (uintptr_t) map);
+    debug_code(kIOHibernateRestoreCodeMapEnd,         ptoa_64(lastMapPage));
 
     // knock all the image pages to be used out of free map
 
     // knock all the image pages to be used out of free map
-    for (ppnum = atop_32(header); ppnum <= lastImagePage; ppnum++)
+    for (ppnum = atop_32((uintptr_t) header); ppnum <= lastImagePage; ppnum++)
     {
        hibernate_page_bitset(map, FALSE, ppnum);
     }
 
     nextFree = 0;
     {
        hibernate_page_bitset(map, FALSE, ppnum);
     }
 
     nextFree = 0;
-    buffer = (uint32_t *) ptoa_32(hibernate_page_list_grab(map, &nextFree));
+    hibernate_page_list_grab(map, &nextFree);
+    buffer = (uint32_t *) (uintptr_t) ptoa_32(hibernate_page_list_grab(map, &nextFree));
+
+    if (header->memoryMapSize && (count = header->memoryMapOffset))
+    {
+       p4 = (void *)(((uintptr_t) header) - count);
+       gIOHibernateWakeMap     = hibernate_page_list_grab(map, &nextFree);
+       gIOHibernateWakeMapSize = header->memoryMapSize;
+       debug_code(kIOHibernateRestoreCodeWakeMapSize, gIOHibernateWakeMapSize);
+       if (gIOHibernateWakeMapSize > PAGE_SIZE)
+           fatal();
+       bcopy_internal(p4, (void  *) (uintptr_t) ptoa_32(gIOHibernateWakeMap), gIOHibernateWakeMapSize);
+    }
+    else
+       gIOHibernateWakeMapSize = 0;
 
     sum = gIOHibernateCurrentHeader->actualRestore1Sum;
 
     sum = gIOHibernateCurrentHeader->actualRestore1Sum;
-    gIOHibernateCurrentHeader->diag[0] = (uint32_t) header;
+    gIOHibernateCurrentHeader->diag[0] = (uint32_t)(uintptr_t) header;
     gIOHibernateCurrentHeader->diag[1] = sum;
 
     uncompressedPages = 0;
     gIOHibernateCurrentHeader->diag[1] = sum;
 
     uncompressedPages = 0;
@@ -387,7 +539,7 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
             if (!count)
             {
                 pageIndexSource = 0;
             if (!count)
             {
                 pageIndexSource = 0;
-                src =  (uint32_t *) (((uint32_t) map) + gIOHibernateCurrentHeader->bitmapSize);
+                src =  (uint32_t *) (((uintptr_t) map) + gIOHibernateCurrentHeader->bitmapSize);
                 ppnum = src[0];
                 count = src[1];
                 src += 2;
                 ppnum = src[0];
                 count = src[1];
                 src += 2;
@@ -413,11 +565,11 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
                 compressedSize = kIOHibernateTagLength & tag;
             }
 
                 compressedSize = kIOHibernateTagLength & tag;
             }
 
-           conflicts = (((ppnum >= atop_32(map)) && (ppnum <= lastMapPage))
-                     || ((ppnum >= atop_32(src)) && (ppnum <= lastImagePage)));
+           conflicts = (((ppnum >= atop_32((uintptr_t) map)) && (ppnum <= lastMapPage))
+                     || ((ppnum >= atop_32((uintptr_t) src)) && (ppnum <= lastImagePage)));
 
             if (pageIndexSource)
 
             if (pageIndexSource)
-                conflicts |= ((ppnum >= atop_32(pageIndexSource)) && (ppnum <= lastPageIndexPage));
+                conflicts |= ((ppnum >= atop_32((uintptr_t) pageIndexSource)) && (ppnum <= lastPageIndexPage));
 
            if (!conflicts)
            {
 
            if (!conflicts)
            {
@@ -431,6 +583,9 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
                uint32_t   bufferPage;
                uint32_t * dst;
 
                uint32_t   bufferPage;
                uint32_t * dst;
 
+//             debug_code(kIOHibernateRestoreCodeConflictPage,   ppnum);
+//             debug_code(kIOHibernateRestoreCodeConflictSource, (uintptr_t) src);
+
                conflictCount++;
 
                // alloc new buffer page
                conflictCount++;
 
                // alloc new buffer page
@@ -445,7 +600,7 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
                        copyPageList[1] = pageListPage;
                    else
                        copyPageListHead = pageListPage;
                        copyPageList[1] = pageListPage;
                    else
                        copyPageListHead = pageListPage;
-                   copyPageList = (uint32_t *) ptoa_32(pageListPage);
+                   copyPageList = (uint32_t *) (uintptr_t) ptoa_32(pageListPage);
                    copyPageList[1] = 0;
                    copyPageIndex = 2;
                }
                    copyPageList[1] = 0;
                    copyPageIndex = 2;
                }
@@ -455,7 +610,7 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
                copyPageList[copyPageIndex++] = compressedSize;
                copyPageList[0] = copyPageIndex;
 
                copyPageList[copyPageIndex++] = compressedSize;
                copyPageList[0] = copyPageIndex;
 
-               dst = (uint32_t *) ptoa_32(bufferPage);
+               dst = (uint32_t *) (uintptr_t) ptoa_32(bufferPage);
                for (idx = 0; idx < ((compressedSize + 3) >> 2); idx++)
                    dst[idx] = src[idx];
            }
                for (idx = 0; idx < ((compressedSize + 3) >> 2); idx++)
                    dst[idx] = src[idx];
            }
@@ -465,20 +620,20 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
 
     // -- copy back conflicts
 
 
     // -- copy back conflicts
 
-    copyPageList = (uint32_t *) ptoa_32(copyPageListHead);
+    copyPageList = (uint32_t *)(uintptr_t) ptoa_32(copyPageListHead);
     while (copyPageList)
     {
        for (copyPageIndex = 2; copyPageIndex < copyPageList[0]; copyPageIndex += 3)
        {
            ppnum          =              copyPageList[copyPageIndex + 0];
     while (copyPageList)
     {
        for (copyPageIndex = 2; copyPageIndex < copyPageList[0]; copyPageIndex += 3)
        {
            ppnum          =              copyPageList[copyPageIndex + 0];
-           src            = (uint32_t *) ptoa_32(copyPageList[copyPageIndex + 1]);
+           src            = (uint32_t *) (uintptr_t) ptoa_32(copyPageList[copyPageIndex + 1]);
            compressedSize =              copyPageList[copyPageIndex + 2];
 
            sum += store_one_page(gIOHibernateCurrentHeader->processorFlags,
                                    src, compressedSize, buffer, ppnum);
            uncompressedPages++;
        }
            compressedSize =              copyPageList[copyPageIndex + 2];
 
            sum += store_one_page(gIOHibernateCurrentHeader->processorFlags,
                                    src, compressedSize, buffer, ppnum);
            uncompressedPages++;
        }
-       copyPageList = (uint32_t *) ptoa_32(copyPageList[1]);
+       copyPageList = (uint32_t *) (uintptr_t) ptoa_32(copyPageList[1]);
     }
 
     // -- image has been destroyed...
     }
 
     // -- image has been destroyed...
@@ -490,18 +645,24 @@ hibernate_kernel_entrypoint(IOHibernateImageHeader * header,
 
     gIOHibernateState = kIOHibernateStateWakingFromHibernate;
 
 
     gIOHibernateState = kIOHibernateStateWakingFromHibernate;
 
-#if __ppc__
+#if CONFIG_SLEEP
+#if defined(__ppc__)
+    typedef void (*ResetProc)(void);
     ResetProc proc;
     proc = (ResetProc) 0x100;
     __asm__ volatile("ori 0, 0, 0" : : );
     proc();
     ResetProc proc;
     proc = (ResetProc) 0x100;
     __asm__ volatile("ori 0, 0, 0" : : );
     proc();
-#elif __i386__
+#elif defined(__i386__) || defined(__x86_64__)
+    typedef void (*ResetProc)(void);
     ResetProc proc;
     proc = (ResetProc) acpi_wake_prot_entry;
     ResetProc proc;
     proc = (ResetProc) acpi_wake_prot_entry;
-
+    // flush caches
+    __asm__("wbinvd");
     proc();
     proc();
+#else
+// implement me
 #endif
 #endif
-  
+#endif
+
     return -1;
 }
     return -1;
 }
-
mirror of XNU