arch/x86/lib/relocate.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2008-2011
   4  * Graeme Russ, <graeme.russ@gmail.com>
   5  *
   6  * (C) Copyright 2002
   7  * Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
   8  *
   9  * (C) Copyright 2002
  10  * Wolfgang Denk, DENX Software Engineering, <wd@denx.de>
  11  *
  12  * (C) Copyright 2002
  13  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
  14  * Marius Groeger <mgroeger@sysgo.de>
  15  */
  16
  17 #include <common.h>
  18 #include <relocate.h>
  19 #include <asm/u-boot-x86.h>
  20 #include <asm/sections.h>
  21 #include <elf.h>
  22
  23 DECLARE_GLOBAL_DATA_PTR;
  24
  25 int copy_uboot_to_ram(void)
  26 {
  27         size_t len = (uintptr_t)&__data_end - (uintptr_t)&__text_start;
  28
  29         if (gd->flags & GD_FLG_SKIP_RELOC)
  30                 return 0;
  31         memcpy((void *)gd->relocaddr, (void *)&__text_start, len);
  32
  33         return 0;
  34 }
  35
  36 int clear_bss(void)
  37 {
  38         ulong dst_addr = (ulong)&__bss_start + gd->reloc_off;
  39         size_t len = (uintptr_t)&__bss_end - (uintptr_t)&__bss_start;
  40
  41         if (gd->flags & GD_FLG_SKIP_RELOC)
  42                 return 0;
  43         memset((void *)dst_addr, 0x00, len);
  44
  45         return 0;
  46 }
  47
  48 #if CONFIG_IS_ENABLED(X86_64)
  49 static void do_elf_reloc_fixups64(unsigned int text_base, uintptr_t size,
  50                                   Elf64_Rela *re_src, Elf64_Rela *re_end)
  51 {
  52         Elf64_Addr *offset_ptr_rom, *last_offset = NULL;
  53         Elf64_Addr *offset_ptr_ram;
  54
  55         do {
  56                 /* Get the location from the relocation entry */
  57                 offset_ptr_rom = (Elf64_Addr *)(uintptr_t)re_src->r_offset;
  58
  59                 /* Check that the location of the relocation is in .text */
  60                 if (offset_ptr_rom >= (Elf64_Addr *)(uintptr_t)text_base &&
  61                     offset_ptr_rom > last_offset) {
  62                         /* Switch to the in-RAM version */
  63                         offset_ptr_ram = (Elf64_Addr *)((ulong)offset_ptr_rom +
  64                                                         gd->reloc_off);
  65
  66                         /* Check that the target points into .text */
  67                         if (*offset_ptr_ram >= text_base &&
  68                             *offset_ptr_ram <= text_base + size) {
  69                                 *offset_ptr_ram = gd->reloc_off +
  70                                                         re_src->r_addend;
  71                         } else {
  72                                 debug("   %p: %lx: rom reloc %lx, ram %p, value %lx, limit %lX\n",
  73                                       re_src, (ulong)re_src->r_info,
  74                                       (ulong)re_src->r_offset, offset_ptr_ram,
  75                                       (ulong)*offset_ptr_ram, text_base + size);
  76                         }
  77                 } else {
  78                         debug("   %p: %lx: rom reloc %lx, last %p\n", re_src,
  79                               (ulong)re_src->r_info, (ulong)re_src->r_offset,
  80                               last_offset);
  81                 }
  82                 last_offset = offset_ptr_rom;
  83
  84         } while (++re_src < re_end);
  85 }
  86 #else
  87 static void do_elf_reloc_fixups32(unsigned int text_base, uintptr_t size,
  88                                   Elf32_Rel *re_src, Elf32_Rel *re_end)
  89 {
  90         Elf32_Addr *offset_ptr_rom, *last_offset = NULL;
  91         Elf32_Addr *offset_ptr_ram;
  92
  93         do {
  94                 /* Get the location from the relocation entry */
  95                 offset_ptr_rom = (Elf32_Addr *)(uintptr_t)re_src->r_offset;
  96
  97                 /* Check that the location of the relocation is in .text */
  98                 if (offset_ptr_rom >= (Elf32_Addr *)(uintptr_t)text_base &&
  99                     offset_ptr_rom > last_offset) {
 100
 101                         /* Switch to the in-RAM version */
 102                         offset_ptr_ram = (Elf32_Addr *)((ulong)offset_ptr_rom +
 103                                                         gd->reloc_off);
 104
 105                         /* Check that the target points into .text */
 106                         if (*offset_ptr_ram >= text_base &&
 107                             *offset_ptr_ram <= text_base + size) {
 108                                 *offset_ptr_ram += gd->reloc_off;
 109                         } else {
 110                                 debug("   %p: rom reloc %x, ram %p, value %x, limit %lX\n",
 111                                       re_src, re_src->r_offset, offset_ptr_ram,
 112                                       *offset_ptr_ram, text_base + size);
 113                         }
 114                 } else {
 115                         debug("   %p: rom reloc %x, last %p\n", re_src,
 116                                re_src->r_offset, last_offset);
 117                 }
 118                 last_offset = offset_ptr_rom;
 119
 120         } while (++re_src < re_end);
 121 }
 122 #endif
 123
 124 /*
 125  * This function has more error checking than you might expect. Please see
 126  * this commit message for more information:
 127  *    62f7970a x86: Add error checking to x86 relocation code
 128  */
 129 int do_elf_reloc_fixups(void)
 130 {
 131         void *re_src = (void *)(&__rel_dyn_start);
 132         void *re_end = (void *)(&__rel_dyn_end);
 133         uint text_base;
 134
 135         /* The size of the region of u-boot that runs out of RAM. */
 136         uintptr_t size = (uintptr_t)&__bss_end - (uintptr_t)&__text_start;
 137
 138         if (gd->flags & GD_FLG_SKIP_RELOC)
 139                 return 0;
 140         if (re_src == re_end)
 141                 panic("No relocation data");
 142
 143 #ifdef CONFIG_SYS_TEXT_BASE
 144         text_base = CONFIG_SYS_TEXT_BASE;
 145 #else
 146         panic("No CONFIG_SYS_TEXT_BASE");
 147 #endif
 148 #if CONFIG_IS_ENABLED(X86_64)
 149         do_elf_reloc_fixups64(text_base, size, re_src, re_end);
 150 #else
 151         do_elf_reloc_fixups32(text_base, size, re_src, re_end);
 152 #endif
 153
 154         return 0;
 155 }