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_u32_below(PTRS_PER_PTE); 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); 458