Logo Search packages:      
Sourcecode: linux version File versions  Download package

module.c

/*
 * AVR32-specific kernel module loader
 *
 * Copyright (C) 2005-2006 Atmel Corporation
 *
 * GOT initialization parts are based on the s390 version
 *   Copyright (C) 2002, 2003 IBM Deutschland Entwicklung GmbH,
 *                            IBM Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/bug.h>
#include <linux/elf.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleloader.h>
#include <linux/vmalloc.h>

void *module_alloc(unsigned long size)
{
      if (size == 0)
            return NULL;
      return vmalloc(size);
}

void module_free(struct module *mod, void *module_region)
{
      vfree(mod->arch.syminfo);
      mod->arch.syminfo = NULL;

      vfree(module_region);
}

static inline int check_rela(Elf32_Rela *rela, struct module *module,
                       char *strings, Elf32_Sym *symbols)
{
      struct mod_arch_syminfo *info;

      info = module->arch.syminfo + ELF32_R_SYM(rela->r_info);
      switch (ELF32_R_TYPE(rela->r_info)) {
      case R_AVR32_GOT32:
      case R_AVR32_GOT16:
      case R_AVR32_GOT8:
      case R_AVR32_GOT21S:
      case R_AVR32_GOT18SW:   /* mcall */
      case R_AVR32_GOT16S:    /* ld.w */
            if (rela->r_addend != 0) {
                  printk(KERN_ERR
                         "GOT relocation against %s at offset %u with addend\n",
                         strings + symbols[ELF32_R_SYM(rela->r_info)].st_name,
                         rela->r_offset);
                  return -ENOEXEC;
            }
            if (info->got_offset == -1UL) {
                  info->got_offset = module->arch.got_size;
                  module->arch.got_size += sizeof(void *);
            }
            pr_debug("GOT[%3lu] %s\n", info->got_offset,
                   strings + symbols[ELF32_R_SYM(rela->r_info)].st_name);
            break;
      }

      return 0;
}

int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
                        char *secstrings, struct module *module)
{
      Elf32_Shdr *symtab;
      Elf32_Sym *symbols;
      Elf32_Rela *rela;
      char *strings;
      int nrela, i, j;
      int ret;

      /* Find the symbol table */
      symtab = NULL;
      for (i = 0; i < hdr->e_shnum; i++)
            switch (sechdrs[i].sh_type) {
            case SHT_SYMTAB:
                  symtab = &sechdrs[i];
                  break;
            }
      if (!symtab) {
            printk(KERN_ERR "module %s: no symbol table\n", module->name);
            return -ENOEXEC;
      }

      /* Allocate room for one syminfo structure per symbol. */
      module->arch.nsyms = symtab->sh_size / sizeof(Elf_Sym);
      module->arch.syminfo = vmalloc(module->arch.nsyms
                           * sizeof(struct mod_arch_syminfo));
      if (!module->arch.syminfo)
            return -ENOMEM;

      symbols = (void *)hdr + symtab->sh_offset;
      strings = (void *)hdr + sechdrs[symtab->sh_link].sh_offset;
      for (i = 0; i < module->arch.nsyms; i++) {
            if (symbols[i].st_shndx == SHN_UNDEF &&
                strcmp(strings + symbols[i].st_name,
                     "_GLOBAL_OFFSET_TABLE_") == 0)
                  /* "Define" it as absolute. */
                  symbols[i].st_shndx = SHN_ABS;
            module->arch.syminfo[i].got_offset = -1UL;
            module->arch.syminfo[i].got_initialized = 0;
      }

      /* Allocate GOT entries for symbols that need it. */
      module->arch.got_size = 0;
      for (i = 0; i < hdr->e_shnum; i++) {
            if (sechdrs[i].sh_type != SHT_RELA)
                  continue;
            nrela = sechdrs[i].sh_size / sizeof(Elf32_Rela);
            rela = (void *)hdr + sechdrs[i].sh_offset;
            for (j = 0; j < nrela; j++) {
                  ret = check_rela(rela + j, module,
                               strings, symbols);
                  if (ret)
                        goto out_free_syminfo;
            }
      }

      /*
       * Increase core size to make room for GOT and set start
       * offset for GOT.
       */
      module->core_size = ALIGN(module->core_size, 4);
      module->arch.got_offset = module->core_size;
      module->core_size += module->arch.got_size;

      return 0;

out_free_syminfo:
      vfree(module->arch.syminfo);
      module->arch.syminfo = NULL;

      return ret;
}

static inline int reloc_overflow(struct module *module, const char *reloc_name,
                         Elf32_Addr relocation)
{
      printk(KERN_ERR "module %s: Value %lx does not fit relocation %s\n",
             module->name, (unsigned long)relocation, reloc_name);
      return -ENOEXEC;
}

#define get_u16(loc)          (*((uint16_t *)loc))
#define put_u16(loc, val)     (*((uint16_t *)loc) = (val))

int apply_relocate_add(Elf32_Shdr *sechdrs, const char *strtab,
                   unsigned int symindex, unsigned int relindex,
                   struct module *module)
{
      Elf32_Shdr *symsec = sechdrs + symindex;
      Elf32_Shdr *relsec = sechdrs + relindex;
      Elf32_Shdr *dstsec = sechdrs + relsec->sh_info;
      Elf32_Rela *rel = (void *)relsec->sh_addr;
      unsigned int i;
      int ret = 0;

