sys/compat/linux/linux_vdso.c

   1 /*-
   2  * Copyright (c) 2013 Dmitry Chagin
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include "opt_compat.h"
  31
  32 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
  33 #define __ELF_WORD_SIZE 32
  34 #else
  35 #define __ELF_WORD_SIZE 64
  36 #endif
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/elf.h>
  41 #include <sys/kernel.h>
  42 #include <sys/lock.h>
  43 #include <sys/rwlock.h>
  44 #include <sys/queue.h>
  45 #include <sys/sysent.h>
  46
  47 #include <vm/vm.h>
  48 #include <vm/vm_param.h>
  49 #include <vm/pmap.h>
  50 #include <vm/vm_extern.h>
  51 #include <vm/vm_kern.h>
  52 #include <vm/vm_map.h>
  53 #include <vm/vm_object.h>
  54 #include <vm/vm_page.h>
  55 #include <vm/vm_pager.h>
  56
  57 #include <compat/linux/linux_vdso.h>
  58
  59 SLIST_HEAD(, linux_vdso_sym) __elfN(linux_vdso_syms) =
  60     SLIST_HEAD_INITIALIZER(__elfN(linux_vdso_syms));
  61
  62 static int __elfN(symtabindex);
  63 static int __elfN(symstrindex);
  64
  65 static void
  66 __elfN(linux_vdso_lookup)(Elf_Ehdr *, struct linux_vdso_sym *);
  67
  68 void
  69 __elfN(linux_vdso_sym_init)(struct linux_vdso_sym *s)
  70 {
  71
  72         SLIST_INSERT_HEAD(&__elfN(linux_vdso_syms), s, sym);
  73 }
  74
  75 vm_object_t
  76 __elfN(linux_shared_page_init)(char **mapping)
  77 {
  78         vm_page_t m;
  79         vm_object_t obj;
  80         vm_offset_t addr;
  81
  82         obj = vm_pager_allocate(OBJT_PHYS, 0, PAGE_SIZE,
  83             VM_PROT_DEFAULT, 0, NULL);
  84         VM_OBJECT_WLOCK(obj);
  85         m = vm_page_grab(obj, 0, VM_ALLOC_ZERO);
  86         VM_OBJECT_WUNLOCK(obj);
  87         vm_page_valid(m);
  88         vm_page_xunbusy(m);
  89         addr = kva_alloc(PAGE_SIZE);
  90         pmap_qenter(addr, &m, 1);
  91         *mapping = (char *)addr;
  92         return (obj);
  93 }
  94
  95 void
  96 __elfN(linux_shared_page_fini)(vm_object_t obj, void *mapping)
  97 {
  98         vm_offset_t va;
  99
 100         va = (vm_offset_t)mapping;
 101         pmap_qremove(va, 1);
 102         kva_free(va, PAGE_SIZE);
 103         vm_object_deallocate(obj);
 104 }
 105
 106 void
 107 __elfN(linux_vdso_fixup)(struct sysentvec *sv)
 108 {
 109         Elf_Ehdr *ehdr;
 110         Elf_Shdr *shdr;
 111         int i;
 112
 113         ehdr = (Elf_Ehdr *) sv->sv_sigcode;
 114
 115         if (!IS_ELF(*ehdr) ||
 116             ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
 117             ehdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
 118             ehdr->e_ident[EI_VERSION] != EV_CURRENT ||
 119             ehdr->e_shoff == 0 ||
 120             ehdr->e_shentsize != sizeof(Elf_Shdr))
 121                 panic("Linux invalid vdso header.\n");
 122
 123         if (ehdr->e_type != ET_DYN)
 124                 panic("Linux invalid vdso header.\n");
 125
 126         shdr = (Elf_Shdr *) ((caddr_t)ehdr + ehdr->e_shoff);
 127
 128         __elfN(symtabindex) = -1;
 129         __elfN(symstrindex) = -1;
 130         for (i = 0; i < ehdr->e_shnum; i++) {
 131                 if (shdr[i].sh_size == 0)
 132                         continue;
 133                 if (shdr[i].sh_type == SHT_DYNSYM) {
 134                         __elfN(symtabindex) = i;
 135                         __elfN(symstrindex) = shdr[i].sh_link;
 136                 }
 137         }
 138
 139         if (__elfN(symtabindex) == -1 || __elfN(symstrindex) == -1)
 140                 panic("Linux invalid vdso header.\n");
 141
 142         ehdr->e_ident[EI_OSABI] = ELFOSABI_LINUX;
 143 }
 144
 145 void
 146 __elfN(linux_vdso_reloc)(struct sysentvec *sv)
 147 {
 148         struct linux_vdso_sym *lsym;
 149         Elf_Ehdr *ehdr;
 150         Elf_Phdr *phdr;
 151         Elf_Shdr *shdr;
 152         Elf_Dyn *dyn;
 153         Elf_Sym *sym;
 154         int i, j, symcnt;
 155
 156         ehdr = (Elf_Ehdr *) sv->sv_sigcode;
 157
 158         /* Adjust our so relative to the sigcode_base */
 159         if (sv->sv_shared_page_base != 0) {
 160                 ehdr->e_entry += sv->sv_shared_page_base;
 161                 phdr = (Elf_Phdr *)((caddr_t)ehdr + ehdr->e_phoff);
 162
 163                 /* phdrs */
 164                 for (i = 0; i < ehdr->e_phnum; i++) {
 165                         phdr[i].p_vaddr += sv->sv_shared_page_base;
 166                         if (phdr[i].p_type != PT_DYNAMIC)
 167                                 continue;
 168                         dyn = (Elf_Dyn *)((caddr_t)ehdr + phdr[i].p_offset);
 169                         for(; dyn->d_tag != DT_NULL; dyn++) {
 170                                 switch (dyn->d_tag) {
 171                                 case DT_PLTGOT:
 172                                 case DT_HASH:
 173                                 case DT_STRTAB:
 174                                 case DT_SYMTAB:
 175                                 case DT_RELA:
 176                                 case DT_INIT:
 177                                 case DT_FINI:
 178                                 case DT_REL:
 179                                 case DT_DEBUG:
 180                                 case DT_JMPREL:
 181                                 case DT_VERSYM:
 182                                 case DT_VERDEF:
 183                                 case DT_VERNEED:
 184                                 case DT_ADDRRNGLO ... DT_ADDRRNGHI:
 185                                         dyn->d_un.d_ptr += sv->sv_shared_page_base;
 186                                         break;
 187                                 case DT_ENCODING ... DT_LOOS-1:
 188                                 case DT_LOOS ... DT_HIOS:
 189                                         if (dyn->d_tag >= DT_ENCODING &&
 190                                             (dyn->d_tag & 1) == 0)
 191                                                 dyn->d_un.d_ptr += sv->sv_shared_page_base;
 192                                         break;
 193                                 default:
 194                                         break;
 195                                 }
 196                         }
 197                 }
 198
 199                 /* sections */
 200                 shdr = (Elf_Shdr *)((caddr_t)ehdr + ehdr->e_shoff);
 201                 for(i = 0; i < ehdr->e_shnum; i++) {
 202                         if (!(shdr[i].sh_flags & SHF_ALLOC))
 203                                 continue;
 204                         shdr[i].sh_addr += sv->sv_shared_page_base;
 205                         if (shdr[i].sh_type != SHT_SYMTAB &&
 206                             shdr[i].sh_type != SHT_DYNSYM)
 207                                 continue;
 208
 209                         sym = (Elf_Sym *)((caddr_t)ehdr + shdr[i].sh_offset);
 210                         symcnt = shdr[i].sh_size / sizeof(*sym);
 211
 212                         for(j = 0; j < symcnt; j++, sym++) {
 213                                 if (sym->st_shndx == SHN_UNDEF ||
 214                                     sym->st_shndx == SHN_ABS)
 215                                         continue;
 216                                 sym->st_value += sv->sv_shared_page_base;
 217                         }
 218                 }
 219         }
 220
 221         SLIST_FOREACH(lsym, &__elfN(linux_vdso_syms), sym)
 222                 __elfN(linux_vdso_lookup)(ehdr, lsym);
 223 }
 224
 225 static void
 226 __elfN(linux_vdso_lookup)(Elf_Ehdr *ehdr, struct linux_vdso_sym *vsym)
 227 {
 228         vm_offset_t strtab, symname;
 229         uint32_t symcnt;
 230         Elf_Shdr *shdr;
 231         int i;
 232
 233         shdr = (Elf_Shdr *) ((caddr_t)ehdr + ehdr->e_shoff);
 234
 235         strtab = (vm_offset_t)((caddr_t)ehdr +
 236             shdr[__elfN(symstrindex)].sh_offset);
 237         Elf_Sym *sym = (Elf_Sym *)((caddr_t)ehdr +
 238             shdr[__elfN(symtabindex)].sh_offset);
 239         symcnt = shdr[__elfN(symtabindex)].sh_size / sizeof(*sym);
 240
 241         for (i = 0; i < symcnt; ++i, ++sym) {
 242                 symname = strtab + sym->st_name;
 243                 if (strncmp(vsym->symname, (char *)symname, vsym->size) == 0) {
 244                         *vsym->ptr = (uintptr_t)sym->st_value;
 245                         break;
 246                 }
 247         }
 248 }