grub-core/loader/xnu_resume.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2009  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <grub/normal.h>
  20 #include <grub/dl.h>
  21 #include <grub/file.h>
  22 #include <grub/disk.h>
  23 #include <grub/misc.h>
  24 #include <grub/xnu.h>
  25 #include <grub/cpu/xnu.h>
  26 #include <grub/mm.h>
  27 #include <grub/loader.h>
  28 #include <grub/i18n.h>
  29
  30 static void *grub_xnu_hibernate_image;
  31
  32 static grub_err_t
  33 grub_xnu_resume_unload (void)
  34 {
  35   /* Free loaded image */
  36   if (grub_xnu_hibernate_image)
  37     grub_free (grub_xnu_hibernate_image);
  38   grub_xnu_hibernate_image = 0;
  39   grub_xnu_unlock ();
  40   return GRUB_ERR_NONE;
  41 }
  42
  43 grub_err_t
  44 grub_xnu_resume (char *imagename)
  45 {
  46   grub_file_t file;
  47   grub_size_t total_header_size;
  48   struct grub_xnu_hibernate_header hibhead;
  49   void *code;
  50   void *image;
  51   grub_uint32_t codedest;
  52   grub_uint32_t codesize;
  53   grub_addr_t target_image;
  54   grub_err_t err;
  55
  56   file = grub_file_open (imagename, GRUB_FILE_TYPE_XNU_HIBERNATE_IMAGE
  57                          | GRUB_FILE_TYPE_NO_DECOMPRESS);
  58   if (! file)
  59     return 0;
  60
  61   /* Read the header. */
  62   if (grub_file_read (file, &hibhead, sizeof (hibhead))
  63       != sizeof (hibhead))
  64     {
  65       grub_file_close (file);
  66       if (!grub_errno)
  67         grub_error (GRUB_ERR_READ_ERROR,
  68                     N_("premature end of file %s"), imagename);
  69       return grub_errno;
  70     }
  71
  72   /* Check the header. */
  73   if (hibhead.magic != GRUB_XNU_HIBERNATE_MAGIC)
  74     {
  75       grub_file_close (file);
  76       return grub_error (GRUB_ERR_BAD_OS,
  77                          "hibernate header has incorrect magic number");
  78     }
  79   if (hibhead.encoffset)
  80     {
  81       grub_file_close (file);
  82       return grub_error (GRUB_ERR_BAD_OS,
  83                          "encrypted images aren't supported yet");
  84     }
  85
  86   if (hibhead.image_size == 0)
  87     {
  88       grub_file_close (file);
  89       return grub_error (GRUB_ERR_BAD_OS,
  90                          "hibernate image is empty");
  91     }
  92
  93   codedest = hibhead.launchcode_target_page;
  94   codedest *= GRUB_XNU_PAGESIZE;
  95   codesize = hibhead.launchcode_numpages;
  96   codesize *= GRUB_XNU_PAGESIZE;
  97
  98   /* FIXME: check that codedest..codedest+codesize is available. */
  99
 100   /* Calculate total size before pages to copy. */
 101   total_header_size = hibhead.extmapsize + sizeof (hibhead);
 102
 103   /* Unload image if any. */
 104   if (grub_xnu_hibernate_image)
 105     grub_free (grub_xnu_hibernate_image);
 106
 107   /* Try to allocate necessary space.
 108      FIXME: mm isn't good enough yet to handle huge allocations.
 109    */
 110   grub_xnu_relocator = grub_relocator_new ();
 111   if (!grub_xnu_relocator)
 112     {
 113       grub_file_close (file);
 114       return grub_errno;
 115     }
 116
 117   {
 118     grub_relocator_chunk_t ch;
 119     err = grub_relocator_alloc_chunk_addr (grub_xnu_relocator, &ch, codedest,
 120                                            codesize + GRUB_XNU_PAGESIZE);
 121     if (err)
 122       {
 123         grub_file_close (file);
 124         return err;
 125       }
 126     code = get_virtual_current_address (ch);
 127   }
 128
 129   {
 130     grub_relocator_chunk_t ch;
 131     err = grub_relocator_alloc_chunk_align (grub_xnu_relocator, &ch, 0,
 132                                             (0xffffffff - hibhead.image_size) + 1,
 133                                             hibhead.image_size,
 134                                             GRUB_XNU_PAGESIZE,
 135                                             GRUB_RELOCATOR_PREFERENCE_NONE, 0);
 136     if (err)
 137       {
 138         grub_file_close (file);
 139         return err;
 140       }
 141     image = get_virtual_current_address (ch);
 142     target_image = get_physical_target_address (ch);
 143   }
 144
 145   /* Read code part. */
 146   if (grub_file_seek (file, total_header_size) == (grub_off_t) -1
 147       || grub_file_read (file, code, codesize)
 148       != (grub_ssize_t) codesize)
 149     {
 150       grub_file_close (file);
 151       if (!grub_errno)
 152         grub_error (GRUB_ERR_READ_ERROR,
 153                     N_("premature end of file %s"), imagename);
 154       return grub_errno;
 155     }
 156
 157   /* Read image. */
 158   if (grub_file_seek (file, 0) == (grub_off_t) -1
 159       || grub_file_read (file, image, hibhead.image_size)
 160       != (grub_ssize_t) hibhead.image_size)
 161     {
 162       grub_file_close (file);
 163       if (!grub_errno)
 164         grub_error (GRUB_ERR_READ_ERROR,
 165                     N_("premature end of file %s"), imagename);
 166       return grub_errno;
 167     }
 168   grub_file_close (file);
 169
 170   /* Setup variables needed by asm helper. */
 171   grub_xnu_heap_target_start = codedest;
 172   grub_xnu_heap_size = target_image + hibhead.image_size - codedest;
 173   grub_xnu_stack = (codedest + hibhead.stack);
 174   grub_xnu_entry_point = (codedest + hibhead.entry_point);
 175   grub_xnu_arg1 = target_image;
 176
 177   grub_dprintf ("xnu", "entry point 0x%x\n", codedest + hibhead.entry_point);
 178   grub_dprintf ("xnu", "image at 0x%x\n",
 179                 codedest + codesize + GRUB_XNU_PAGESIZE);
 180
 181   /* We're ready now. */
 182   grub_loader_set (grub_xnu_boot_resume,
 183                    grub_xnu_resume_unload, 0);
 184
 185   /* Prevent module from unloading. */
 186   grub_xnu_lock ();
 187   return GRUB_ERR_NONE;
 188 }