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