arch/common/boot/grub2/loader/i386/efi/linux.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2006,2007  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/loader.h>
  20 #include <grub/machine/loader.h>
  21 #include <grub/file.h>
  22 #include <grub/disk.h>
  23 #include <grub/err.h>
  24 #include <grub/misc.h>
  25 #include <grub/types.h>
  26 #include <grub/rescue.h>
  27 #include <grub/dl.h>
  28 #include <grub/mm.h>
  29 #include <grub/term.h>
  30 #include <grub/cpu/linux.h>
  31 #include <grub/efi/api.h>
  32 #include <grub/efi/efi.h>
  33
  34 #define NEXT_MEMORY_DESCRIPTOR(desc, size)      \
  35   ((grub_efi_memory_descriptor_t *) ((char *) (desc) + (size)))
  36
  37 static grub_dl_t my_mod;
  38
  39 static grub_size_t linux_mem_size;
  40 static int loaded;
  41 static void *real_mode_mem;
  42 static void *prot_mode_mem;
  43 static void *initrd_mem;
  44 static grub_efi_uintn_t real_mode_pages;
  45 static grub_efi_uintn_t prot_mode_pages;
  46 static grub_efi_uintn_t initrd_pages;
  47 static void *mmap_buf;
  48
  49 static grub_uint8_t gdt[] __attribute__ ((aligned(16))) =
  50   {
  51     /* NULL.  */
  52     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  53     /* Reserved.  */
  54     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  55     /* Code segment.  */
  56     0xFF, 0xFF, 0x00, 0x00, 0x00, 0x9A, 0xCF, 0x00,
  57     /* Data segment.  */
  58     0xFF, 0xFF, 0x00, 0x00, 0x00, 0x92, 0xCF, 0x00
  59   };
  60
  61 struct gdt_descriptor
  62 {
  63   grub_uint16_t dummy;
  64   grub_uint16_t limit;
  65   grub_uint32_t base;
  66 } __attribute__ ((aligned(4), packed));
  67
  68 static struct gdt_descriptor gdt_desc =
  69   {
  70     0,
  71     sizeof (gdt) - 1,
  72     (grub_addr_t) gdt
  73   };
  74
  75 struct idt_descriptor
  76 {
  77   grub_uint16_t dummy;
  78   grub_uint16_t limit;
  79   grub_uint32_t base;
  80 } __attribute__ ((aligned(4)));
  81
  82 static struct idt_descriptor idt_desc =
  83   {
  84     0,
  85     0,
  86     0
  87   };
  88
  89 static inline grub_size_t
  90 page_align (grub_size_t size)
  91 {
  92   return (size + (1 << 12) - 1) & (~((1 << 12) - 1));
  93 }
  94
  95 /* Find the optimal number of pages for the memory map. Is it better to
  96    move this code to efi/mm.c?  */
  97 static grub_efi_uintn_t
  98 find_mmap_size (void)
  99 {
 100   static grub_efi_uintn_t mmap_size = 0;
 101
 102   if (mmap_size != 0)
 103     return mmap_size;
 104
 105   mmap_size = (1 << 12);
 106   while (1)
 107     {
 108       int ret;
 109       grub_efi_memory_descriptor_t *mmap;
 110       grub_efi_uintn_t desc_size;
 111
 112       mmap = grub_malloc (mmap_size);
 113       if (! mmap)
 114         return 0;
 115
 116       ret = grub_efi_get_memory_map (&mmap_size, mmap, 0, &desc_size, 0);
 117       grub_free (mmap);
 118
 119       if (ret < 0)
 120         grub_fatal ("cannot get memory map");
 121       else if (ret > 0)
 122         break;
 123
 124       mmap_size += (1 << 12);
 125     }
 126
 127   /* Increase the size a bit for safety, because GRUB allocates more on
 128      later, and EFI itself may allocate more.  */
 129   mmap_size += (1 << 12);
 130
 131   return page_align (mmap_size);
 132 }
 133
 134 static void
 135 free_pages (void)
 136 {
 137   if (real_mode_mem)
 138     {
 139       grub_efi_free_pages ((grub_addr_t) real_mode_mem, real_mode_pages);
 140       real_mode_mem = 0;
 141     }
 142
 143   if (prot_mode_mem)
 144     {
 145       grub_efi_free_pages ((grub_addr_t) prot_mode_mem, prot_mode_pages);
 146       prot_mode_mem = 0;
 147     }
 148
 149   if (initrd_mem)
 150     {
 151       grub_efi_free_pages ((grub_addr_t) initrd_mem, initrd_pages);
 152       initrd_mem = 0;
 153     }
 154 }
 155
 156 /* Allocate pages for the real mode code and the protected mode code
 157    for linux as well as a memory map buffer.  */
 158 static int
 159 allocate_pages (grub_size_t real_size, grub_size_t prot_size)
 160 {
 161   grub_efi_uintn_t desc_size;
 162   grub_efi_memory_descriptor_t *mmap, *mmap_end;
 163   grub_efi_uintn_t mmap_size, tmp_mmap_size;
 164   grub_efi_memory_descriptor_t *desc;
 165
 166   /* Make sure that each size is aligned to a page boundary.  */
 167   real_size = page_align (real_size + GRUB_DISK_SECTOR_SIZE);
 168   prot_size = page_align (prot_size);
 169   mmap_size = find_mmap_size ();
 170
 171   grub_dprintf ("linux", "real_size = %x, prot_size = %x, mmap_size = %x\n",
 172                 real_size, prot_size, mmap_size);
 173
 174   /* Calculate the number of pages; Combine the real mode code with
 175      the memory map buffer for simplicity.  */
 176   real_mode_pages = ((real_size + mmap_size) >> 12);
 177   prot_mode_pages = (prot_size >> 12);
 178
 179   /* Initialize the memory pointers with NULL for convenience.  */
 180   real_mode_mem = 0;
 181   prot_mode_mem = 0;
 182
 183   /* Read the memory map temporarily, to find free space.  */
 184   mmap = grub_malloc (mmap_size);
 185   if (! mmap)
 186     return 0;
 187
 188   tmp_mmap_size = mmap_size;
 189   if (grub_efi_get_memory_map (&tmp_mmap_size, mmap, 0, &desc_size, 0) <= 0)
 190     grub_fatal ("cannot get memory map");
 191
 192   mmap_end = NEXT_MEMORY_DESCRIPTOR (mmap, tmp_mmap_size);
 193
 194   /* First, find free pages for the real mode code
 195      and the memory map buffer.  */
 196   for (desc = mmap;
 197        desc < mmap_end;
 198        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
 199     {
 200       /* Probably it is better to put the real mode code in the traditional
 201          space for safety.  */
 202       if (desc->type == GRUB_EFI_CONVENTIONAL_MEMORY
 203           && desc->physical_start <= 0x90000
 204           && desc->num_pages >= real_mode_pages)
 205         {
 206           grub_efi_physical_address_t physical_end;
 207           grub_efi_physical_address_t addr;
 208
 209           physical_end = desc->physical_start + (desc->num_pages << 12);
 210           if (physical_end > 0x90000)
 211             physical_end = 0x90000;
 212
 213           grub_dprintf ("linux", "physical_start = %x, physical_end = %x\n",
 214                         (unsigned) desc->physical_start,
 215                         (unsigned) physical_end);
 216           addr = physical_end - real_size - mmap_size;
 217           if (addr < 0x10000)
 218             continue;
 219
 220           grub_dprintf ("linux", "trying to allocate %u pages at %x\n",
 221                         real_mode_pages, (unsigned) addr);
 222           real_mode_mem = grub_efi_allocate_pages (addr, real_mode_pages);
 223           if (! real_mode_mem)
 224             grub_fatal ("cannot allocate pages");
 225
 226           desc->num_pages -= real_mode_pages;
 227           break;
 228         }
 229     }
 230
 231   if (! real_mode_mem)
 232     {
 233       grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate real mode pages");
 234       goto fail;
 235     }
 236
 237   mmap_buf = (void *) ((char *) real_mode_mem + real_size);
 238
 239   /* Next, find free pages for the protected mode code.  */
 240   /* XXX what happens if anything is using this address?  */
 241   prot_mode_mem = grub_efi_allocate_pages (0x100000, prot_mode_pages);
 242   if (! prot_mode_mem)
 243     {
 244       grub_error (GRUB_ERR_OUT_OF_MEMORY,
 245                   "cannot allocate protected mode pages");
 246       goto fail;
 247     }
 248
 249   grub_free (mmap);
 250   return 1;
 251
 252  fail:
 253   grub_free (mmap);
 254   free_pages ();
 255   return 0;
 256 }
 257
 258 static grub_err_t
 259 grub_linux_boot (void)
 260 {
 261   struct linux_kernel_header *lh;
 262   struct linux_kernel_params *params;
 263   grub_efi_uintn_t mmap_size;
 264   grub_efi_uintn_t map_key;
 265   grub_efi_uintn_t desc_size;
 266   grub_efi_uint32_t desc_version;
 267
 268   lh = real_mode_mem;
 269   params = real_mode_mem;
 270
 271   grub_dprintf ("linux", "code32_start = %x, idt_desc = %x, gdt_desc = %x\n",
 272                 (unsigned) lh->code32_start, (grub_addr_t) &(idt_desc.limit),
 273                 (grub_addr_t) &(gdt_desc.limit));
 274   grub_dprintf ("linux", "idt = %x:%x, gdt = %x:%x\n",
 275                 (unsigned) idt_desc.limit, (unsigned) idt_desc.base,
 276                 (unsigned) gdt_desc.limit, (unsigned) gdt_desc.base);
 277   mmap_size = find_mmap_size ();
 278   if (grub_efi_get_memory_map (&mmap_size, mmap_buf, &map_key,
 279                                &desc_size, &desc_version) <= 0)
 280     grub_fatal ("cannot get memory map");
 281
 282   if (! grub_efi_exit_boot_services (map_key))
 283     grub_fatal ("cannot exit boot services");
 284
 285   /* Note that no boot services are available from here.  */
 286
 287   /* Hardware interrupts are not safe any longer.  */
 288   asm volatile ("cli" : : );
 289
 290   /* Pass EFI parameters.  */
 291   params->efi_mem_desc_size = desc_size;
 292   params->efi_mem_desc_version = desc_version;
 293   params->efi_mmap = (grub_addr_t) mmap_buf;
 294   params->efi_mmap_size = mmap_size;
 295
 296   /* Pass parameters.  */
 297   asm volatile ("movl %0, %%esi" : : "m" (real_mode_mem));
 298   asm volatile ("movl %0, %%ecx" : : "m" (lh->code32_start));
 299   asm volatile ("xorl %%ebx, %%ebx" : : );
 300
 301   /* Load the IDT and the GDT for the bootstrap.  */
 302   asm volatile ("lidt %0" : : "m" (idt_desc.limit));
 303   asm volatile ("lgdt %0" : : "m" (gdt_desc.limit));
 304
 305   /* Enter Linux.  */
 306   asm volatile ("jmp *%%ecx" : : );
 307
 308   /* Never reach here.  */
 309   return GRUB_ERR_NONE;
 310 }
 311
 312 static grub_err_t
 313 grub_linux_unload (void)
 314 {
 315   free_pages ();
 316   grub_dl_unref (my_mod);
 317   loaded = 0;
 318   return GRUB_ERR_NONE;
 319 }
 320
 321 void
 322 grub_rescue_cmd_linux (int argc, char *argv[])
 323 {
 324   grub_file_t file = 0;
 325   struct linux_kernel_header lh;
 326   struct linux_kernel_params *params;
 327   grub_uint8_t setup_sects;
 328   grub_size_t real_size, prot_size;
 329   grub_ssize_t len;
 330   int i;
 331   char *dest;
 332
 333   grub_dl_ref (my_mod);
 334
 335   if (argc == 0)
 336     {
 337       grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
 338       goto fail;
 339     }
 340
 341   file = grub_file_open (argv[0]);
 342   if (! file)
 343     goto fail;
 344
 345   if (grub_file_read (file, (char *) &lh, sizeof (lh)) != sizeof (lh))
 346     {
 347       grub_error (GRUB_ERR_READ_ERROR, "cannot read the linux header");
 348       goto fail;
 349     }
 350
 351   if (lh.boot_flag != grub_cpu_to_le16 (0xaa55))
 352     {
 353       grub_error (GRUB_ERR_BAD_OS, "invalid magic number");
 354       goto fail;
 355     }
 356
 357   if (lh.setup_sects > GRUB_LINUX_MAX_SETUP_SECTS)
 358     {
 359       grub_error (GRUB_ERR_BAD_OS, "too many setup sectors");
 360       goto fail;
 361     }
 362
 363   /* EFI support is quite new, so reject old versions.  */
 364   if (lh.header != grub_cpu_to_le32 (GRUB_LINUX_MAGIC_SIGNATURE)
 365       || grub_le_to_cpu16 (lh.version) < 0x0203)
 366     {
 367       grub_error (GRUB_ERR_BAD_OS, "too old version");
 368       goto fail;
 369     }
 370
 371   /* I'm not sure how to support zImage on EFI.  */
 372   if (! (lh.loadflags & GRUB_LINUX_FLAG_BIG_KERNEL))
 373     {
 374       grub_error (GRUB_ERR_BAD_OS, "zImage is not supported");
 375       goto fail;
 376     }
 377
 378   setup_sects = lh.setup_sects;
 379
 380   /* If SETUP_SECTS is not set, set it to the default (4).  */
 381   if (! setup_sects)
 382     setup_sects = GRUB_LINUX_DEFAULT_SETUP_SECTS;
 383
 384   real_size = setup_sects << GRUB_DISK_SECTOR_BITS;
 385   prot_size = grub_file_size (file) - real_size - GRUB_DISK_SECTOR_SIZE;
 386
 387   if (! allocate_pages (real_size, prot_size))
 388     goto fail;
 389
 390   /* XXX Linux assumes that only elilo can boot Linux on EFI!!!  */
 391   lh.type_of_loader = 0x50;
 392
 393   lh.cl_magic = GRUB_LINUX_CL_MAGIC;
 394   lh.cl_offset = GRUB_LINUX_CL_END_OFFSET;
 395   lh.cmd_line_ptr = (char *) real_mode_mem + GRUB_LINUX_CL_OFFSET;
 396   lh.ramdisk_image = 0;
 397   lh.ramdisk_size = 0;
 398
 399   params = (struct linux_kernel_params *) &lh;
 400
 401   /* These are not needed to be precise, because Linux uses these values
 402      only to raise an error when the decompression code cannot find good
 403      space.  */
 404   params->ext_mem = ((32 * 0x100000) >> 10);
 405   params->alt_mem = ((32 * 0x100000) >> 10);
 406
 407   params->video_cursor_x = grub_efi_system_table->con_out->mode->cursor_column;
 408   params->video_cursor_y = grub_efi_system_table->con_out->mode->cursor_row;
 409   params->video_page = 0; /* ??? */
 410   params->video_mode = grub_efi_system_table->con_out->mode->mode;
 411   params->video_width = (grub_getwh () >> 8);
 412   params->video_ega_bx = 0;
 413   params->video_height = (grub_getwh () & 0xff);
 414   params->have_vga = 0;
 415   params->font_size = 16; /* XXX */
 416
 417   /* No VBE on EFI.  */
 418   params->lfb_width = 0;
 419   params->lfb_height = 0;
 420   params->lfb_depth = 0;
 421   params->lfb_base = 0;
 422   params->lfb_size = 0;
 423   params->lfb_line_len = 0;
 424   params->red_mask_size = 0;
 425   params->red_field_pos = 0;
 426   params->green_mask_size = 0;
 427   params->green_field_pos = 0;
 428   params->blue_mask_size = 0;
 429   params->blue_field_pos = 0;
 430   params->reserved_mask_size = 0;
 431   params->reserved_field_pos = 0;
 432   params->vesapm_segment = 0;
 433   params->vesapm_offset = 0;
 434   params->lfb_pages = 0;
 435   params->vesa_attrib = 0;
 436
 437   /* No APM on EFI.  */
 438   params->apm_version = 0;
 439   params->apm_code_segment = 0;
 440   params->apm_entry = 0;
 441   params->apm_16bit_code_segment = 0;
 442   params->apm_data_segment = 0;
 443   params->apm_flags = 0;
 444   params->apm_code_len = 0;
 445   params->apm_data_len = 0;
 446
 447   /* XXX is there any way to use SpeedStep on EFI?  */
 448   params->ist_signature = 0;
 449   params->ist_command = 0;
 450   params->ist_event = 0;
 451   params->ist_perf_level = 0;
 452
 453   /* Let the kernel probe the information.  */
 454   grub_memset (params->hd0_drive_info, 0, sizeof (params->hd0_drive_info));
 455   grub_memset (params->hd1_drive_info, 0, sizeof (params->hd1_drive_info));
 456
 457   /* No MCA on EFI.  */
 458   params->rom_config_len = 0;
 459
 460   params->efi_signature = GRUB_LINUX_EFI_SIGNATURE; /* XXX not used */
 461   params->efi_system_table = (grub_addr_t) grub_efi_system_table;
 462   /* The other EFI parameters are filled when booting.  */
 463
 464   /* No need to fake the BIOS's memory map.  */
 465   params->mmap_size = 0;
 466
 467   /* Let the kernel probe the information.  */
 468   params->ps_mouse = 0;
 469
 470   /* Clear padding for future compatibility.  */
 471   grub_memset (params->padding1, 0, sizeof (params->padding1));
 472   grub_memset (params->padding2, 0, sizeof (params->padding2));
 473   grub_memset (params->padding3, 0, sizeof (params->padding3));
 474   grub_memset (params->padding4, 0, sizeof (params->padding4));
 475   grub_memset (params->padding5, 0, sizeof (params->padding5));
 476   grub_memset (params->padding6, 0, sizeof (params->padding6));
 477   grub_memset (params->padding7, 0, sizeof (params->padding7));
 478   grub_memset (params->padding8, 0, sizeof (params->padding8));
 479   grub_memset (params->padding9, 0, sizeof (params->padding9));
 480
 481   /* Put the real mode code at the real location.  */
 482   grub_memmove (real_mode_mem, &lh, sizeof (lh));
 483
 484   len = real_size + GRUB_DISK_SECTOR_SIZE - sizeof (lh);
 485   if (grub_file_read (file, (char *) real_mode_mem + sizeof (lh), len) != len)
 486     {
 487       grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
 488       goto fail;
 489     }
 490
 491   /* XXX there is no way to know if the kernel really supports EFI.  */
 492   grub_printf ("   [Linux-EFI, setup=0x%x, size=0x%x]\n",
 493                real_size, prot_size);
 494
 495   /* Detect explicitly specified memory size, if any.  */
 496   linux_mem_size = 0;
 497   for (i = 1; i < argc; i++)
 498     if (grub_memcmp (argv[i], "mem=", 4) == 0)
 499       {
 500         char *val = argv[i] + 4;
 501
 502         linux_mem_size = grub_strtoul (val, &val, 0);
 503
 504         if (grub_errno)
 505           {
 506             grub_errno = GRUB_ERR_NONE;
 507             linux_mem_size = 0;
 508           }
 509         else
 510           {
 511             int shift = 0;
 512
 513             switch (grub_tolower (val[0]))
 514               {
 515               case 'g':
 516                 shift += 10;
 517               case 'm':
 518                 shift += 10;
 519               case 'k':
 520                 shift += 10;
 521               default:
 522                 break;
 523               }
 524
 525             /* Check an overflow.  */
 526             if (linux_mem_size > (~0UL >> shift))
 527               linux_mem_size = 0;
 528             else
 529               linux_mem_size <<= shift;
 530           }
 531       }
 532
 533   /* Specify the boot file.  */
 534   dest = grub_stpcpy ((char *) real_mode_mem + GRUB_LINUX_CL_OFFSET,
 535                       "BOOT_IMAGE=");
 536   dest = grub_stpcpy (dest, argv[0]);
 537
 538   /* Copy kernel parameters.  */
 539   for (i = 1;
 540        i < argc
 541          && dest + grub_strlen (argv[i]) + 1 < ((char *) real_mode_mem
 542                                                 + GRUB_LINUX_CL_END_OFFSET);
 543        i++)
 544     {
 545       *dest++ = ' ';
 546       dest = grub_stpcpy (dest, argv[i]);
 547     }
 548
 549   len = prot_size;
 550   if (grub_file_read (file, (char *) GRUB_LINUX_BZIMAGE_ADDR, len) != len)
 551     grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
 552
 553   if (grub_errno == GRUB_ERR_NONE)
 554     {
 555       grub_loader_set (grub_linux_boot, grub_linux_unload, 1);
 556       loaded = 1;
 557     }
 558
 559  fail:
 560
 561   if (file)
 562     grub_file_close (file);
 563
 564   if (grub_errno != GRUB_ERR_NONE)
 565     {
 566       grub_dl_unref (my_mod);
 567       loaded = 0;
 568     }
 569 }
 570
 571 void
 572 grub_rescue_cmd_initrd (int argc, char *argv[])
 573 {
 574   grub_file_t file = 0;
 575   grub_ssize_t size;
 576   grub_addr_t addr_min, addr_max;
 577   grub_addr_t addr;
 578   grub_efi_uintn_t mmap_size;
 579   grub_efi_memory_descriptor_t *desc;
 580   grub_efi_uintn_t desc_size;
 581   struct linux_kernel_header *lh;
 582
 583   if (argc == 0)
 584     {
 585       grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
 586       goto fail;
 587     }
 588
 589   if (! loaded)
 590     {
 591       grub_error (GRUB_ERR_BAD_ARGUMENT, "You need to load the kernel first.");
 592       goto fail;
 593     }
 594
 595   file = grub_file_open (argv[0]);
 596   if (! file)
 597     goto fail;
 598
 599   size = grub_file_size (file);
 600   initrd_pages = (page_align (size) >> 12);
 601
 602   lh = (struct linux_kernel_header *) real_mode_mem;
 603
 604   addr_max = grub_cpu_to_le32 (lh->initrd_addr_max);
 605   if (linux_mem_size != 0 && linux_mem_size < addr_max)
 606     addr_max = linux_mem_size;
 607
 608   /* Linux 2.3.xx has a bug in the memory range check, so avoid
 609      the last page.
 610      Linux 2.2.xx has a bug in the memory range check, which is
 611      worse than that of Linux 2.3.xx, so avoid the last 64kb.  */
 612   addr_max -= 0x10000;
 613
 614   /* Usually, the compression ratio is about 50%.  */
 615   addr_min = (grub_addr_t) prot_mode_mem + ((prot_mode_pages * 3) << 12);
 616
 617   /* Find the highest address to put the initrd.  */
 618   mmap_size = find_mmap_size ();
 619   if (grub_efi_get_memory_map (&mmap_size, mmap_buf, 0, &desc_size, 0) <= 0)
 620     grub_fatal ("cannot get memory map");
 621
 622   addr = 0;
 623   for (desc = mmap_buf;
 624        desc < NEXT_MEMORY_DESCRIPTOR (mmap_buf, mmap_size);
 625        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
 626     {
 627       if (desc->type == GRUB_EFI_CONVENTIONAL_MEMORY
 628           && desc->physical_start >= addr_min
 629           && desc->physical_start + size < addr_max
 630           && desc->num_pages >= initrd_pages)
 631         {
 632           grub_efi_physical_address_t physical_end;
 633
 634           physical_end = desc->physical_start + (desc->num_pages << 12);
 635           if (physical_end > addr_max)
 636             physical_end = addr_max;
 637
 638           if (physical_end > addr)
 639             addr = physical_end - page_align (size);
 640         }
 641     }
 642
 643   if (addr == 0)
 644     {
 645       grub_error (GRUB_ERR_OUT_OF_MEMORY, "no free pages available");
 646       goto fail;
 647     }
 648
 649   initrd_mem = grub_efi_allocate_pages (addr, initrd_pages);
 650   if (! initrd_mem)
 651     grub_fatal ("cannot allocate pages");
 652
 653   if (grub_file_read (file, initrd_mem, size) != size)
 654     {
 655       grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
 656       goto fail;
 657     }
 658
 659   grub_printf ("   [Initrd, addr=0x%x, size=0x%x]\n",
 660                addr, size);
 661
 662   lh->ramdisk_image = addr;
 663   lh->ramdisk_size = size;
 664   lh->root_dev = 0x0100; /* XXX */
 665
 666  fail:
 667   if (file)
 668     grub_file_close (file);
 669 }
 670
 671
 672 GRUB_MOD_INIT(linux)
 673 {
 674   grub_rescue_register_command ("linux",
 675                                 grub_rescue_cmd_linux,
 676                                 "load linux");
 677   grub_rescue_register_command ("initrd",
 678                                 grub_rescue_cmd_initrd,
 679                                 "load initrd");
 680   my_mod = mod;
 681 }
 682
 683 GRUB_MOD_FINI(linux)
 684 {
 685   grub_rescue_unregister_command ("linux");
 686   grub_rescue_unregister_command ("initrd");
 687 }