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