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