1 // SPDX-License-Identifier: GPL-2.0-or-later 2 3 /* 4 * Copyright (C) 2004 Benjamin Herrenschmidt, IBM Corp. 5 * <benh@kernel.crashing.org> 6 */ 7 8 #include <linux/errno.h> 9 #include <linux/sched.h> 10 #include <linux/kernel.h> 11 #include <linux/mm.h> 12 #include <linux/smp.h> 13 #include <linux/stddef.h> 14 #include <linux/unistd.h> 15 #include <linux/slab.h> 16 #include <linux/user.h> 17 #include <linux/elf.h> 18 #include <linux/security.h> 19 #include <linux/memblock.h> 20 21 #include <asm/pgtable.h> 22 #include <asm/processor.h> 23 #include <asm/mmu.h> 24 #include <asm/mmu_context.h> 25 #include <asm/prom.h> 26 #include <asm/machdep.h> 27 #include <asm/cputable.h> 28 #include <asm/sections.h> 29 #include <asm/firmware.h> 30 #include <asm/vdso.h> 31 #include <asm/vdso_datapage.h> 32 #include <asm/setup.h> 33 34 #undef DEBUG 35 36 #ifdef DEBUG 37 #define DBG(fmt...) printk(fmt) 38 #else 39 #define DBG(fmt...) 40 #endif 41 42 /* Max supported size for symbol names */ 43 #define MAX_SYMNAME 64 44 45 /* The alignment of the vDSO */ 46 #define VDSO_ALIGNMENT (1 << 16) 47 48 static unsigned int vdso32_pages; 49 static void *vdso32_kbase; 50 static struct page **vdso32_pagelist; 51 unsigned long vdso32_sigtramp; 52 unsigned long vdso32_rt_sigtramp; 53 54 #ifdef CONFIG_VDSO32 55 extern char vdso32_start, vdso32_end; 56 #endif 57 58 #ifdef CONFIG_PPC64 59 extern char vdso64_start, vdso64_end; 60 static void *vdso64_kbase = &vdso64_start; 61 static unsigned int vdso64_pages; 62 static struct page **vdso64_pagelist; 63 unsigned long vdso64_rt_sigtramp; 64 #endif /* CONFIG_PPC64 */ 65 66 static int vdso_ready; 67 68 /* 69 * The vdso data page (aka. systemcfg for old ppc64 fans) is here. 70 * Once the early boot kernel code no longer needs to muck around 71 * with it, it will become dynamically allocated 72 */ 73 static union { 74 struct vdso_data data; 75 u8 page[PAGE_SIZE]; 76 } vdso_data_store __page_aligned_data; 77 struct vdso_data *vdso_data = &vdso_data_store.data; 78 79 /* Format of the patch table */ 80 struct vdso_patch_def 81 { 82 unsigned long ftr_mask, ftr_value; 83 const char *gen_name; 84 const char *fix_name; 85 }; 86 87 /* Table of functions to patch based on the CPU type/revision 88 * 89 * Currently, we only change sync_dicache to do nothing on processors 90 * with a coherent icache 91 */ 92 static struct vdso_patch_def vdso_patches[] = { 93 { 94 CPU_FTR_COHERENT_ICACHE, CPU_FTR_COHERENT_ICACHE, 95 "__kernel_sync_dicache", "__kernel_sync_dicache_p5" 96 }, 97 }; 98 99 /* 100 * Some infos carried around for each of them during parsing at 101 * boot time. 102 */ 103 struct lib32_elfinfo 104 { 105 Elf32_Ehdr *hdr; /* ptr to ELF */ 106 Elf32_Sym *dynsym; /* ptr to .dynsym section */ 107 unsigned long dynsymsize; /* size of .dynsym section */ 108 char *dynstr; /* ptr to .dynstr section */ 109 unsigned long text; /* offset of .text section in .so */ 110 }; 111 112 struct lib64_elfinfo 113 { 114 Elf64_Ehdr *hdr; 115 Elf64_Sym *dynsym; 116 unsigned long dynsymsize; 117 char *dynstr; 118 unsigned long text; 119 }; 120 121 122 /* 123 * This is called from binfmt_elf, we create the special vma for the 124 * vDSO and insert it into the mm struct tree 125 */ 126 int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) 127 { 128 struct mm_struct *mm = current->mm; 129 struct page **vdso_pagelist; 130 unsigned long vdso_pages; 131 unsigned long vdso_base; 132 int rc; 133 134 if (!vdso_ready) 135 return 0; 136 137 #ifdef CONFIG_PPC64 138 if (is_32bit_task()) { 139 vdso_pagelist = vdso32_pagelist; 140 vdso_pages = vdso32_pages; 141 vdso_base = VDSO32_MBASE; 142 } else { 143 vdso_pagelist = vdso64_pagelist; 144 vdso_pages = vdso64_pages; 145 /* 146 * On 64bit we don't have a preferred map address. This 147 * allows get_unmapped_area to find an area near other mmaps 148 * and most likely share a SLB entry. 149 */ 150 vdso_base = 0; 151 } 152 #else 153 vdso_pagelist = vdso32_pagelist; 154 vdso_pages = vdso32_pages; 155 vdso_base = VDSO32_MBASE; 156 #endif 157 158 current->mm->context.vdso_base = 0; 159 160 /* vDSO has a problem and was disabled, just don't "enable" it for the 161 * process 162 */ 163 if (vdso_pages == 0) 164 return 0; 165 /* Add a page to the vdso size for the data page */ 166 vdso_pages ++; 167 168 /* 169 * pick a base address for the vDSO in process space. We try to put it 170 * at vdso_base which is the "natural" base for it, but we might fail 171 * and end up putting it elsewhere. 172 * Add enough to the size so that the result can be aligned. 173 */ 174 if (down_write_killable(&mm->mmap_sem)) 175 return -EINTR; 176 vdso_base = get_unmapped_area(NULL, vdso_base, 177 (vdso_pages << PAGE_SHIFT) + 178 ((VDSO_ALIGNMENT - 1) & PAGE_MASK), 179 0, 0); 180 if (IS_ERR_VALUE(vdso_base)) { 181 rc = vdso_base; 182 goto fail_mmapsem; 183 } 184 185 /* Add required alignment. */ 186 vdso_base = ALIGN(vdso_base, VDSO_ALIGNMENT); 187 188 /* 189 * Put vDSO base into mm struct. We need to do this before calling 190 * install_special_mapping or the perf counter mmap tracking code 191 * will fail to recognise it as a vDSO (since arch_vma_name fails). 192 */ 193 current->mm->context.vdso_base = vdso_base; 194 195 /* 196 * our vma flags don't have VM_WRITE so by default, the process isn't 197 * allowed to write those pages. 198 * gdb can break that with ptrace interface, and thus trigger COW on 199 * those pages but it's then your responsibility to never do that on 200 * the "data" page of the vDSO or you'll stop getting kernel updates 201 * and your nice userland gettimeofday will be totally dead. 202 * It's fine to use that for setting breakpoints in the vDSO code 203 * pages though. 204 */ 205 rc = install_special_mapping(mm, vdso_base, vdso_pages << PAGE_SHIFT, 206 VM_READ|VM_EXEC| 207 VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC, 208 vdso_pagelist); 209 if (rc) { 210 current->mm->context.vdso_base = 0; 211 goto fail_mmapsem; 212 } 213 214 up_write(&mm->mmap_sem); 215 return 0; 216 217 fail_mmapsem: 218 up_write(&mm->mmap_sem); 219 return rc; 220 } 221 222 const char *arch_vma_name(struct vm_area_struct *vma) 223 { 224 if (vma->vm_mm && vma->vm_start == vma->vm_mm->context.vdso_base) 225 return "[vdso]"; 226 return NULL; 227 } 228 229 230 231 #ifdef CONFIG_VDSO32 232 static void * __init find_section32(Elf32_Ehdr *ehdr, const char *secname, 233 unsigned long *size) 234 { 235 Elf32_Shdr *sechdrs; 236 unsigned int i; 237 char *secnames; 238 239 /* Grab section headers and strings so we can tell who is who */ 240 sechdrs = (void *)ehdr + ehdr->e_shoff; 241 secnames = (void *)ehdr + sechdrs[ehdr->e_shstrndx].sh_offset; 242 243 /* Find the section they want */ 244 for (i = 1; i < ehdr->e_shnum; i++) { 245 if (strcmp(secnames+sechdrs[i].sh_name, secname) == 0) { 246 if (size) 247 *size = sechdrs[i].sh_size; 248 return (void *)ehdr + sechdrs[i].sh_offset; 249 } 250 } 251 *size = 0; 252 return NULL; 253 } 254 255 static Elf32_Sym * __init find_symbol32(struct lib32_elfinfo *lib, 256 const char *symname) 257 { 258 unsigned int i; 259 char name[MAX_SYMNAME], *c; 260 261 for (i = 0; i < (lib->dynsymsize / sizeof(Elf32_Sym)); i++) { 262 if (lib->dynsym[i].st_name == 0) 263 continue; 264 strlcpy(name, lib->dynstr + lib->dynsym[i].st_name, 265 MAX_SYMNAME); 266 c = strchr(name, '@'); 267 if (c) 268 *c = 0; 269 if (strcmp(symname, name) == 0) 270 return &lib->dynsym[i]; 271 } 272 return NULL; 273 } 274 275 /* Note that we assume the section is .text and the symbol is relative to 276 * the library base 277 */ 278 static unsigned long __init find_function32(struct lib32_elfinfo *lib, 279 const char *symname) 280 { 281 Elf32_Sym *sym = find_symbol32(lib, symname); 282 283 if (sym == NULL) { 284 printk(KERN_WARNING "vDSO32: function %s not found !\n", 285 symname); 286 return 0; 287 } 288 return sym->st_value - VDSO32_LBASE; 289 } 290 291 static int __init vdso_do_func_patch32(struct lib32_elfinfo *v32, 292 struct lib64_elfinfo *v64, 293 const char *orig, const char *fix) 294 { 295 Elf32_Sym *sym32_gen, *sym32_fix; 296 297 sym32_gen = find_symbol32(v32, orig); 298 if (sym32_gen == NULL) { 299 printk(KERN_ERR "vDSO32: Can't find symbol %s !\n", orig); 300 return -1; 301 } 302 if (fix == NULL) { 303 sym32_gen->st_name = 0; 304 return 0; 305 } 306 sym32_fix = find_symbol32(v32, fix); 307 if (sym32_fix == NULL) { 308 printk(KERN_ERR "vDSO32: Can't find symbol %s !\n", fix); 309 return -1; 310 } 311 sym32_gen->st_value = sym32_fix->st_value; 312 sym32_gen->st_size = sym32_fix->st_size; 313 sym32_gen->st_info = sym32_fix->st_info; 314 sym32_gen->st_other = sym32_fix->st_other; 315 sym32_gen->st_shndx = sym32_fix->st_shndx; 316 317 return 0; 318 } 319 #else /* !CONFIG_VDSO32 */ 320 static unsigned long __init find_function32(struct lib32_elfinfo *lib, 321 const char *symname) 322 { 323 return 0; 324 } 325 326 static int __init vdso_do_func_patch32(struct lib32_elfinfo *v32, 327 struct lib64_elfinfo *v64, 328 const char *orig, const char *fix) 329 { 330 return 0; 331 } 332 #endif /* CONFIG_VDSO32 */ 333 334 335 #ifdef CONFIG_PPC64 336 337 static void * __init find_section64(Elf64_Ehdr *ehdr, const char *secname, 338 unsigned long *size) 339 { 340 Elf64_Shdr *sechdrs; 341 unsigned int i; 342 char *secnames; 343 344 /* Grab section headers and strings so we can tell who is who */ 345 sechdrs = (void *)ehdr + ehdr->e_shoff; 346 secnames = (void *)ehdr + sechdrs[ehdr->e_shstrndx].sh_offset; 347 348 /* Find the section they want */ 349 for (i = 1; i < ehdr->e_shnum; i++) { 350 if (strcmp(secnames+sechdrs[i].sh_name, secname) == 0) { 351 if (size) 352 *size = sechdrs[i].sh_size; 353 return (void *)ehdr + sechdrs[i].sh_offset; 354 } 355 } 356 if (size) 357 *size = 0; 358 return NULL; 359 } 360 361 static Elf64_Sym * __init find_symbol64(struct lib64_elfinfo *lib, 362 const char *symname) 363 { 364 unsigned int i; 365 char name[MAX_SYMNAME], *c; 366 367 for (i = 0; i < (lib->dynsymsize / sizeof(Elf64_Sym)); i++) { 368 if (lib->dynsym[i].st_name == 0) 369 continue; 370 strlcpy(name, lib->dynstr + lib->dynsym[i].st_name, 371 MAX_SYMNAME); 372 c = strchr(name, '@'); 373 if (c) 374 *c = 0; 375 if (strcmp(symname, name) == 0) 376 return &lib->dynsym[i]; 377 } 378 return NULL; 379 } 380 381 /* Note that we assume the section is .text and the symbol is relative to 382 * the library base 383 */ 384 static unsigned long __init find_function64(struct lib64_elfinfo *lib, 385 const char *symname) 386 { 387 Elf64_Sym *sym = find_symbol64(lib, symname); 388 389 if (sym == NULL) { 390 printk(KERN_WARNING "vDSO64: function %s not found !\n", 391 symname); 392 return 0; 393 } 394 #ifdef VDS64_HAS_DESCRIPTORS 395 return *((u64 *)(vdso64_kbase + sym->st_value - VDSO64_LBASE)) - 396 VDSO64_LBASE; 397 #else 398 return sym->st_value - VDSO64_LBASE; 399 #endif 400 } 401 402 static int __init vdso_do_func_patch64(struct lib32_elfinfo *v32, 403 struct lib64_elfinfo *v64, 404 const char *orig, const char *fix) 405 { 406 Elf64_Sym *sym64_gen, *sym64_fix; 407 408 sym64_gen = find_symbol64(v64, orig); 409 if (sym64_gen == NULL) { 410 printk(KERN_ERR "vDSO64: Can't find symbol %s !\n", orig); 411 return -1; 412 } 413 if (fix == NULL) { 414 sym64_gen->st_name = 0; 415 return 0; 416 } 417 sym64_fix = find_symbol64(v64, fix); 418 if (sym64_fix == NULL) { 419 printk(KERN_ERR "vDSO64: Can't find symbol %s !\n", fix); 420 return -1; 421 } 422 sym64_gen->st_value = sym64_fix->st_value; 423 sym64_gen->st_size = sym64_fix->st_size; 424 sym64_gen->st_info = sym64_fix->st_info; 425 sym64_gen->st_other = sym64_fix->st_other; 426 sym64_gen->st_shndx = sym64_fix->st_shndx; 427 428 return 0; 429 } 430 431 #endif /* CONFIG_PPC64 */ 432 433 434 static __init int vdso_do_find_sections(struct lib32_elfinfo *v32, 435 struct lib64_elfinfo *v64) 436 { 437 void *sect; 438 439 /* 440 * Locate symbol tables & text section 441 */ 442 443 #ifdef CONFIG_VDSO32 444 v32->dynsym = find_section32(v32->hdr, ".dynsym", &v32->dynsymsize); 445 v32->dynstr = find_section32(v32->hdr, ".dynstr", NULL); 446 if (v32->dynsym == NULL || v32->dynstr == NULL) { 447 printk(KERN_ERR "vDSO32: required symbol section not found\n"); 448 return -1; 449 } 450 sect = find_section32(v32->hdr, ".text", NULL); 451 if (sect == NULL) { 452 printk(KERN_ERR "vDSO32: the .text section was not found\n"); 453 return -1; 454 } 455 v32->text = sect - vdso32_kbase; 456 #endif 457 458 #ifdef CONFIG_PPC64 459 v64->dynsym = find_section64(v64->hdr, ".dynsym", &v64->dynsymsize); 460 v64->dynstr = find_section64(v64->hdr, ".dynstr", NULL); 461 if (v64->dynsym == NULL || v64->dynstr == NULL) { 462 printk(KERN_ERR "vDSO64: required symbol section not found\n"); 463 return -1; 464 } 465 sect = find_section64(v64->hdr, ".text", NULL); 466 if (sect == NULL) { 467 printk(KERN_ERR "vDSO64: the .text section was not found\n"); 468 return -1; 469 } 470 v64->text = sect - vdso64_kbase; 471 #endif /* CONFIG_PPC64 */ 472 473 return 0; 474 } 475 476 static __init void vdso_setup_trampolines(struct lib32_elfinfo *v32, 477 struct lib64_elfinfo *v64) 478 { 479 /* 480 * Find signal trampolines 481 */ 482 483 #ifdef CONFIG_PPC64 484 vdso64_rt_sigtramp = find_function64(v64, "__kernel_sigtramp_rt64"); 485 #endif 486 vdso32_sigtramp = find_function32(v32, "__kernel_sigtramp32"); 487 vdso32_rt_sigtramp = find_function32(v32, "__kernel_sigtramp_rt32"); 488 } 489 490 static __init int vdso_fixup_datapage(struct lib32_elfinfo *v32, 491 struct lib64_elfinfo *v64) 492 { 493 #ifdef CONFIG_VDSO32 494 Elf32_Sym *sym32; 495 #endif 496 #ifdef CONFIG_PPC64 497 Elf64_Sym *sym64; 498 499 sym64 = find_symbol64(v64, "__kernel_datapage_offset"); 500 if (sym64 == NULL) { 501 printk(KERN_ERR "vDSO64: Can't find symbol " 502 "__kernel_datapage_offset !\n"); 503 return -1; 504 } 505 *((int *)(vdso64_kbase + sym64->st_value - VDSO64_LBASE)) = 506 (vdso64_pages << PAGE_SHIFT) - 507 (sym64->st_value - VDSO64_LBASE); 508 #endif /* CONFIG_PPC64 */ 509 510 #ifdef CONFIG_VDSO32 511 sym32 = find_symbol32(v32, "__kernel_datapage_offset"); 512 if (sym32 == NULL) { 513 printk(KERN_ERR "vDSO32: Can't find symbol " 514 "__kernel_datapage_offset !\n"); 515 return -1; 516 } 517 *((int *)(vdso32_kbase + (sym32->st_value - VDSO32_LBASE))) = 518 (vdso32_pages << PAGE_SHIFT) - 519 (sym32->st_value - VDSO32_LBASE); 520 #endif 521 522 return 0; 523 } 524 525 526 static __init int vdso_fixup_features(struct lib32_elfinfo *v32, 527 struct lib64_elfinfo *v64) 528 { 529 unsigned long size; 530 void *start; 531 532 #ifdef CONFIG_PPC64 533 start = find_section64(v64->hdr, "__ftr_fixup", &size); 534 if (start) 535 do_feature_fixups(cur_cpu_spec->cpu_features, 536 start, start + size); 537 538 start = find_section64(v64->hdr, "__mmu_ftr_fixup", &size); 539 if (start) 540 do_feature_fixups(cur_cpu_spec->mmu_features, 541 start, start + size); 542 543 start = find_section64(v64->hdr, "__fw_ftr_fixup", &size); 544 if (start) 545 do_feature_fixups(powerpc_firmware_features, 546 start, start + size); 547 548 start = find_section64(v64->hdr, "__lwsync_fixup", &size); 549 if (start) 550 do_lwsync_fixups(cur_cpu_spec->cpu_features, 551 start, start + size); 552 #endif /* CONFIG_PPC64 */ 553 554 #ifdef CONFIG_VDSO32 555 start = find_section32(v32->hdr, "__ftr_fixup", &size); 556 if (start) 557 do_feature_fixups(cur_cpu_spec->cpu_features, 558 start, start + size); 559 560 start = find_section32(v32->hdr, "__mmu_ftr_fixup", &size); 561 if (start) 562 do_feature_fixups(cur_cpu_spec->mmu_features, 563 start, start + size); 564 565 #ifdef CONFIG_PPC64 566 start = find_section32(v32->hdr, "__fw_ftr_fixup", &size); 567 if (start) 568 do_feature_fixups(powerpc_firmware_features, 569 start, start + size); 570 #endif /* CONFIG_PPC64 */ 571 572 start = find_section32(v32->hdr, "__lwsync_fixup", &size); 573 if (start) 574 do_lwsync_fixups(cur_cpu_spec->cpu_features, 575 start, start + size); 576 #endif 577 578 return 0; 579 } 580 581 static __init int vdso_fixup_alt_funcs(struct lib32_elfinfo *v32, 582 struct lib64_elfinfo *v64) 583 { 584 int i; 585 586 for (i = 0; i < ARRAY_SIZE(vdso_patches); i++) { 587 struct vdso_patch_def *patch = &vdso_patches[i]; 588 int match = (cur_cpu_spec->cpu_features & patch->ftr_mask) 589 == patch->ftr_value; 590 if (!match) 591 continue; 592 593 DBG("replacing %s with %s...\n", patch->gen_name, 594 patch->fix_name ? "NONE" : patch->fix_name); 595 596 /* 597 * Patch the 32 bits and 64 bits symbols. Note that we do not 598 * patch the "." symbol on 64 bits. 599 * It would be easy to do, but doesn't seem to be necessary, 600 * patching the OPD symbol is enough. 601 */ 602 vdso_do_func_patch32(v32, v64, patch->gen_name, 603 patch->fix_name); 604 #ifdef CONFIG_PPC64 605 vdso_do_func_patch64(v32, v64, patch->gen_name, 606 patch->fix_name); 607 #endif /* CONFIG_PPC64 */ 608 } 609 610 return 0; 611 } 612 613 614 static __init int vdso_setup(void) 615 { 616 struct lib32_elfinfo v32; 617 struct lib64_elfinfo v64; 618 619 v32.hdr = vdso32_kbase; 620 #ifdef CONFIG_PPC64 621 v64.hdr = vdso64_kbase; 622 #endif 623 if (vdso_do_find_sections(&v32, &v64)) 624 return -1; 625 626 if (vdso_fixup_datapage(&v32, &v64)) 627 return -1; 628 629 if (vdso_fixup_features(&v32, &v64)) 630 return -1; 631 632 if (vdso_fixup_alt_funcs(&v32, &v64)) 633 return -1; 634 635 vdso_setup_trampolines(&v32, &v64); 636 637 return 0; 638 } 639 640 /* 641 * Called from setup_arch to initialize the bitmap of available 642 * syscalls in the systemcfg page 643 */ 644 static void __init vdso_setup_syscall_map(void) 645 { 646 unsigned int i; 647 extern unsigned long *sys_call_table; 648 #ifdef CONFIG_PPC64 649 extern unsigned long *compat_sys_call_table; 650 #endif 651 extern unsigned long sys_ni_syscall; 652 653 654 for (i = 0; i < NR_syscalls; i++) { 655 #ifdef CONFIG_PPC64 656 if (sys_call_table[i] != sys_ni_syscall) 657 vdso_data->syscall_map_64[i >> 5] |= 658 0x80000000UL >> (i & 0x1f); 659 if (compat_sys_call_table[i] != sys_ni_syscall) 660 vdso_data->syscall_map_32[i >> 5] |= 661 0x80000000UL >> (i & 0x1f); 662 #else /* CONFIG_PPC64 */ 663 if (sys_call_table[i] != sys_ni_syscall) 664 vdso_data->syscall_map_32[i >> 5] |= 665 0x80000000UL >> (i & 0x1f); 666 #endif /* CONFIG_PPC64 */ 667 } 668 } 669 670 #ifdef CONFIG_PPC64 671 int vdso_getcpu_init(void) 672 { 673 unsigned long cpu, node, val; 674 675 /* 676 * SPRG_VDSO contains the CPU in the bottom 16 bits and the NUMA node 677 * in the next 16 bits. The VDSO uses this to implement getcpu(). 678 */ 679 cpu = get_cpu(); 680 WARN_ON_ONCE(cpu > 0xffff); 681 682 node = cpu_to_node(cpu); 683 WARN_ON_ONCE(node > 0xffff); 684 685 val = (cpu & 0xfff) | ((node & 0xffff) << 16); 686 mtspr(SPRN_SPRG_VDSO_WRITE, val); 687 get_paca()->sprg_vdso = val; 688 689 put_cpu(); 690 691 return 0; 692 } 693 /* We need to call this before SMP init */ 694 early_initcall(vdso_getcpu_init); 695 #endif 696 697 static int __init vdso_init(void) 698 { 699 int i; 700 701 #ifdef CONFIG_PPC64 702 /* 703 * Fill up the "systemcfg" stuff for backward compatibility 704 */ 705 strcpy((char *)vdso_data->eye_catcher, "SYSTEMCFG:PPC64"); 706 vdso_data->version.major = SYSTEMCFG_MAJOR; 707 vdso_data->version.minor = SYSTEMCFG_MINOR; 708 vdso_data->processor = mfspr(SPRN_PVR); 709 /* 710 * Fake the old platform number for pSeries and add 711 * in LPAR bit if necessary 712 */ 713 vdso_data->platform = 0x100; 714 if (firmware_has_feature(FW_FEATURE_LPAR)) 715 vdso_data->platform |= 1; 716 vdso_data->physicalMemorySize = memblock_phys_mem_size(); 717 vdso_data->dcache_size = ppc64_caches.l1d.size; 718 vdso_data->dcache_line_size = ppc64_caches.l1d.line_size; 719 vdso_data->icache_size = ppc64_caches.l1i.size; 720 vdso_data->icache_line_size = ppc64_caches.l1i.line_size; 721 vdso_data->dcache_block_size = ppc64_caches.l1d.block_size; 722 vdso_data->icache_block_size = ppc64_caches.l1i.block_size; 723 vdso_data->dcache_log_block_size = ppc64_caches.l1d.log_block_size; 724 vdso_data->icache_log_block_size = ppc64_caches.l1i.log_block_size; 725 726 /* 727 * Calculate the size of the 64 bits vDSO 728 */ 729 vdso64_pages = (&vdso64_end - &vdso64_start) >> PAGE_SHIFT; 730 DBG("vdso64_kbase: %p, 0x%x pages\n", vdso64_kbase, vdso64_pages); 731 #else 732 vdso_data->dcache_block_size = L1_CACHE_BYTES; 733 vdso_data->dcache_log_block_size = L1_CACHE_SHIFT; 734 vdso_data->icache_block_size = L1_CACHE_BYTES; 735 vdso_data->icache_log_block_size = L1_CACHE_SHIFT; 736 #endif /* CONFIG_PPC64 */ 737 738 739 #ifdef CONFIG_VDSO32 740 vdso32_kbase = &vdso32_start; 741 742 /* 743 * Calculate the size of the 32 bits vDSO 744 */ 745 vdso32_pages = (&vdso32_end - &vdso32_start) >> PAGE_SHIFT; 746 DBG("vdso32_kbase: %p, 0x%x pages\n", vdso32_kbase, vdso32_pages); 747 #endif 748 749 750 /* 751 * Setup the syscall map in the vDOS 752 */ 753 vdso_setup_syscall_map(); 754 755 /* 756 * Initialize the vDSO images in memory, that is do necessary 757 * fixups of vDSO symbols, locate trampolines, etc... 758 */ 759 if (vdso_setup()) { 760 printk(KERN_ERR "vDSO setup failure, not enabled !\n"); 761 vdso32_pages = 0; 762 #ifdef CONFIG_PPC64 763 vdso64_pages = 0; 764 #endif 765 return 0; 766 } 767 768 #ifdef CONFIG_VDSO32 769 /* Make sure pages are in the correct state */ 770 vdso32_pagelist = kcalloc(vdso32_pages + 2, sizeof(struct page *), 771 GFP_KERNEL); 772 BUG_ON(vdso32_pagelist == NULL); 773 for (i = 0; i < vdso32_pages; i++) { 774 struct page *pg = virt_to_page(vdso32_kbase + i*PAGE_SIZE); 775 get_page(pg); 776 vdso32_pagelist[i] = pg; 777 } 778 vdso32_pagelist[i++] = virt_to_page(vdso_data); 779 vdso32_pagelist[i] = NULL; 780 #endif 781 782 #ifdef CONFIG_PPC64 783 vdso64_pagelist = kcalloc(vdso64_pages + 2, sizeof(struct page *), 784 GFP_KERNEL); 785 BUG_ON(vdso64_pagelist == NULL); 786 for (i = 0; i < vdso64_pages; i++) { 787 struct page *pg = virt_to_page(vdso64_kbase + i*PAGE_SIZE); 788 get_page(pg); 789 vdso64_pagelist[i] = pg; 790 } 791 vdso64_pagelist[i++] = virt_to_page(vdso_data); 792 vdso64_pagelist[i] = NULL; 793 #endif /* CONFIG_PPC64 */ 794 795 get_page(virt_to_page(vdso_data)); 796 797 smp_wmb(); 798 vdso_ready = 1; 799 800 return 0; 801 } 802 arch_initcall(vdso_init); 803