      for (i = 0; i < relsec->sh_size / sizeof(Elf32_Rela); i++, rel++) {
            struct mod_arch_syminfo *info;
            Elf32_Sym *sym;
            Elf32_Addr relocation;
            uint32_t *location;
            uint32_t value;

            location = (void *)dstsec->sh_addr + rel->r_offset;
            sym = (Elf32_Sym *)symsec->sh_addr + ELF32_R_SYM(rel->r_info);
            relocation = sym->st_value + rel->r_addend;

            info = module->arch.syminfo + ELF32_R_SYM(rel->r_info);

            /* Initialize GOT entry if necessary */
            switch (ELF32_R_TYPE(rel->r_info)) {
            case R_AVR32_GOT32:
            case R_AVR32_GOT16:
            case R_AVR32_GOT8:
            case R_AVR32_GOT21S:
            case R_AVR32_GOT18SW:
            case R_AVR32_GOT16S:
                  if (!info->got_initialized) {
                        Elf32_Addr *gotent;

                        gotent = (module->module_core
                                + module->arch.got_offset
                                + info->got_offset);
                        *gotent = relocation;
                        info->got_initialized = 1;
                  }

                  relocation = info->got_offset;
                  break;
            }

            switch (ELF32_R_TYPE(rel->r_info)) {
            case R_AVR32_32:
            case R_AVR32_32_CPENT:
                  *location = relocation;
                  break;
            case R_AVR32_22H_PCREL:
                  relocation -= (Elf32_Addr)location;
                  if ((relocation & 0xffe00001) != 0
                      && (relocation & 0xffc00001) != 0xffc00000)
                        return reloc_overflow(module,
                                          "R_AVR32_22H_PCREL",
                                          relocation);
                  relocation >>= 1;

                  value = *location;
                  value = ((value & 0xe1ef0000)
                         | (relocation & 0xffff)
                         | ((relocation & 0x10000) << 4)
                         | ((relocation & 0x1e0000) << 8));
                  *location = value;
                  break;
            case R_AVR32_11H_PCREL:
                  relocation -= (Elf32_Addr)location;
                  if ((relocation & 0xfffffc01) != 0
                      && (relocation & 0xfffff801) != 0xfffff800)
                        return reloc_overflow(module,
                                          "R_AVR32_11H_PCREL",
                                          relocation);
                  value = get_u16(location);
                  value = ((value & 0xf00c)
                         | ((relocation & 0x1fe) << 3)
                         | ((relocation & 0x600) >> 9));
                  put_u16(location, value);
                  break;
            case R_AVR32_9H_PCREL:
                  relocation -= (Elf32_Addr)location;
                  if ((relocation & 0xffffff01) != 0
                      && (relocation & 0xfffffe01) != 0xfffffe00)
                        return reloc_overflow(module,
                                          "R_AVR32_9H_PCREL",
                                          relocation);
                  value = get_u16(location);
                  value = ((value & 0xf00f)
                         | ((relocation & 0x1fe) << 3));
                  put_u16(location, value);
                  break;
            case R_AVR32_9UW_PCREL:
                  relocation -= ((Elf32_Addr)location) & 0xfffffffc;
                  if ((relocation & 0xfffffc03) != 0)
                        return reloc_overflow(module,
                                          "R_AVR32_9UW_PCREL",
                                          relocation);
                  value = get_u16(location);
                  value = ((value & 0xf80f)
                         | ((relocation & 0x1fc) << 2));
                  put_u16(location, value);
                  break;
            case R_AVR32_GOTPC:
                  /*
                   * R6 = PC - (PC - GOT)
                   *
                   * At this point, relocation contains the
                   * value of PC.  Just subtract the value of
                   * GOT, and we're done.
                   */
                  pr_debug("GOTPC: PC=0x%x, got_offset=0x%lx, core=0x%p\n",
                         relocation, module->arch.got_offset,
                         module->module_core);
                  relocation -= ((unsigned long)module->module_core
                               + module->arch.got_offset);
                  *location = relocation;
                  break;
            case R_AVR32_GOT18SW:
                  if ((relocation & 0xfffe0003) != 0
                      && (relocation & 0xfffc0003) != 0xffff0000)
                        return reloc_overflow(module, "R_AVR32_GOT18SW",
                                         relocation);
                  relocation >>= 2;
                  /* fall through */
            case R_AVR32_GOT16S:
                  if ((relocation & 0xffff8000) != 0
                      && (relocation & 0xffff0000) != 0xffff0000)
                        return reloc_overflow(module, "R_AVR32_GOT16S",
                                          relocation);
                  pr_debug("GOT reloc @ 0x%x -> %u\n",
                         rel->r_offset, relocation);
                  value = *location;
                  value = ((value & 0xffff0000)
                         | (relocation & 0xffff));
                  *location = value;
                  break;

            default:
                  printk(KERN_ERR "module %s: Unknown relocation: %u\n",
                         module->name, ELF32_R_TYPE(rel->r_info));
                  return -ENOEXEC;
            }
      }

      return ret;
}

int apply_relocate(Elf32_Shdr *sechdrs, const char *strtab,
               unsigned int symindex, unsigned int relindex,
               struct module *module)
{
      printk(KERN_ERR "module %s: REL relocations are not supported\n",
            module->name);
      return -ENOEXEC;
}

int module_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
                struct module *module)
{
      vfree(module->arch.syminfo);
      module->arch.syminfo = NULL;

      return module_bug_finalize(hdr, sechdrs, module);
}

void module_arch_cleanup(struct module *module)
{
      module_bug_cleanup(module);
}

Generated by  Doxygen 1.6.0   Back to index