grub-core/kern/mips/dl.c

   1 /* dl-386.c - arch-dependent part of loadable module support */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2002,2005,2007,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 #include <grub/dl.h>
  21 #include <grub/elf.h>
  22 #include <grub/misc.h>
  23 #include <grub/err.h>
  24 #include <grub/cpu/types.h>
  25 #include <grub/mm.h>
  26 #include <grub/i18n.h>
  27
  28 /* Dummy __gnu_local_gp. Resolved by linker.  */
  29 static char __gnu_local_gp_dummy;
  30 static char _gp_disp_dummy;
  31
  32 /* Check if EHDR is a valid ELF header.  */
  33 grub_err_t
  34 grub_arch_dl_check_header (void *ehdr)
  35 {
  36   Elf_Ehdr *e = ehdr;
  37
  38   /* Check the magic numbers.  */
  39 #ifdef GRUB_CPU_WORDS_BIGENDIAN
  40   if (e->e_ident[EI_CLASS] != ELFCLASS32
  41       || e->e_ident[EI_DATA] != ELFDATA2MSB
  42       || e->e_machine != EM_MIPS)
  43 #else
  44   if (e->e_ident[EI_CLASS] != ELFCLASS32
  45       || e->e_ident[EI_DATA] != ELFDATA2LSB
  46       || e->e_machine != EM_MIPS)
  47 #endif
  48     return grub_error (GRUB_ERR_BAD_OS, N_("invalid arch-dependent ELF magic"));
  49
  50   return GRUB_ERR_NONE;
  51 }
  52
  53 #pragma GCC diagnostic ignored "-Wcast-align"
  54
  55 grub_err_t
  56 grub_arch_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp,
  57                                  grub_size_t *got)
  58 {
  59   const Elf_Ehdr *e = ehdr;
  60   const Elf_Shdr *s;
  61   /* FIXME: suboptimal.  */
  62   grub_size_t gp_size = 0;
  63   unsigned i;
  64
  65   *tramp = 0;
  66   *got = 0;
  67
  68   for (i = 0, s = (const Elf_Shdr *) ((const char *) e + e->e_shoff);
  69        i < e->e_shnum;
  70        i++, s = (const Elf_Shdr *) ((const char *) s + e->e_shentsize))
  71     if (s->sh_type == SHT_REL)
  72       {
  73         const Elf_Rel *rel, *max;
  74
  75         for (rel = (const Elf_Rel *) ((const char *) e + s->sh_offset),
  76                max = rel + s->sh_size / s->sh_entsize;
  77              rel < max;
  78              rel++)
  79           switch (ELF_R_TYPE (rel->r_info))
  80             {
  81             case R_MIPS_GOT16:
  82             case R_MIPS_CALL16:
  83             case R_MIPS_GPREL32:
  84               gp_size += 4;
  85               break;
  86             }
  87       }
  88
  89   if (gp_size > 0x08000)
  90     return grub_error (GRUB_ERR_OUT_OF_RANGE, "__gnu_local_gp is too big\n");
  91
  92   *got = gp_size;
  93
  94   return GRUB_ERR_NONE;
  95 }
  96
  97 /* Relocate symbols.  */
  98 grub_err_t
  99 grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 100                                Elf_Shdr *s, grub_dl_segment_t seg)
 101 {
 102   grub_uint32_t gp0;
 103   Elf_Ehdr *e = ehdr;
 104
 105   if (!mod->reginfo)
 106     {
 107       unsigned i;
 108       Elf_Shdr *ri;
 109
 110       /* Find reginfo. */
 111       for (i = 0, ri = (Elf_Shdr *) ((char *) ehdr + e->e_shoff);
 112            i < e->e_shnum;
 113            i++, ri = (Elf_Shdr *) ((char *) ri + e->e_shentsize))
 114         if (ri->sh_type == SHT_MIPS_REGINFO)
 115           break;
 116       if (i == e->e_shnum)
 117         return grub_error (GRUB_ERR_BAD_MODULE, "no reginfo found");
 118       mod->reginfo = (grub_uint32_t *)((char *) ehdr + ri->sh_offset);
 119     }
 120
 121   gp0 = mod->reginfo[5];
 122   Elf_Rel *rel, *max;
 123
 124   for (rel = (Elf_Rel *) ((char *) e + s->sh_offset),
 125          max = (Elf_Rel *) ((char *) rel + s->sh_size);
 126        rel < max;
 127        rel = (Elf_Rel *) ((char *) rel + s->sh_entsize))
 128     {
 129       grub_uint8_t *addr;
 130       Elf_Sym *sym;
 131       grub_uint32_t sym_value;
 132
 133       if (seg->size < rel->r_offset)
 134         return grub_error (GRUB_ERR_BAD_MODULE,
 135                            "reloc offset is out of the segment");
 136
 137       addr = (grub_uint8_t *) ((char *) seg->addr + rel->r_offset);
 138       sym = (Elf_Sym *) ((char *) mod->symtab
 139                          + mod->symsize * ELF_R_SYM (rel->r_info));
 140       sym_value = sym->st_value;
 141       if (s->sh_type == SHT_RELA)
 142         {
 143           sym_value += ((Elf_Rela *) rel)->r_addend;
 144         }
 145       if (sym_value == (grub_addr_t) &__gnu_local_gp_dummy)
 146         sym_value = (grub_addr_t) mod->got;
 147       else if (sym_value == (grub_addr_t) &_gp_disp_dummy)
 148         {
 149           sym_value = (grub_addr_t) mod->got - (grub_addr_t) addr;
 150           if (ELF_R_TYPE (rel->r_info) == R_MIPS_LO16)
 151             /* ABI mandates +4 even if partner lui doesn't
 152                immediately precede addiu.  */
 153             sym_value += 4;
 154         }
 155       switch (ELF_R_TYPE (rel->r_info))
 156         {
 157         case R_MIPS_HI16:
 158           {
 159             grub_uint32_t value;
 160             Elf_Rel *rel2;
 161
 162 #ifdef GRUB_CPU_WORDS_BIGENDIAN
 163             addr += 2;
 164 #endif
 165
 166             /* Handle partner lo16 relocation. Lower part is
 167                treated as signed. Hence add 0x8000 to compensate.
 168             */
 169             value = (*(grub_uint16_t *) addr << 16)
 170               + sym_value + 0x8000;
 171             for (rel2 = rel + 1; rel2 < max; rel2++)
 172               if (ELF_R_SYM (rel2->r_info)
 173                   == ELF_R_SYM (rel->r_info)
 174                   && ELF_R_TYPE (rel2->r_info) == R_MIPS_LO16)
 175                 {
 176                   value += *(grub_int16_t *)
 177                     ((char *) seg->addr + rel2->r_offset
 178 #ifdef GRUB_CPU_WORDS_BIGENDIAN
 179                      + 2
 180 #endif
 181                      );
 182                   break;
 183                 }
 184             *(grub_uint16_t *) addr = (value >> 16) & 0xffff;
 185           }
 186           break;
 187         case R_MIPS_LO16:
 188 #ifdef GRUB_CPU_WORDS_BIGENDIAN
 189           addr += 2;
 190 #endif
 191           *(grub_uint16_t *) addr += sym_value & 0xffff;
 192           break;
 193         case R_MIPS_32:
 194           *(grub_uint32_t *) addr += sym_value;
 195           break;
 196         case R_MIPS_GPREL32:
 197           *(grub_uint32_t *) addr = sym_value
 198             + *(grub_uint32_t *) addr + gp0 - (grub_uint32_t)mod->got;
 199           break;
 200
 201         case R_MIPS_26:
 202           {
 203             grub_uint32_t value;
 204             grub_uint32_t raw;
 205             raw = (*(grub_uint32_t *) addr) & 0x3ffffff;
 206             value = raw << 2;
 207             value += sym_value;
 208             raw = (value >> 2) & 0x3ffffff;
 209
 210             *(grub_uint32_t *) addr =
 211               raw | ((*(grub_uint32_t *) addr) & 0xfc000000);
 212           }
 213           break;
 214         case R_MIPS_GOT16:
 215           if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
 216             {
 217               Elf_Rel *rel2;
 218               /* Handle partner lo16 relocation. Lower part is
 219                  treated as signed. Hence add 0x8000 to compensate.
 220               */
 221               sym_value += (*(grub_uint16_t *) addr << 16)
 222                 + 0x8000;
 223               for (rel2 = rel + 1; rel2 < max; rel2++)
 224                 if (ELF_R_SYM (rel2->r_info)
 225                     == ELF_R_SYM (rel->r_info)
 226                     && ELF_R_TYPE (rel2->r_info) == R_MIPS_LO16)
 227                   {
 228                     sym_value += *(grub_int16_t *)
 229                       ((char *) seg->addr + rel2->r_offset
 230 #ifdef GRUB_CPU_WORDS_BIGENDIAN
 231                        + 2
 232 #endif
 233                        );
 234                     break;
 235                   }
 236               sym_value &= 0xffff0000;
 237               *(grub_uint16_t *) addr = 0;
 238             }
 239           /* Fallthrough.  */
 240         case R_MIPS_CALL16:
 241           {
 242             grub_uint32_t *gpptr = mod->gotptr;
 243           /* FIXME: reuse*/
 244 #ifdef GRUB_CPU_WORDS_BIGENDIAN
 245             addr += 2;
 246 #endif
 247             *gpptr = sym_value + *(grub_uint16_t *) addr;
 248             *(grub_uint16_t *) addr
 249               = sizeof (grub_uint32_t) * (gpptr - (grub_uint32_t *) mod->got);
 250             mod->gotptr = gpptr + 1;
 251             break;
 252           }
 253         case R_MIPS_JALR:
 254           break;
 255         default:
 256           {
 257             return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
 258                                N_("relocation 0x%x is not implemented yet"),
 259                                ELF_R_TYPE (rel->r_info));
 260           }
 261           break;
 262         }
 263     }
 264
 265   return GRUB_ERR_NONE;
 266 }
 267
 268 void
 269 grub_arch_dl_init_linker (void)
 270 {
 271   grub_dl_register_symbol ("__gnu_local_gp", &__gnu_local_gp_dummy, 0, 0);
 272   grub_dl_register_symbol ("_gp_disp", &_gp_disp_dummy, 0, 0);
 273 }
 274