kern/elf.c

   1 /* elf.c - load ELF files */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2003,2004,2005,2006,2007,2008  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/err.h>
  21 #include <grub/elf.h>
  22 #include <grub/elfload.h>
  23 #include <grub/file.h>
  24 #include <grub/gzio.h>
  25 #include <grub/misc.h>
  26 #include <grub/mm.h>
  27
  28 /* Check if EHDR is a valid ELF header.  */
  29 static grub_err_t
  30 grub_elf_check_header (grub_elf_t elf)
  31 {
  32   Elf32_Ehdr *e = &elf->ehdr.ehdr32;
  33
  34   if (e->e_ident[EI_MAG0] != ELFMAG0
  35       || e->e_ident[EI_MAG1] != ELFMAG1
  36       || e->e_ident[EI_MAG2] != ELFMAG2
  37       || e->e_ident[EI_MAG3] != ELFMAG3
  38       || e->e_ident[EI_VERSION] != EV_CURRENT
  39       || e->e_version != EV_CURRENT)
  40     return grub_error (GRUB_ERR_BAD_OS, "invalid arch independent ELF magic");
  41
  42   return GRUB_ERR_NONE;
  43 }
  44
  45 grub_err_t
  46 grub_elf_close (grub_elf_t elf)
  47 {
  48   grub_file_t file = elf->file;
  49
  50   grub_free (elf->phdrs);
  51   grub_free (elf);
  52
  53   if (file)
  54     grub_file_close (file);
  55
  56   return grub_errno;
  57 }
  58
  59 grub_elf_t
  60 grub_elf_file (grub_file_t file)
  61 {
  62   grub_elf_t elf;
  63
  64   elf = grub_malloc (sizeof (*elf));
  65   if (! elf)
  66     return 0;
  67
  68   elf->file = file;
  69   elf->phdrs = 0;
  70
  71   if (grub_file_seek (elf->file, 0) == (grub_off_t) -1)
  72     goto fail;
  73
  74   if (grub_file_read (elf->file, &elf->ehdr, sizeof (elf->ehdr))
  75       != sizeof (elf->ehdr))
  76     {
  77       grub_error_push ();
  78       grub_error (GRUB_ERR_READ_ERROR, "Cannot read ELF header.");
  79       goto fail;
  80     }
  81
  82   if (grub_elf_check_header (elf))
  83     goto fail;
  84
  85   return elf;
  86
  87 fail:
  88   grub_free (elf->phdrs);
  89   grub_free (elf);
  90   return 0;
  91 }
  92
  93 grub_elf_t
  94 grub_elf_open (const char *name)
  95 {
  96   grub_file_t file;
  97   grub_elf_t elf;
  98
  99   file = grub_gzfile_open (name, 1);
 100   if (! file)
 101     return 0;
 102
 103   elf = grub_elf_file (file);
 104   if (! elf)
 105     grub_file_close (file);
 106
 107   return elf;
 108 }
 109
 110 \f
 111 /* 32-bit */
 112
 113 int
 114 grub_elf_is_elf32 (grub_elf_t elf)
 115 {
 116   return elf->ehdr.ehdr32.e_ident[EI_CLASS] == ELFCLASS32;
 117 }
 118
 119 static grub_err_t
 120 grub_elf32_load_phdrs (grub_elf_t elf)
 121 {
 122   grub_ssize_t phdrs_size;
 123
 124   phdrs_size = elf->ehdr.ehdr32.e_phnum * elf->ehdr.ehdr32.e_phentsize;
 125
 126   grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",
 127                 (unsigned long long) elf->ehdr.ehdr32.e_phoff,
 128                 (unsigned long) phdrs_size);
 129
 130   elf->phdrs = grub_malloc (phdrs_size);
 131   if (! elf->phdrs)
 132     return grub_errno;
 133
 134   if ((grub_file_seek (elf->file, elf->ehdr.ehdr32.e_phoff) == (grub_off_t) -1)
 135       || (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))
 136     {
 137       grub_error_push ();
 138       return grub_error (GRUB_ERR_READ_ERROR, "Cannot read program headers");
 139     }
 140
 141   return GRUB_ERR_NONE;
 142 }
 143
 144 static grub_err_t
 145 grub_elf32_phdr_iterate (grub_elf_t elf,
 146                          int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf32_Phdr *, void *),
 147                          void *hook_arg)
 148 {
 149   Elf32_Phdr *phdrs;
 150   unsigned int i;
 151
 152   if (! elf->phdrs)
 153     if (grub_elf32_load_phdrs (elf))
 154       return grub_errno;
 155   phdrs = elf->phdrs;
 156
 157   for (i = 0; i < elf->ehdr.ehdr32.e_phnum; i++)
 158     {
 159       Elf32_Phdr *phdr = phdrs + i;
 160       grub_dprintf ("elf",
 161                     "Segment %u: type 0x%x paddr 0x%lx memsz 0x%lx "
 162                     "filesz %lx\n",
 163                     i, phdr->p_type,
 164                     (unsigned long) phdr->p_paddr,
 165                     (unsigned long) phdr->p_memsz,
 166                     (unsigned long) phdr->p_filesz);
 167       if (hook (elf, phdr, hook_arg))
 168         break;
 169     }
 170
 171   return grub_errno;
 172 }
 173
 174 /* Calculate the amount of memory spanned by the segments.  */
 175 grub_size_t
 176 grub_elf32_size (grub_elf_t elf)
 177 {
 178   Elf32_Addr segments_start = (Elf32_Addr) -1;
 179   Elf32_Addr segments_end = 0;
 180   int nr_phdrs = 0;
 181
 182   /* Run through the program headers to calculate the total memory size we
 183    * should claim.  */
 184   auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf32_Phdr *phdr, void *_arg);
 185   int NESTED_FUNC_ATTR calcsize (grub_elf_t UNUSED _elf, Elf32_Phdr *phdr, void UNUSED *_arg)
 186     {
 187       /* Only consider loadable segments.  */
 188       if (phdr->p_type != PT_LOAD)
 189         return 0;
 190       nr_phdrs++;
 191       if (phdr->p_paddr < segments_start)
 192         segments_start = phdr->p_paddr;
 193       if (phdr->p_paddr + phdr->p_memsz > segments_end)
 194         segments_end = phdr->p_paddr + phdr->p_memsz;
 195       return 0;
 196     }
 197
 198   grub_elf32_phdr_iterate (elf, calcsize, 0);
 199
 200   if (nr_phdrs == 0)
 201     {
 202       grub_error (GRUB_ERR_BAD_OS, "No program headers present");
 203       return 0;
 204     }
 205
 206   if (segments_end < segments_start)
 207     {
 208       /* Very bad addresses.  */
 209       grub_error (GRUB_ERR_BAD_OS, "Bad program header load addresses");
 210       return 0;
 211     }
 212
 213   return segments_end - segments_start;
 214 }
 215
 216
 217 /* Load every loadable segment into memory specified by `_load_hook'.  */
 218 grub_err_t
 219 grub_elf32_load (grub_elf_t _elf, grub_elf32_load_hook_t _load_hook,
 220                  grub_addr_t *base, grub_size_t *size)
 221 {
 222   grub_addr_t load_base = (grub_addr_t) -1ULL;
 223   grub_size_t load_size = 0;
 224   grub_err_t err;
 225
 226   auto int NESTED_FUNC_ATTR grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *hook);
 227   int NESTED_FUNC_ATTR grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *hook)
 228   {
 229     grub_elf32_load_hook_t load_hook = (grub_elf32_load_hook_t) hook;
 230     grub_addr_t load_addr;
 231
 232     if (phdr->p_type != PT_LOAD)
 233       return 0;
 234
 235     load_addr = phdr->p_paddr;
 236     if (load_hook && load_hook (phdr, &load_addr))
 237       return 1;
 238
 239     if (load_addr < load_base)
 240       load_base = load_addr;
 241
 242     grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
 243                   (unsigned long long) load_addr,
 244                   (unsigned long long) phdr->p_memsz);
 245
 246     if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)
 247       {
 248         grub_error_push ();
 249         return grub_error (GRUB_ERR_BAD_OS,
 250                            "Invalid offset in program header.");
 251       }
 252
 253     if (phdr->p_filesz)
 254       {
 255         grub_ssize_t read;
 256         read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
 257         if (read != (grub_ssize_t) phdr->p_filesz)
 258           {
 259             /* XXX How can we free memory from `load_hook'? */
 260             grub_error_push ();
 261             return grub_error (GRUB_ERR_BAD_OS,
 262                                "Couldn't read segment from file: "
 263                                "wanted 0x%lx bytes; read 0x%lx bytes.",
 264                                phdr->p_filesz, read);
 265           }
 266       }
 267
 268     if (phdr->p_filesz < phdr->p_memsz)
 269       grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
 270                    0, phdr->p_memsz - phdr->p_filesz);
 271
 272     load_size += phdr->p_memsz;
 273
 274     return 0;
 275   }
 276
 277   err = grub_elf32_phdr_iterate (_elf, grub_elf32_load_segment, _load_hook);
 278
 279   if (base)
 280     *base = load_base;
 281   if (size)
 282     *size = load_size;
 283
 284   return err;
 285 }
 286
 287
 288 \f
 289 /* 64-bit */
 290
 291 int
 292 grub_elf_is_elf64 (grub_elf_t elf)
 293 {
 294   return elf->ehdr.ehdr64.e_ident[EI_CLASS] == ELFCLASS64;
 295 }
 296
 297 static grub_err_t
 298 grub_elf64_load_phdrs (grub_elf_t elf)
 299 {
 300   grub_ssize_t phdrs_size;
 301
 302   phdrs_size = elf->ehdr.ehdr64.e_phnum * elf->ehdr.ehdr64.e_phentsize;
 303
 304   grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",
 305                 (unsigned long long) elf->ehdr.ehdr64.e_phoff,
 306                 (unsigned long) phdrs_size);
 307
 308   elf->phdrs = grub_malloc (phdrs_size);
 309   if (! elf->phdrs)
 310     return grub_errno;
 311
 312   if ((grub_file_seek (elf->file, elf->ehdr.ehdr64.e_phoff) == (grub_off_t) -1)
 313       || (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))
 314     {
 315       grub_error_push ();
 316       return grub_error (GRUB_ERR_READ_ERROR, "Cannot read program headers");
 317     }
 318
 319   return GRUB_ERR_NONE;
 320 }
 321
 322 static grub_err_t
 323 grub_elf64_phdr_iterate (grub_elf_t elf,
 324                          int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf64_Phdr *, void *),
 325                          void *hook_arg)
 326 {
 327   Elf64_Phdr *phdrs;
 328   unsigned int i;
 329
 330   if (! elf->phdrs)
 331     if (grub_elf64_load_phdrs (elf))
 332       return grub_errno;
 333   phdrs = elf->phdrs;
 334
 335   for (i = 0; i < elf->ehdr.ehdr64.e_phnum; i++)
 336     {
 337       Elf64_Phdr *phdr = phdrs + i;
 338       grub_dprintf ("elf",
 339                     "Segment %u: type 0x%x paddr 0x%lx memsz 0x%lx "
 340                     "filesz %lx\n",
 341                     i, phdr->p_type,
 342                     (unsigned long) phdr->p_paddr,
 343                     (unsigned long) phdr->p_memsz,
 344                     (unsigned long) phdr->p_filesz);
 345       if (hook (elf, phdr, hook_arg))
 346         break;
 347     }
 348
 349   return grub_errno;
 350 }
 351
 352 /* Calculate the amount of memory spanned by the segments.  */
 353 grub_size_t
 354 grub_elf64_size (grub_elf_t elf)
 355 {
 356   Elf64_Addr segments_start = (Elf64_Addr) -1;
 357   Elf64_Addr segments_end = 0;
 358   int nr_phdrs = 0;
 359
 360   /* Run through the program headers to calculate the total memory size we
 361    * should claim.  */
 362   auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf64_Phdr *phdr, void *_arg);
 363   int NESTED_FUNC_ATTR calcsize (grub_elf_t UNUSED _elf, Elf64_Phdr *phdr, void UNUSED *_arg)
 364     {
 365       /* Only consider loadable segments.  */
 366       if (phdr->p_type != PT_LOAD)
 367         return 0;
 368       nr_phdrs++;
 369       if (phdr->p_paddr < segments_start)
 370         segments_start = phdr->p_paddr;
 371       if (phdr->p_paddr + phdr->p_memsz > segments_end)
 372         segments_end = phdr->p_paddr + phdr->p_memsz;
 373       return 0;
 374     }
 375
 376   grub_elf64_phdr_iterate (elf, calcsize, 0);
 377
 378   if (nr_phdrs == 0)
 379     {
 380       grub_error (GRUB_ERR_BAD_OS, "No program headers present");
 381       return 0;
 382     }
 383
 384   if (segments_end < segments_start)
 385     {
 386       /* Very bad addresses.  */
 387       grub_error (GRUB_ERR_BAD_OS, "Bad program header load addresses");
 388       return 0;
 389     }
 390
 391   return segments_end - segments_start;
 392 }
 393
 394
 395 /* Load every loadable segment into memory specified by `_load_hook'.  */
 396 grub_err_t
 397 grub_elf64_load (grub_elf_t _elf, grub_elf64_load_hook_t _load_hook,
 398                  grub_addr_t *base, grub_size_t *size)
 399 {
 400   grub_addr_t load_base = (grub_addr_t) -1ULL;
 401   grub_size_t load_size = 0;
 402   grub_err_t err;
 403
 404   auto int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr,
 405                                                      void *hook);
 406   int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, void *hook)
 407   {
 408     grub_elf64_load_hook_t load_hook = (grub_elf64_load_hook_t) hook;
 409     grub_addr_t load_addr;
 410
 411     if (phdr->p_type != PT_LOAD)
 412       return 0;
 413
 414     load_addr = phdr->p_paddr;
 415     if (load_hook && load_hook (phdr, &load_addr))
 416       return 1;
 417
 418     if (load_addr < load_base)
 419       load_base = load_addr;
 420
 421     grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
 422                   (unsigned long long) load_addr,
 423                   (unsigned long long) phdr->p_memsz);
 424
 425     if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)
 426       {
 427         grub_error_push ();
 428         return grub_error (GRUB_ERR_BAD_OS,
 429                            "Invalid offset in program header.");
 430       }
 431
 432     if (phdr->p_filesz)
 433       {
 434         grub_ssize_t read;
 435         read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
 436         if (read != (grub_ssize_t) phdr->p_filesz)
 437           {
 438             /* XXX How can we free memory from `load_hook'?  */
 439             grub_error_push ();
 440             return grub_error (GRUB_ERR_BAD_OS,
 441                               "Couldn't read segment from file: "
 442                               "wanted 0x%lx bytes; read 0x%lx bytes.",
 443                               phdr->p_filesz, read);
 444           }
 445       }
 446
 447     if (phdr->p_filesz < phdr->p_memsz)
 448       grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
 449                    0, phdr->p_memsz - phdr->p_filesz);
 450
 451     load_size += phdr->p_memsz;
 452
 453     return 0;
 454   }
 455
 456   err = grub_elf64_phdr_iterate (_elf, grub_elf64_load_segment, _load_hook);
 457
 458   if (base)
 459     *base = load_base;
 460   if (size)
 461     *size = load_size;
 462
 463   return err;
 464 }