kern/dl.c

   1 /* dl.c - loadable module support */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2002,2003,2004,2005,2007,2008,2009  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 /* Force native word size */
  21 #define GRUB_TARGET_WORDSIZE (8 * GRUB_CPU_SIZEOF_VOID_P)
  22
  23 #include <config.h>
  24 #include <grub/elf.h>
  25 #include <grub/dl.h>
  26 #include <grub/misc.h>
  27 #include <grub/mm.h>
  28 #include <grub/err.h>
  29 #include <grub/types.h>
  30 #include <grub/symbol.h>
  31 #include <grub/file.h>
  32 #include <grub/env.h>
  33 #include <grub/cache.h>
  34 #include <grub/machine/machine.h>
  35
  36 /* Platforms where modules are in a readonly area of memory.  */
  37 #if defined(GRUB_MACHINE_QEMU)
  38 #define GRUB_MODULES_MACHINE_READONLY
  39 #endif
  40
  41 \f
  42
  43 struct grub_dl_list
  44 {
  45   struct grub_dl_list *next;
  46   grub_dl_t mod;
  47 };
  48 typedef struct grub_dl_list *grub_dl_list_t;
  49
  50 static grub_dl_list_t grub_dl_head;
  51
  52 static grub_err_t
  53 grub_dl_add (grub_dl_t mod)
  54 {
  55   grub_dl_list_t l;
  56
  57   if (grub_dl_get (mod->name))
  58     return grub_error (GRUB_ERR_BAD_MODULE,
  59                        "`%s' is already loaded", mod->name);
  60
  61   l = (grub_dl_list_t) grub_malloc (sizeof (*l));
  62   if (! l)
  63     return grub_errno;
  64
  65   l->mod = mod;
  66   l->next = grub_dl_head;
  67   grub_dl_head = l;
  68
  69   return GRUB_ERR_NONE;
  70 }
  71
  72 static void
  73 grub_dl_remove (grub_dl_t mod)
  74 {
  75   grub_dl_list_t *p, q;
  76
  77   for (p = &grub_dl_head, q = *p; q; p = &q->next, q = *p)
  78     if (q->mod == mod)
  79       {
  80         *p = q->next;
  81         grub_free (q);
  82         return;
  83       }
  84 }
  85
  86 grub_dl_t
  87 grub_dl_get (const char *name)
  88 {
  89   grub_dl_list_t l;
  90
  91   for (l = grub_dl_head; l; l = l->next)
  92     if (grub_strcmp (name, l->mod->name) == 0)
  93       return l->mod;
  94
  95   return 0;
  96 }
  97
  98 void
  99 grub_dl_iterate (int (*hook) (grub_dl_t mod))
 100 {
 101   grub_dl_list_t l;
 102
 103   for (l = grub_dl_head; l; l = l->next)
 104     if (hook (l->mod))
 105       break;
 106 }
 107
 108 \f
 109
 110 struct grub_symbol
 111 {
 112   struct grub_symbol *next;
 113   const char *name;
 114   void *addr;
 115   grub_dl_t mod;        /* The module to which this symbol belongs.  */
 116 };
 117 typedef struct grub_symbol *grub_symbol_t;
 118
 119 /* The size of the symbol table.  */
 120 #define GRUB_SYMTAB_SIZE        509
 121
 122 /* The symbol table (using an open-hash).  */
 123 static struct grub_symbol *grub_symtab[GRUB_SYMTAB_SIZE];
 124
 125 /* Simple hash function.  */
 126 static unsigned
 127 grub_symbol_hash (const char *s)
 128 {
 129   unsigned key = 0;
 130
 131   while (*s)
 132     key = key * 65599 + *s++;
 133
 134   return (key + (key >> 5)) % GRUB_SYMTAB_SIZE;
 135 }
 136
 137 /* Resolve the symbol name NAME and return the address.
 138    Return NULL, if not found.  */
 139 static void *
 140 grub_dl_resolve_symbol (const char *name)
 141 {
 142   grub_symbol_t sym;
 143
 144   for (sym = grub_symtab[grub_symbol_hash (name)]; sym; sym = sym->next)
 145     if (grub_strcmp (sym->name, name) == 0)
 146       return sym->addr;
 147
 148   return 0;
 149 }
 150
 151 /* Register a symbol with the name NAME and the address ADDR.  */
 152 grub_err_t
 153 grub_dl_register_symbol (const char *name, void *addr, grub_dl_t mod)
 154 {
 155   grub_symbol_t sym;
 156   unsigned k;
 157
 158   sym = (grub_symbol_t) grub_malloc (sizeof (*sym));
 159   if (! sym)
 160     return grub_errno;
 161
 162   if (mod)
 163     {
 164       sym->name = grub_strdup (name);
 165       if (! sym->name)
 166         {
 167           grub_free (sym);
 168           return grub_errno;
 169         }
 170     }
 171   else
 172     sym->name = name;
 173
 174   sym->addr = addr;
 175   sym->mod = mod;
 176
 177   k = grub_symbol_hash (name);
 178   sym->next = grub_symtab[k];
 179   grub_symtab[k] = sym;
 180
 181   return GRUB_ERR_NONE;
 182 }
 183
 184 /* Unregister all the symbols defined in the module MOD.  */
 185 static void
 186 grub_dl_unregister_symbols (grub_dl_t mod)
 187 {
 188   unsigned i;
 189
 190   if (! mod)
 191     grub_fatal ("core symbols cannot be unregistered");
 192
 193   for (i = 0; i < GRUB_SYMTAB_SIZE; i++)
 194     {
 195       grub_symbol_t sym, *p, q;
 196
 197       for (p = &grub_symtab[i], sym = *p; sym; sym = q)
 198         {
 199           q = sym->next;
 200           if (sym->mod == mod)
 201             {
 202               *p = q;
 203               grub_free ((void *) sym->name);
 204               grub_free (sym);
 205             }
 206           else
 207             p = &sym->next;
 208         }
 209     }
 210 }
 211
 212 /* Return the address of a section whose index is N.  */
 213 static void *
 214 grub_dl_get_section_addr (grub_dl_t mod, unsigned n)
 215 {
 216   grub_dl_segment_t seg;
 217
 218   for (seg = mod->segment; seg; seg = seg->next)
 219     if (seg->section == n)
 220       return seg->addr;
 221
 222   return 0;
 223 }
 224
 225 /* Check if EHDR is a valid ELF header.  */
 226 static grub_err_t
 227 grub_dl_check_header (void *ehdr, grub_size_t size)
 228 {
 229   Elf_Ehdr *e = ehdr;
 230
 231   /* Check the header size.  */
 232   if (size < sizeof (Elf_Ehdr))
 233     return grub_error (GRUB_ERR_BAD_OS, "ELF header smaller than expected");
 234
 235   /* Check the magic numbers.  */
 236   if (grub_arch_dl_check_header (ehdr)
 237       || e->e_ident[EI_MAG0] != ELFMAG0
 238       || e->e_ident[EI_MAG1] != ELFMAG1
 239       || e->e_ident[EI_MAG2] != ELFMAG2
 240       || e->e_ident[EI_MAG3] != ELFMAG3
 241       || e->e_ident[EI_VERSION] != EV_CURRENT
 242       || e->e_version != EV_CURRENT)
 243     return grub_error (GRUB_ERR_BAD_OS, "invalid arch independent ELF magic");
 244
 245   return GRUB_ERR_NONE;
 246 }
 247
 248 /* Load all segments from memory specified by E.  */
 249 static grub_err_t
 250 grub_dl_load_segments (grub_dl_t mod, const Elf_Ehdr *e)
 251 {
 252   unsigned i;
 253   Elf_Shdr *s;
 254
 255   for (i = 0, s = (Elf_Shdr *)((char *) e + e->e_shoff);
 256        i < e->e_shnum;
 257        i++, s = (Elf_Shdr *)((char *) s + e->e_shentsize))
 258     {
 259       if (s->sh_flags & SHF_ALLOC)
 260         {
 261           grub_dl_segment_t seg;
 262
 263           seg = (grub_dl_segment_t) grub_malloc (sizeof (*seg));
 264           if (! seg)
 265             return grub_errno;
 266
 267           if (s->sh_size)
 268             {
 269               void *addr;
 270
 271               addr = grub_memalign (s->sh_addralign, s->sh_size);
 272               if (! addr)
 273                 {
 274                   grub_free (seg);
 275                   return grub_errno;
 276                 }
 277
 278               switch (s->sh_type)
 279                 {
 280                 case SHT_PROGBITS:
 281                   grub_memcpy (addr, (char *) e + s->sh_offset, s->sh_size);
 282                   break;
 283                 case SHT_NOBITS:
 284                   grub_memset (addr, 0, s->sh_size);
 285                   break;
 286                 }
 287
 288               seg->addr = addr;
 289             }
 290           else
 291             seg->addr = 0;
 292
 293           seg->size = s->sh_size;
 294           seg->section = i;
 295           seg->next = mod->segment;
 296           mod->segment = seg;
 297         }
 298     }
 299
 300   return GRUB_ERR_NONE;
 301 }
 302
 303 static grub_err_t
 304 grub_dl_resolve_symbols (grub_dl_t mod, Elf_Ehdr *e)
 305 {
 306   unsigned i;
 307   Elf_Shdr *s;
 308   Elf_Sym *sym;
 309   const char *str;
 310   Elf_Word size, entsize;
 311
 312   for (i = 0, s = (Elf_Shdr *) ((char *) e + e->e_shoff);
 313        i < e->e_shnum;
 314        i++, s = (Elf_Shdr *) ((char *) s + e->e_shentsize))
 315     if (s->sh_type == SHT_SYMTAB)
 316       break;
 317
 318   if (i == e->e_shnum)
 319     return grub_error (GRUB_ERR_BAD_MODULE, "no symbol table");
 320
 321 #ifdef GRUB_MODULES_MACHINE_READONLY
 322   mod->symtab = grub_malloc (s->sh_size);
 323   memcpy (mod->symtab, (char *) e + s->sh_offset, s->sh_size);
 324 #else
 325   mod->symtab = (Elf_Sym *) ((char *) e + s->sh_offset);
 326 #endif
 327   sym = mod->symtab;
 328   size = s->sh_size;
 329   entsize = s->sh_entsize;
 330
 331   s = (Elf_Shdr *) ((char *) e + e->e_shoff + e->e_shentsize * s->sh_link);
 332   str = (char *) e + s->sh_offset;
 333
 334   for (i = 0;
 335        i < size / entsize;
 336        i++, sym = (Elf_Sym *) ((char *) sym + entsize))
 337     {
 338       unsigned char type = ELF_ST_TYPE (sym->st_info);
 339       unsigned char bind = ELF_ST_BIND (sym->st_info);
 340       const char *name = str + sym->st_name;
 341
 342       switch (type)
 343         {
 344         case STT_NOTYPE:
 345           /* Resolve a global symbol.  */
 346           if (sym->st_name != 0 && sym->st_shndx == 0)
 347             {
 348               sym->st_value = (Elf_Addr) grub_dl_resolve_symbol (name);
 349               if (! sym->st_value)
 350                 return grub_error (GRUB_ERR_BAD_MODULE,
 351                                    "the symbol `%s' not found", name);
 352             }
 353           else
 354             sym->st_value = 0;
 355           break;
 356
 357         case STT_OBJECT:
 358           sym->st_value += (Elf_Addr) grub_dl_get_section_addr (mod,
 359                                                                 sym->st_shndx);
 360           if (bind != STB_LOCAL)
 361             if (grub_dl_register_symbol (name, (void *) sym->st_value, mod))
 362               return grub_errno;
 363           break;
 364
 365         case STT_FUNC:
 366           sym->st_value += (Elf_Addr) grub_dl_get_section_addr (mod,
 367                                                                 sym->st_shndx);
 368           if (bind != STB_LOCAL)
 369             if (grub_dl_register_symbol (name, (void *) sym->st_value, mod))
 370               return grub_errno;
 371
 372           if (grub_strcmp (name, "grub_mod_init") == 0)
 373             mod->init = (void (*) (grub_dl_t)) sym->st_value;
 374           else if (grub_strcmp (name, "grub_mod_fini") == 0)
 375             mod->fini = (void (*) (void)) sym->st_value;
 376           break;
 377
 378         case STT_SECTION:
 379           sym->st_value = (Elf_Addr) grub_dl_get_section_addr (mod,
 380                                                                sym->st_shndx);
 381           break;
 382
 383         case STT_FILE:
 384           sym->st_value = 0;
 385           break;
 386
 387         default:
 388           return grub_error (GRUB_ERR_BAD_MODULE,
 389                              "unknown symbol type `%d'", (int) type);
 390         }
 391     }
 392
 393   return GRUB_ERR_NONE;
 394 }
 395
 396 static void
 397 grub_dl_call_init (grub_dl_t mod)
 398 {
 399   if (mod->init)
 400     (mod->init) (mod);
 401 }
 402
 403 static grub_err_t
 404 grub_dl_resolve_name (grub_dl_t mod, Elf_Ehdr *e)
 405 {
 406   Elf_Shdr *s;
 407   const char *str;
 408   unsigned i;
 409
 410   s = (Elf_Shdr *) ((char *) e + e->e_shoff + e->e_shstrndx * e->e_shentsize);
 411   str = (char *) e + s->sh_offset;
 412
 413   for (i = 0, s = (Elf_Shdr *) ((char *) e + e->e_shoff);
 414        i < e->e_shnum;
 415        i++, s = (Elf_Shdr *) ((char *) s + e->e_shentsize))
 416     if (grub_strcmp (str + s->sh_name, ".modname") == 0)
 417       {
 418         mod->name = grub_strdup ((char *) e + s->sh_offset);
 419         if (! mod->name)
 420           return grub_errno;
 421         break;
 422       }
 423
 424   if (i == e->e_shnum)
 425     return grub_error (GRUB_ERR_BAD_MODULE, "no module name found");
 426
 427   return GRUB_ERR_NONE;
 428 }
 429
 430 static grub_err_t
 431 grub_dl_resolve_dependencies (grub_dl_t mod, Elf_Ehdr *e)
 432 {
 433   Elf_Shdr *s;
 434   const char *str;
 435   unsigned i;
 436
 437   s = (Elf_Shdr *) ((char *) e + e->e_shoff + e->e_shstrndx * e->e_shentsize);
 438   str = (char *) e + s->sh_offset;
 439
 440   for (i = 0, s = (Elf_Shdr *) ((char *) e + e->e_shoff);
 441        i < e->e_shnum;
 442        i++, s = (Elf_Shdr *) ((char *) s + e->e_shentsize))
 443     if (grub_strcmp (str + s->sh_name, ".moddeps") == 0)
 444       {
 445         const char *name = (char *) e + s->sh_offset;
 446         const char *max = name + s->sh_size;
 447
 448         while ((name < max) && (*name))
 449           {
 450             grub_dl_t m;
 451             grub_dl_dep_t dep;
 452
 453             m = grub_dl_load (name);
 454             if (! m)
 455               return grub_errno;
 456
 457             grub_dl_ref (m);
 458
 459             dep = (grub_dl_dep_t) grub_malloc (sizeof (*dep));
 460             if (! dep)
 461               return grub_errno;
 462
 463             dep->mod = m;
 464             dep->next = mod->dep;
 465             mod->dep = dep;
 466
 467             name += grub_strlen (name) + 1;
 468           }
 469       }
 470
 471   return GRUB_ERR_NONE;
 472 }
 473
 474 #ifndef GRUB_UTIL
 475 int
 476 grub_dl_ref (grub_dl_t mod)
 477 {
 478   grub_dl_dep_t dep;
 479
 480   for (dep = mod->dep; dep; dep = dep->next)
 481     grub_dl_ref (dep->mod);
 482
 483   return ++mod->ref_count;
 484 }
 485
 486 int
 487 grub_dl_unref (grub_dl_t mod)
 488 {
 489   grub_dl_dep_t dep;
 490
 491   for (dep = mod->dep; dep; dep = dep->next)
 492     grub_dl_unref (dep->mod);
 493
 494   return --mod->ref_count;
 495 }
 496 #endif
 497
 498 static void
 499 grub_dl_flush_cache (grub_dl_t mod)
 500 {
 501   grub_dl_segment_t seg;
 502
 503   for (seg = mod->segment; seg; seg = seg->next) {
 504     if (seg->size) {
 505       grub_dprintf ("modules", "flushing 0x%lx bytes at %p\n",
 506                     (unsigned long) seg->size, seg->addr);
 507       grub_arch_sync_caches (seg->addr, seg->size);
 508     }
 509   }
 510 }
 511
 512 /* Load a module from core memory.  */
 513 grub_dl_t
 514 grub_dl_load_core (void *addr, grub_size_t size)
 515 {
 516   Elf_Ehdr *e;
 517   grub_dl_t mod;
 518
 519   grub_dprintf ("modules", "module at %p, size 0x%lx\n", addr,
 520                 (unsigned long) size);
 521   e = addr;
 522   if (grub_dl_check_header (e, size))
 523     return 0;
 524
 525   if (e->e_type != ET_REL)
 526     {
 527       grub_error (GRUB_ERR_BAD_MODULE, "invalid ELF file type");
 528       return 0;
 529     }
 530
 531   /* Make sure that every section is within the core.  */
 532   if (size < e->e_shoff + e->e_shentsize * e->e_shnum)
 533     {
 534       grub_error (GRUB_ERR_BAD_OS, "ELF sections outside core");
 535       return 0;
 536     }
 537
 538   mod = (grub_dl_t) grub_zalloc (sizeof (*mod));
 539   if (! mod)
 540     return 0;
 541
 542   mod->ref_count = 1;
 543
 544   grub_dprintf ("modules", "relocating to %p\n", mod);
 545   if (grub_dl_resolve_name (mod, e)
 546       || grub_dl_resolve_dependencies (mod, e)
 547       || grub_dl_load_segments (mod, e)
 548       || grub_dl_resolve_symbols (mod, e)
 549       || grub_arch_dl_relocate_symbols (mod, e))
 550     {
 551       mod->fini = 0;
 552       grub_dl_unload (mod);
 553       return 0;
 554     }
 555
 556   grub_dl_flush_cache (mod);
 557
 558   grub_dprintf ("modules", "module name: %s\n", mod->name);
 559   grub_dprintf ("modules", "init function: %p\n", mod->init);
 560   grub_dl_call_init (mod);
 561
 562   if (grub_dl_add (mod))
 563     {
 564       grub_dl_unload (mod);
 565       return 0;
 566     }
 567
 568   return mod;
 569 }
 570
 571 /* Load a module from the file FILENAME.  */
 572 grub_dl_t
 573 grub_dl_load_file (const char *filename)
 574 {
 575   grub_file_t file = NULL;
 576   grub_ssize_t size;
 577   void *core = 0;
 578   grub_dl_t mod = 0;
 579
 580   file = grub_file_open (filename);
 581   if (! file)
 582     return 0;
 583
 584   size = grub_file_size (file);
 585   core = grub_malloc (size);
 586   if (! core)
 587     {
 588       grub_file_close (file);
 589       return 0;
 590     }
 591
 592   if (grub_file_read (file, core, size) != (int) size)
 593     {
 594       grub_file_close (file);
 595       grub_free (core);
 596       return 0;
 597     }
 598
 599   /* We must close this before we try to process dependencies.
 600      Some disk backends do not handle gracefully multiple concurrent
 601      opens of the same device.  */
 602   grub_file_close (file);
 603
 604   mod = grub_dl_load_core (core, size);
 605   if (! mod)
 606     {
 607       grub_free (core);
 608       return 0;
 609     }
 610
 611   mod->ref_count = 0;
 612   return mod;
 613 }
 614
 615 /* Load a module using a symbolic name.  */
 616 grub_dl_t
 617 grub_dl_load (const char *name)
 618 {
 619   char *filename;
 620   grub_dl_t mod;
 621   char *grub_dl_dir = grub_env_get ("prefix");
 622
 623   mod = grub_dl_get (name);
 624   if (mod)
 625     return mod;
 626
 627   if (! grub_dl_dir) {
 628     grub_error (GRUB_ERR_FILE_NOT_FOUND, "\"prefix\" is not set");
 629     return 0;
 630   }
 631
 632   filename = (char *) grub_malloc (grub_strlen (grub_dl_dir) + 1
 633                                    + grub_strlen (name) + 4 + 1);
 634   if (! filename)
 635     return 0;
 636
 637   grub_sprintf (filename, "%s/%s.mod", grub_dl_dir, name);
 638   mod = grub_dl_load_file (filename);
 639   grub_free (filename);
 640
 641   if (! mod)
 642     return 0;
 643
 644   if (grub_strcmp (mod->name, name) != 0)
 645     grub_error (GRUB_ERR_BAD_MODULE, "mismatched names");
 646
 647   return mod;
 648 }
 649
 650 /* Unload the module MOD.  */
 651 int
 652 grub_dl_unload (grub_dl_t mod)
 653 {
 654   grub_dl_dep_t dep, depn;
 655   grub_dl_segment_t seg, segn;
 656
 657   if (mod->ref_count > 0)
 658     return 0;
 659
 660   if (mod->fini)
 661     (mod->fini) ();
 662
 663   grub_dl_remove (mod);
 664   grub_dl_unregister_symbols (mod);
 665
 666   for (dep = mod->dep; dep; dep = depn)
 667     {
 668       depn = dep->next;
 669
 670       if (! grub_dl_unref (dep->mod))
 671         grub_dl_unload (dep->mod);
 672
 673       grub_free (dep);
 674     }
 675
 676   for (seg = mod->segment; seg; seg = segn)
 677     {
 678       segn = seg->next;
 679       grub_free (seg->addr);
 680       grub_free (seg);
 681     }
 682
 683   grub_free (mod->name);
 684 #ifdef GRUB_MODULES_MACHINE_READONLY
 685   grub_free (mod->symtab);
 686 #endif
 687   grub_free (mod);
 688   return 1;
 689 }
 690
 691 /* Unload unneeded modules.  */
 692 void
 693 grub_dl_unload_unneeded (void)
 694 {
 695   /* Because grub_dl_remove modifies the list of modules, this
 696      implementation is tricky.  */
 697   grub_dl_list_t p = grub_dl_head;
 698
 699   while (p)
 700     {
 701       if (grub_dl_unload (p->mod))
 702         {
 703           p = grub_dl_head;
 704           continue;
 705         }
 706
 707       p = p->next;
 708     }
 709 }
 710
 711 /* Unload all modules.  */
 712 void
 713 grub_dl_unload_all (void)
 714 {
 715   while (grub_dl_head)
 716     {
 717       grub_dl_list_t p;
 718
 719       grub_dl_unload_unneeded ();
 720
 721       /* Force to decrement the ref count. This will purge pre-loaded
 722          modules and manually inserted modules.  */
 723       for (p = grub_dl_head; p; p = p->next)
 724         p->mod->ref_count--;
 725     }
 726 }