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