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     int do_load = 1;
 232
 233     load_addr = phdr->p_paddr;
 234     if (load_hook && load_hook (phdr, &load_addr, &do_load))
 235       return 1;
 236
 237     if (! do_load)
 238       return 0;
 239
 240     if (load_addr < load_base)
 241       load_base = load_addr;
 242
 243     grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
 244                   (unsigned long long) load_addr,
 245                   (unsigned long long) phdr->p_memsz);
 246
 247     if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)
 248       {
 249         grub_error_push ();
 250         return grub_error (GRUB_ERR_BAD_OS,
 251                            "Invalid offset in program header.");
 252       }
 253
 254     if (phdr->p_filesz)
 255       {
 256         grub_ssize_t read;
 257         read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
 258         if (read != (grub_ssize_t) phdr->p_filesz)
 259           {
 260             /* XXX How can we free memory from `load_hook'? */
 261             grub_error_push ();
 262             return grub_error (GRUB_ERR_BAD_OS,
 263                                "Couldn't read segment from file: "
 264                                "wanted 0x%lx bytes; read 0x%lx bytes.",
 265                                phdr->p_filesz, read);
 266           }
 267       }
 268
 269     if (phdr->p_filesz < phdr->p_memsz)
 270       grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
 271                    0, phdr->p_memsz - phdr->p_filesz);
 272
 273     load_size += phdr->p_memsz;
 274
 275     return 0;
 276   }
 277
 278   err = grub_elf32_phdr_iterate (_elf, grub_elf32_load_segment, _load_hook);
 279
 280   if (base)
 281     *base = load_base;
 282   if (size)
 283     *size = load_size;
 284
 285   return err;
 286 }
 287
 288
 289 \f
 290 /* 64-bit */
 291
 292 int
 293 grub_elf_is_elf64 (grub_elf_t elf)
 294 {
 295   return elf->ehdr.ehdr64.e_ident[EI_CLASS] == ELFCLASS64;
 296 }
 297
 298 static grub_err_t
 299 grub_elf64_load_phdrs (grub_elf_t elf)
 300 {
 301   grub_ssize_t phdrs_size;
 302
 303   phdrs_size = elf->ehdr.ehdr64.e_phnum * elf->ehdr.ehdr64.e_phentsize;
 304
 305   grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",
 306                 (unsigned long long) elf->ehdr.ehdr64.e_phoff,
 307                 (unsigned long) phdrs_size);
 308
 309   elf->phdrs = grub_malloc (phdrs_size);
 310   if (! elf->phdrs)
 311     return grub_errno;
 312
 313   if ((grub_file_seek (elf->file, elf->ehdr.ehdr64.e_phoff) == (grub_off_t) -1)
 314       || (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))
 315     {
 316       grub_error_push ();
 317       return grub_error (GRUB_ERR_READ_ERROR, "Cannot read program headers");
 318     }
 319
 320   return GRUB_ERR_NONE;
 321 }
 322
 323 static grub_err_t
 324 grub_elf64_phdr_iterate (grub_elf_t elf,
 325                          int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf64_Phdr *, void *),
 326                          void *hook_arg)
 327 {
 328   Elf64_Phdr *phdrs;
 329   unsigned int i;
 330
 331   if (! elf->phdrs)
 332     if (grub_elf64_load_phdrs (elf))
 333       return grub_errno;
 334   phdrs = elf->phdrs;
 335
 336   for (i = 0; i < elf->ehdr.ehdr64.e_phnum; i++)
 337     {
 338       Elf64_Phdr *phdr = phdrs + i;
 339       grub_dprintf ("elf",
 340                     "Segment %u: type 0x%x paddr 0x%lx memsz 0x%lx "
 341                     "filesz %lx\n",
 342                     i, phdr->p_type,
 343                     (unsigned long) phdr->p_paddr,
 344                     (unsigned long) phdr->p_memsz,
 345                     (unsigned long) phdr->p_filesz);
 346       if (hook (elf, phdr, hook_arg))
 347         break;
 348     }
 349
 350   return grub_errno;
 351 }
 352
 353 /* Calculate the amount of memory spanned by the segments.  */
 354 grub_size_t
 355 grub_elf64_size (grub_elf_t elf)
 356 {
 357   Elf64_Addr segments_start = (Elf64_Addr) -1;
 358   Elf64_Addr segments_end = 0;
 359   int nr_phdrs = 0;
 360
 361   /* Run through the program headers to calculate the total memory size we
 362    * should claim.  */
 363   auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf64_Phdr *phdr, void *_arg);
 364   int NESTED_FUNC_ATTR calcsize (grub_elf_t UNUSED _elf, Elf64_Phdr *phdr, void UNUSED *_arg)
 365     {
 366       /* Only consider loadable segments.  */
 367       if (phdr->p_type != PT_LOAD)
 368         return 0;
 369       nr_phdrs++;
 370       if (phdr->p_paddr < segments_start)
 371         segments_start = phdr->p_paddr;
 372       if (phdr->p_paddr + phdr->p_memsz > segments_end)
 373         segments_end = phdr->p_paddr + phdr->p_memsz;
 374       return 0;
 375     }
 376
 377   grub_elf64_phdr_iterate (elf, calcsize, 0);
 378
 379   if (nr_phdrs == 0)
 380     {
 381       grub_error (GRUB_ERR_BAD_OS, "No program headers present");
 382       return 0;
 383     }
 384
 385   if (segments_end < segments_start)
 386     {
 387       /* Very bad addresses.  */
 388       grub_error (GRUB_ERR_BAD_OS, "Bad program header load addresses");
 389       return 0;
 390     }
 391
 392   return segments_end - segments_start;
 393 }
 394
 395
 396 /* Load every loadable segment into memory specified by `_load_hook'.  */
 397 grub_err_t
 398 grub_elf64_load (grub_elf_t _elf, grub_elf64_load_hook_t _load_hook,
 399                  grub_addr_t *base, grub_size_t *size)
 400 {
 401   grub_addr_t load_base = (grub_addr_t) -1ULL;
 402   grub_size_t load_size = 0;
 403   grub_err_t err;
 404
 405   auto int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr,
 406                                                      void *hook);
 407   int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, void *hook)
 408   {
 409     grub_elf64_load_hook_t load_hook = (grub_elf64_load_hook_t) hook;
 410     grub_addr_t load_addr;
 411     int do_load = 1;
 412
 413     load_addr = phdr->p_paddr;
 414     if (load_hook && load_hook (phdr, &load_addr, &do_load))
 415       return 1;
 416
 417     if (! do_load)
 418       return 0;
 419
 420     if (load_addr < load_base)
 421       load_base = load_addr;
 422
 423     grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",
 424                   (unsigned long long) load_addr,
 425                   (unsigned long long) phdr->p_memsz);
 426
 427     if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)
 428       {
 429         grub_error_push ();
 430         return grub_error (GRUB_ERR_BAD_OS,
 431                            "Invalid offset in program header.");
 432       }
 433
 434     if (phdr->p_filesz)
 435       {
 436         grub_ssize_t read;
 437         read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);
 438         if (read != (grub_ssize_t) phdr->p_filesz)
 439           {
 440             /* XXX How can we free memory from `load_hook'?  */
 441             grub_error_push ();
 442             return grub_error (GRUB_ERR_BAD_OS,
 443                               "Couldn't read segment from file: "
 444                               "wanted 0x%lx bytes; read 0x%lx bytes.",
 445                               phdr->p_filesz, read);
 446           }
 447       }
 448
 449     if (phdr->p_filesz < phdr->p_memsz)
 450       grub_memset ((void *) (long) (load_addr + phdr->p_filesz),
 451                    0, phdr->p_memsz - phdr->p_filesz);
 452
 453     load_size += phdr->p_memsz;
 454
 455     return 0;
 456   }
 457
 458   err = grub_elf64_phdr_iterate (_elf, grub_elf64_load_segment, _load_hook);
 459
 460   if (base)
 461     *base = load_base;
 462   if (size)
 463     *size = load_size;
 464
 465   return err;
 466 }