arch/sparc/vdso/vma.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Set up the VMAs to tell the VM about the vDSO.
   4  * Copyright 2007 Andi Kleen, SUSE Labs.
   5  */
   6
   7 /*
   8  * Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
   9  */
  10
  11 #include <linux/mm.h>
  12 #include <linux/err.h>
  13 #include <linux/sched.h>
  14 #include <linux/slab.h>
  15 #include <linux/init.h>
  16 #include <linux/linkage.h>
  17 #include <linux/random.h>
  18 #include <linux/elf.h>
  19 #include <asm/cacheflush.h>
  20 #include <asm/spitfire.h>
  21 #include <asm/vdso.h>
  22 #include <asm/vvar.h>
  23 #include <asm/page.h>
  24
  25 unsigned int __read_mostly vdso_enabled = 1;
  26
  27 static struct vm_special_mapping vvar_mapping = {
  28         .name = "[vvar]"
  29 };
  30
  31 #ifdef  CONFIG_SPARC64
  32 static struct vm_special_mapping vdso_mapping64 = {
  33         .name = "[vdso]"
  34 };
  35 #endif
  36
  37 #ifdef CONFIG_COMPAT
  38 static struct vm_special_mapping vdso_mapping32 = {
  39         .name = "[vdso]"
  40 };
  41 #endif
  42
  43 struct vvar_data *vvar_data;
  44
  45 struct vdso_elfinfo32 {
  46         Elf32_Ehdr      *hdr;
  47         Elf32_Sym       *dynsym;
  48         unsigned long   dynsymsize;
  49         const char      *dynstr;
  50         unsigned long   text;
  51 };
  52
  53 struct vdso_elfinfo64 {
  54         Elf64_Ehdr      *hdr;
  55         Elf64_Sym       *dynsym;
  56         unsigned long   dynsymsize;
  57         const char      *dynstr;
  58         unsigned long   text;
  59 };
  60
  61 struct vdso_elfinfo {
  62         union {
  63                 struct vdso_elfinfo32 elf32;
  64                 struct vdso_elfinfo64 elf64;
  65         } u;
  66 };
  67
  68 static void *one_section64(struct vdso_elfinfo64 *e, const char *name,
  69                            unsigned long *size)
  70 {
  71         const char *snames;
  72         Elf64_Shdr *shdrs;
  73         unsigned int i;
  74
  75         shdrs = (void *)e->hdr + e->hdr->e_shoff;
  76         snames = (void *)e->hdr + shdrs[e->hdr->e_shstrndx].sh_offset;
  77         for (i = 1; i < e->hdr->e_shnum; i++) {
  78                 if (!strcmp(snames+shdrs[i].sh_name, name)) {
  79                         if (size)
  80                                 *size = shdrs[i].sh_size;
  81                         return (void *)e->hdr + shdrs[i].sh_offset;
  82                 }
  83         }
  84         return NULL;
  85 }
  86
  87 static int find_sections64(const struct vdso_image *image, struct vdso_elfinfo *_e)
  88 {
  89         struct vdso_elfinfo64 *e = &_e->u.elf64;
  90
  91         e->hdr = image->data;
  92         e->dynsym = one_section64(e, ".dynsym", &e->dynsymsize);
  93         e->dynstr = one_section64(e, ".dynstr", NULL);
  94
  95         if (!e->dynsym || !e->dynstr) {
  96                 pr_err("VDSO64: Missing symbol sections.\n");
  97                 return -ENODEV;
  98         }
  99         return 0;
 100 }
 101
 102 static Elf64_Sym *find_sym64(const struct vdso_elfinfo64 *e, const char *name)
 103 {
 104         unsigned int i;
 105
 106         for (i = 0; i < (e->dynsymsize / sizeof(Elf64_Sym)); i++) {
 107                 Elf64_Sym *s = &e->dynsym[i];
 108                 if (s->st_name == 0)
 109                         continue;
 110                 if (!strcmp(e->dynstr + s->st_name, name))
 111                         return s;
 112         }
 113         return NULL;
 114 }
 115
 116 static int patchsym64(struct vdso_elfinfo *_e, const char *orig,
 117                       const char *new)
 118 {
 119         struct vdso_elfinfo64 *e = &_e->u.elf64;
 120         Elf64_Sym *osym = find_sym64(e, orig);
 121         Elf64_Sym *nsym = find_sym64(e, new);
 122
 123         if (!nsym || !osym) {
 124                 pr_err("VDSO64: Missing symbols.\n");
 125                 return -ENODEV;
 126         }
 127         osym->st_value = nsym->st_value;
 128         osym->st_size = nsym->st_size;
 129         osym->st_info = nsym->st_info;
 130         osym->st_other = nsym->st_other;
 131         osym->st_shndx = nsym->st_shndx;
 132
 133         return 0;
 134 }
 135
 136 static void *one_section32(struct vdso_elfinfo32 *e, const char *name,
 137                            unsigned long *size)
 138 {
 139         const char *snames;
 140         Elf32_Shdr *shdrs;
 141         unsigned int i;
 142
 143         shdrs = (void *)e->hdr + e->hdr->e_shoff;
 144         snames = (void *)e->hdr + shdrs[e->hdr->e_shstrndx].sh_offset;
 145         for (i = 1; i < e->hdr->e_shnum; i++) {
 146                 if (!strcmp(snames+shdrs[i].sh_name, name)) {
 147                         if (size)
 148                                 *size = shdrs[i].sh_size;
 149                         return (void *)e->hdr + shdrs[i].sh_offset;
 150                 }
 151         }
 152         return NULL;
 153 }
 154
 155 static int find_sections32(const struct vdso_image *image, struct vdso_elfinfo *_e)
 156 {
 157         struct vdso_elfinfo32 *e = &_e->u.elf32;
 158
 159         e->hdr = image->data;
 160         e->dynsym = one_section32(e, ".dynsym", &e->dynsymsize);
 161         e->dynstr = one_section32(e, ".dynstr", NULL);
 162
 163         if (!e->dynsym || !e->dynstr) {
 164                 pr_err("VDSO32: Missing symbol sections.\n");
 165                 return -ENODEV;
 166         }
 167         return 0;
 168 }
 169
 170 static Elf32_Sym *find_sym32(const struct vdso_elfinfo32 *e, const char *name)
 171 {
 172         unsigned int i;
 173
 174         for (i = 0; i < (e->dynsymsize / sizeof(Elf32_Sym)); i++) {
 175                 Elf32_Sym *s = &e->dynsym[i];
 176                 if (s->st_name == 0)
 177                         continue;
 178                 if (!strcmp(e->dynstr + s->st_name, name))
 179                         return s;
 180         }
 181         return NULL;
 182 }
 183
 184 static int patchsym32(struct vdso_elfinfo *_e, const char *orig,
 185                       const char *new)
 186 {
 187         struct vdso_elfinfo32 *e = &_e->u.elf32;
 188         Elf32_Sym *osym = find_sym32(e, orig);
 189         Elf32_Sym *nsym = find_sym32(e, new);
 190
 191         if (!nsym || !osym) {
 192                 pr_err("VDSO32: Missing symbols.\n");
 193                 return -ENODEV;
 194         }
 195         osym->st_value = nsym->st_value;
 196         osym->st_size = nsym->st_size;
 197         osym->st_info = nsym->st_info;
 198         osym->st_other = nsym->st_other;
 199         osym->st_shndx = nsym->st_shndx;
 200
 201         return 0;
 202 }
 203
 204 static int find_sections(const struct vdso_image *image, struct vdso_elfinfo *e,
 205                          bool elf64)
 206 {
 207         if (elf64)
 208                 return find_sections64(image, e);
 209         else
 210                 return find_sections32(image, e);
 211 }
 212
 213 static int patch_one_symbol(struct vdso_elfinfo *e, const char *orig,
 214                             const char *new_target, bool elf64)
 215 {
 216         if (elf64)
 217                 return patchsym64(e, orig, new_target);
 218         else
 219                 return patchsym32(e, orig, new_target);
 220 }
 221
 222 static int stick_patch(const struct vdso_image *image, struct vdso_elfinfo *e, bool elf64)
 223 {
 224         int err;
 225
 226         err = find_sections(image, e, elf64);
 227         if (err)
 228                 return err;
 229
 230         err = patch_one_symbol(e,
 231                                "__vdso_gettimeofday",
 232                                "__vdso_gettimeofday_stick", elf64);
 233         if (err)
 234                 return err;
 235
 236         return patch_one_symbol(e,
 237                                 "__vdso_clock_gettime",
 238                                 "__vdso_clock_gettime_stick", elf64);
 239         return 0;
 240 }
 241
 242 /*
 243  * Allocate pages for the vdso and vvar, and copy in the vdso text from the
 244  * kernel image.
 245  */
 246 int __init init_vdso_image(const struct vdso_image *image,
 247                            struct vm_special_mapping *vdso_mapping, bool elf64)
 248 {
 249         int cnpages = (image->size) / PAGE_SIZE;
 250         struct page *dp, **dpp = NULL;
 251         struct page *cp, **cpp = NULL;
 252         struct vdso_elfinfo ei;
 253         int i, dnpages = 0;
 254
 255         if (tlb_type != spitfire) {
 256                 int err = stick_patch(image, &ei, elf64);
 257                 if (err)
 258                         return err;
 259         }
 260
 261         /*
 262          * First, the vdso text.  This is initialied data, an integral number of
 263          * pages long.
 264          */
 265         if (WARN_ON(image->size % PAGE_SIZE != 0))
 266                 goto oom;
 267
 268         cpp = kcalloc(cnpages, sizeof(struct page *), GFP_KERNEL);
 269         vdso_mapping->pages = cpp;
 270
 271         if (!cpp)
 272                 goto oom;
 273
 274         for (i = 0; i < cnpages; i++) {
 275                 cp = alloc_page(GFP_KERNEL);
 276                 if (!cp)
 277                         goto oom;
 278                 cpp[i] = cp;
 279                 copy_page(page_address(cp), image->data + i * PAGE_SIZE);
 280         }
 281
 282         /*
 283          * Now the vvar page.  This is uninitialized data.
 284          */
 285
 286         if (vvar_data == NULL) {
 287                 dnpages = (sizeof(struct vvar_data) / PAGE_SIZE) + 1;
 288                 if (WARN_ON(dnpages != 1))
 289                         goto oom;
 290                 dpp = kcalloc(dnpages, sizeof(struct page *), GFP_KERNEL);
 291                 vvar_mapping.pages = dpp;
 292
 293                 if (!dpp)
 294                         goto oom;
 295
 296                 dp = alloc_page(GFP_KERNEL);
 297                 if (!dp)
 298                         goto oom;
 299
 300                 dpp[0] = dp;
 301                 vvar_data = page_address(dp);
 302                 memset(vvar_data, 0, PAGE_SIZE);
 303
 304                 vvar_data->seq = 0;
 305         }
 306
 307         return 0;
 308  oom:
 309         if (cpp != NULL) {
 310                 for (i = 0; i < cnpages; i++) {
 311                         if (cpp[i] != NULL)
 312                                 __free_page(cpp[i]);
 313                 }
 314                 kfree(cpp);
 315                 vdso_mapping->pages = NULL;
 316         }
 317
 318         if (dpp != NULL) {
 319                 for (i = 0; i < dnpages; i++) {
 320                         if (dpp[i] != NULL)
 321                                 __free_page(dpp[i]);
 322                 }
 323                 kfree(dpp);
 324                 vvar_mapping.pages = NULL;
 325         }
 326
 327         pr_warn("Cannot allocate vdso\n");
 328         vdso_enabled = 0;
 329         return -ENOMEM;
 330 }
 331
 332 static int __init init_vdso(void)
 333 {
 334         int err = 0;
 335 #ifdef CONFIG_SPARC64
 336         err = init_vdso_image(&vdso_image_64_builtin, &vdso_mapping64, true);
 337         if (err)
 338                 return err;
 339 #endif
 340
 341 #ifdef CONFIG_COMPAT
 342         err = init_vdso_image(&vdso_image_32_builtin, &vdso_mapping32, false);
 343 #endif
 344         return err;
 345
 346 }
 347 subsys_initcall(init_vdso);
 348
 349 struct linux_binprm;
 350
 351 /* Shuffle the vdso up a bit, randomly. */
 352 static unsigned long vdso_addr(unsigned long start, unsigned int len)
 353 {
 354         unsigned int offset;
 355
 356         /* This loses some more bits than a modulo, but is cheaper */
 357         offset = get_random_int() & (PTRS_PER_PTE - 1);
 358         return start + (offset << PAGE_SHIFT);
 359 }
 360
 361 static int map_vdso(const struct vdso_image *image,
 362                 struct vm_special_mapping *vdso_mapping)
 363 {
 364         struct mm_struct *mm = current->mm;
 365         struct vm_area_struct *vma;
 366         unsigned long text_start, addr = 0;
 367         int ret = 0;
 368
 369         mmap_write_lock(mm);
 370
 371         /*
 372          * First, get an unmapped region: then randomize it, and make sure that
 373          * region is free.
 374          */
 375         if (current->flags & PF_RANDOMIZE) {
 376                 addr = get_unmapped_area(NULL, 0,
 377                                          image->size - image->sym_vvar_start,
 378                                          0, 0);
 379                 if (IS_ERR_VALUE(addr)) {
 380                         ret = addr;
 381                         goto up_fail;
 382                 }
 383                 addr = vdso_addr(addr, image->size - image->sym_vvar_start);
 384         }
 385         addr = get_unmapped_area(NULL, addr,
 386                                  image->size - image->sym_vvar_start, 0, 0);
 387         if (IS_ERR_VALUE(addr)) {
 388                 ret = addr;
 389                 goto up_fail;
 390         }
 391
 392         text_start = addr - image->sym_vvar_start;
 393         current->mm->context.vdso = (void __user *)text_start;
 394
 395         /*
 396          * MAYWRITE to allow gdb to COW and set breakpoints
 397          */
 398         vma = _install_special_mapping(mm,
 399                                        text_start,
 400                                        image->size,
 401                                        VM_READ|VM_EXEC|
 402                                        VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC,
 403                                        vdso_mapping);
 404
 405         if (IS_ERR(vma)) {
 406                 ret = PTR_ERR(vma);
 407                 goto up_fail;
 408         }
 409
 410         vma = _install_special_mapping(mm,
 411                                        addr,
 412                                        -image->sym_vvar_start,
 413                                        VM_READ|VM_MAYREAD,
 414                                        &vvar_mapping);
 415
 416         if (IS_ERR(vma)) {
 417                 ret = PTR_ERR(vma);
 418                 do_munmap(mm, text_start, image->size, NULL);
 419         }
 420
 421 up_fail:
 422         if (ret)
 423                 current->mm->context.vdso = NULL;
 424
 425         mmap_write_unlock(mm);
 426         return ret;
 427 }
 428
 429 int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
 430 {
 431
 432         if (!vdso_enabled)
 433                 return 0;
 434
 435 #if defined CONFIG_COMPAT
 436         if (!(is_32bit_task()))
 437                 return map_vdso(&vdso_image_64_builtin, &vdso_mapping64);
 438         else
 439                 return map_vdso(&vdso_image_32_builtin, &vdso_mapping32);
 440 #else
 441         return map_vdso(&vdso_image_64_builtin, &vdso_mapping64);
 442 #endif
 443
 444 }
 445
 446 static __init int vdso_setup(char *s)
 447 {
 448         int err;
 449         unsigned long val;
 450
 451         err = kstrtoul(s, 10, &val);
 452         if (err)
 453                 return err;
 454         vdso_enabled = val;
 455         return 0;
 456 }
 457 __setup("vdso=", vdso_setup);