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/* && 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, 188 int executable_stack) 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 vdso_base = VDSO64_MBASE; 208 } 209 #else 210 vdso_pagelist = vdso32_pagelist; 211 vdso_pages = vdso32_pages; 212 vdso_base = VDSO32_MBASE; 213 #endif 214 215 current->mm->context.vdso_base = 0; 216 217 /* vDSO has a problem and was disabled, just don't "enable" it for the 218 * process 219 */ 220 if (vdso_pages == 0) 221 return 0; 222 /* Add a page to the vdso size for the data page */ 223 vdso_pages ++; 224 225 /* 226 * pick a base address for the vDSO in process space. We try to put it 227 * at vdso_base which is the "natural" base for it, but we might fail 228 * and end up putting it elsewhere. 229 */ 230 down_write(&mm->mmap_sem); 231 vdso_base = get_unmapped_area(NULL, vdso_base, 232 vdso_pages << PAGE_SHIFT, 0, 0); 233 if (IS_ERR_VALUE(vdso_base)) { 234 rc = vdso_base; 235 goto fail_mmapsem; 236 } 237 238 /* 239 * our vma flags don't have VM_WRITE so by default, the process isn't 240 * allowed to write those pages. 241 * gdb can break that with ptrace interface, and thus trigger COW on 242 * those pages but it's then your responsibility to never do that on 243 * the "data" page of the vDSO or you'll stop getting kernel updates 244 * and your nice userland gettimeofday will be totally dead. 245 * It's fine to use that for setting breakpoints in the vDSO code 246 * pages though 247 * 248 * Make sure the vDSO gets into every core dump. 249 * Dumping its contents makes post-mortem fully interpretable later 250 * without matching up the same kernel and hardware config to see 251 * what PC values meant. 252 */ 253 rc = install_special_mapping(mm, vdso_base, vdso_pages << PAGE_SHIFT, 254 VM_READ|VM_EXEC| 255 VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC| 256 VM_ALWAYSDUMP, 257 vdso_pagelist); 258 if (rc) 259 goto fail_mmapsem; 260 261 /* Put vDSO base into mm struct */ 262 current->mm->context.vdso_base = vdso_base; 263 264 up_write(&mm->mmap_sem); 265 return 0; 266 267 fail_mmapsem: 268 up_write(&mm->mmap_sem); 269 return rc; 270 } 271 272 const char *arch_vma_name(struct vm_area_struct *vma) 273 { 274 if (vma->vm_mm && vma->vm_start == vma->vm_mm->context.vdso_base) 275 return "[vdso]"; 276 return NULL; 277 } 278 279 280 281 static void * __init find_section32(Elf32_Ehdr *ehdr, const char *secname, 282 unsigned long *size) 283 { 284 Elf32_Shdr *sechdrs; 285 unsigned int i; 286 char *secnames; 287 288 /* Grab section headers and strings so we can tell who is who */ 289 sechdrs = (void *)ehdr + ehdr->e_shoff; 290 secnames = (void *)ehdr + sechdrs[ehdr->e_shstrndx].sh_offset; 291 292 /* Find the section they want */ 293 for (i = 1; i < ehdr->e_shnum; i++) { 294 if (strcmp(secnames+sechdrs[i].sh_name, secname) == 0) { 295 if (size) 296 *size = sechdrs[i].sh_size; 297 return (void *)ehdr + sechdrs[i].sh_offset; 298 } 299 } 300 *size = 0; 301 return NULL; 302 } 303 304 static Elf32_Sym * __init find_symbol32(struct lib32_elfinfo *lib, 305 const char *symname) 306 { 307 unsigned int i; 308 char name[MAX_SYMNAME], *c; 309 310 for (i = 0; i < (lib->dynsymsize / sizeof(Elf32_Sym)); i++) { 311 if (lib->dynsym[i].st_name == 0) 312 continue; 313 strlcpy(name, lib->dynstr + lib->dynsym[i].st_name, 314 MAX_SYMNAME); 315 c = strchr(name, '@'); 316 if (c) 317 *c = 0; 318 if (strcmp(symname, name) == 0) 319 return &lib->dynsym[i]; 320 } 321 return NULL; 322 } 323 324 /* Note that we assume the section is .text and the symbol is relative to 325 * the library base 326 */ 327 static unsigned long __init find_function32(struct lib32_elfinfo *lib, 328 const char *symname) 329 { 330 Elf32_Sym *sym = find_symbol32(lib, symname); 331 332 if (sym == NULL) { 333 printk(KERN_WARNING "vDSO32: function %s not found !\n", 334 symname); 335 return 0; 336 } 337 return sym->st_value - VDSO32_LBASE; 338 } 339 340 static int __init vdso_do_func_patch32(struct lib32_elfinfo *v32, 341 struct lib64_elfinfo *v64, 342 const char *orig, const char *fix) 343 { 344 Elf32_Sym *sym32_gen, *sym32_fix; 345 346 sym32_gen = find_symbol32(v32, orig); 347 if (sym32_gen == NULL) { 348 printk(KERN_ERR "vDSO32: Can't find symbol %s !\n", orig); 349 return -1; 350 } 351 if (fix == NULL) { 352 sym32_gen->st_name = 0; 353 return 0; 354 } 355 sym32_fix = find_symbol32(v32, fix); 356 if (sym32_fix == NULL) { 357 printk(KERN_ERR "vDSO32: Can't find symbol %s !\n", fix); 358 return -1; 359 } 360 sym32_gen->st_value = sym32_fix->st_value; 361 sym32_gen->st_size = sym32_fix->st_size; 362 sym32_gen->st_info = sym32_fix->st_info; 363 sym32_gen->st_other = sym32_fix->st_other; 364 sym32_gen->st_shndx = sym32_fix->st_shndx; 365 366 return 0; 367 } 368 369 370 #ifdef CONFIG_PPC64 371 372 static void * __init find_section64(Elf64_Ehdr *ehdr, const char *secname, 373 unsigned long *size) 374 { 375 Elf64_Shdr *sechdrs; 376 unsigned int i; 377 char *secnames; 378 379 /* Grab section headers and strings so we can tell who is who */ 380 sechdrs = (void *)ehdr + ehdr->e_shoff; 381 secnames = (void *)ehdr + sechdrs[ehdr->e_shstrndx].sh_offset; 382 383 /* Find the section they want */ 384 for (i = 1; i < ehdr->e_shnum; i++) { 385 if (strcmp(secnames+sechdrs[i].sh_name, secname) == 0) { 386 if (size) 387 *size = sechdrs[i].sh_size; 388 return (void *)ehdr + sechdrs[i].sh_offset; 389 } 390 } 391 if (size) 392 *size = 0; 393 return NULL; 394 } 395 396 static Elf64_Sym * __init find_symbol64(struct lib64_elfinfo *lib, 397 const char *symname) 398 { 399 unsigned int i; 400 char name[MAX_SYMNAME], *c; 401 402 for (i = 0; i < (lib->dynsymsize / sizeof(Elf64_Sym)); i++) { 403 if (lib->dynsym[i].st_name == 0) 404 continue; 405 strlcpy(name, lib->dynstr + lib->dynsym[i].st_name, 406 MAX_SYMNAME); 407 c = strchr(name, '@'); 408 if (c) 409 *c = 0; 410 if (strcmp(symname, name) == 0) 411 return &lib->dynsym[i]; 412 } 413 return NULL; 414 } 415 416 /* Note that we assume the section is .text and the symbol is relative to 417 * the library base 418 */ 419 static unsigned long __init find_function64(struct lib64_elfinfo *lib, 420 const char *symname) 421 { 422 Elf64_Sym *sym = find_symbol64(lib, symname); 423 424 if (sym == NULL) { 425 printk(KERN_WARNING "vDSO64: function %s not found !\n", 426 symname); 427 return 0; 428 } 429 #ifdef VDS64_HAS_DESCRIPTORS 430 return *((u64 *)(vdso64_kbase + sym->st_value - VDSO64_LBASE)) - 431 VDSO64_LBASE; 432 #else 433 return sym->st_value - VDSO64_LBASE; 434 #endif 435 } 436 437 static int __init vdso_do_func_patch64(struct lib32_elfinfo *v32, 438 struct lib64_elfinfo *v64, 439 const char *orig, const char *fix) 440 { 441 Elf64_Sym *sym64_gen, *sym64_fix; 442 443 sym64_gen = find_symbol64(v64, orig); 444 if (sym64_gen == NULL) { 445 printk(KERN_ERR "vDSO64: Can't find symbol %s !\n", orig); 446 return -1; 447 } 448 if (fix == NULL) { 449 sym64_gen->st_name = 0; 450 return 0; 451 } 452 sym64_fix = find_symbol64(v64, fix); 453 if (sym64_fix == NULL) { 454 printk(KERN_ERR "vDSO64: Can't find symbol %s !\n", fix); 455 return -1; 456 } 457 sym64_gen->st_value = sym64_fix->st_value; 458 sym64_gen->st_size = sym64_fix->st_size; 459 sym64_gen->st_info = sym64_fix->st_info; 460 sym64_gen->st_other = sym64_fix->st_other; 461 sym64_gen->st_shndx = sym64_fix->st_shndx; 462 463 return 0; 464 } 465 466 #endif /* CONFIG_PPC64 */ 467 468 469 static __init int vdso_do_find_sections(struct lib32_elfinfo *v32, 470 struct lib64_elfinfo *v64) 471 { 472 void *sect; 473 474 /* 475 * Locate symbol tables & text section 476 */ 477 478 v32->dynsym = find_section32(v32->hdr, ".dynsym", &v32->dynsymsize); 479 v32->dynstr = find_section32(v32->hdr, ".dynstr", NULL); 480 if (v32->dynsym == NULL || v32->dynstr == NULL) { 481 printk(KERN_ERR "vDSO32: required symbol section not found\n"); 482 return -1; 483 } 484 sect = find_section32(v32->hdr, ".text", NULL); 485 if (sect == NULL) { 486 printk(KERN_ERR "vDSO32: the .text section was not found\n"); 487 return -1; 488 } 489 v32->text = sect - vdso32_kbase; 490 491 #ifdef CONFIG_PPC64 492 v64->dynsym = find_section64(v64->hdr, ".dynsym", &v64->dynsymsize); 493 v64->dynstr = find_section64(v64->hdr, ".dynstr", NULL); 494 if (v64->dynsym == NULL || v64->dynstr == NULL) { 495 printk(KERN_ERR "vDSO64: required symbol section not found\n"); 496 return -1; 497 } 498 sect = find_section64(v64->hdr, ".text", NULL); 499 if (sect == NULL) { 500 printk(KERN_ERR "vDSO64: the .text section was not found\n"); 501 return -1; 502 } 503 v64->text = sect - vdso64_kbase; 504 #endif /* CONFIG_PPC64 */ 505 506 return 0; 507 } 508 509 static __init void vdso_setup_trampolines(struct lib32_elfinfo *v32, 510 struct lib64_elfinfo *v64) 511 { 512 /* 513 * Find signal trampolines 514 */ 515 516 #ifdef CONFIG_PPC64 517 vdso64_rt_sigtramp = find_function64(v64, "__kernel_sigtramp_rt64"); 518 #endif 519 vdso32_sigtramp = find_function32(v32, "__kernel_sigtramp32"); 520 vdso32_rt_sigtramp = find_function32(v32, "__kernel_sigtramp_rt32"); 521 } 522 523 static __init int vdso_fixup_datapage(struct lib32_elfinfo *v32, 524 struct lib64_elfinfo *v64) 525 { 526 Elf32_Sym *sym32; 527 #ifdef CONFIG_PPC64 528 Elf64_Sym *sym64; 529 530 sym64 = find_symbol64(v64, "__kernel_datapage_offset"); 531 if (sym64 == NULL) { 532 printk(KERN_ERR "vDSO64: Can't find symbol " 533 "__kernel_datapage_offset !\n"); 534 return -1; 535 } 536 *((int *)(vdso64_kbase + sym64->st_value - VDSO64_LBASE)) = 537 (vdso64_pages << PAGE_SHIFT) - 538 (sym64->st_value - VDSO64_LBASE); 539 #endif /* CONFIG_PPC64 */ 540 541 sym32 = find_symbol32(v32, "__kernel_datapage_offset"); 542 if (sym32 == NULL) { 543 printk(KERN_ERR "vDSO32: Can't find symbol " 544 "__kernel_datapage_offset !\n"); 545 return -1; 546 } 547 *((int *)(vdso32_kbase + (sym32->st_value - VDSO32_LBASE))) = 548 (vdso32_pages << PAGE_SHIFT) - 549 (sym32->st_value - VDSO32_LBASE); 550 551 return 0; 552 } 553 554 555 static __init int vdso_fixup_features(struct lib32_elfinfo *v32, 556 struct lib64_elfinfo *v64) 557 { 558 void *start32; 559 unsigned long size32; 560 561 #ifdef CONFIG_PPC64 562 void *start64; 563 unsigned long size64; 564 565 start64 = find_section64(v64->hdr, "__ftr_fixup", &size64); 566 if (start64) 567 do_feature_fixups(cur_cpu_spec->cpu_features, 568 start64, start64 + size64); 569 570 start64 = find_section64(v64->hdr, "__fw_ftr_fixup", &size64); 571 if (start64) 572 do_feature_fixups(powerpc_firmware_features, 573 start64, start64 + size64); 574 #endif /* CONFIG_PPC64 */ 575 576 start32 = find_section32(v32->hdr, "__ftr_fixup", &size32); 577 if (start32) 578 do_feature_fixups(cur_cpu_spec->cpu_features, 579 start32, start32 + size32); 580 581 #ifdef CONFIG_PPC64 582 start32 = find_section32(v32->hdr, "__fw_ftr_fixup", &size32); 583 if (start32) 584 do_feature_fixups(powerpc_firmware_features, 585 start32, start32 + size32); 586 #endif /* CONFIG_PPC64 */ 587 588 return 0; 589 } 590 591 static __init int vdso_fixup_alt_funcs(struct lib32_elfinfo *v32, 592 struct lib64_elfinfo *v64) 593 { 594 int i; 595 596 for (i = 0; i < ARRAY_SIZE(vdso_patches); i++) { 597 struct vdso_patch_def *patch = &vdso_patches[i]; 598 int match = (cur_cpu_spec->cpu_features & patch->ftr_mask) 599 == patch->ftr_value; 600 if (!match) 601 continue; 602 603 DBG("replacing %s with %s...\n", patch->gen_name, 604 patch->fix_name ? "NONE" : patch->fix_name); 605 606 /* 607 * Patch the 32 bits and 64 bits symbols. Note that we do not 608 * patch the "." symbol on 64 bits. 609 * It would be easy to do, but doesn't seem to be necessary, 610 * patching the OPD symbol is enough. 611 */ 612 vdso_do_func_patch32(v32, v64, patch->gen_name, 613 patch->fix_name); 614 #ifdef CONFIG_PPC64 615 vdso_do_func_patch64(v32, v64, patch->gen_name, 616 patch->fix_name); 617 #endif /* CONFIG_PPC64 */ 618 } 619 620 return 0; 621 } 622 623 624 static __init int vdso_setup(void) 625 { 626 struct lib32_elfinfo v32; 627 struct lib64_elfinfo v64; 628 629 v32.hdr = vdso32_kbase; 630 #ifdef CONFIG_PPC64 631 v64.hdr = vdso64_kbase; 632 #endif 633 if (vdso_do_find_sections(&v32, &v64)) 634 return -1; 635 636 if (vdso_fixup_datapage(&v32, &v64)) 637 return -1; 638 639 if (vdso_fixup_features(&v32, &v64)) 640 return -1; 641 642 if (vdso_fixup_alt_funcs(&v32, &v64)) 643 return -1; 644 645 vdso_setup_trampolines(&v32, &v64); 646 647 return 0; 648 } 649 650 /* 651 * Called from setup_arch to initialize the bitmap of available 652 * syscalls in the systemcfg page 653 */ 654 static void __init vdso_setup_syscall_map(void) 655 { 656 unsigned int i; 657 extern unsigned long *sys_call_table; 658 extern unsigned long sys_ni_syscall; 659 660 661 for (i = 0; i < __NR_syscalls; i++) { 662 #ifdef CONFIG_PPC64 663 if (sys_call_table[i*2] != sys_ni_syscall) 664 vdso_data->syscall_map_64[i >> 5] |= 665 0x80000000UL >> (i & 0x1f); 666 if (sys_call_table[i*2+1] != sys_ni_syscall) 667 vdso_data->syscall_map_32[i >> 5] |= 668 0x80000000UL >> (i & 0x1f); 669 #else /* CONFIG_PPC64 */ 670 if (sys_call_table[i] != sys_ni_syscall) 671 vdso_data->syscall_map_32[i >> 5] |= 672 0x80000000UL >> (i & 0x1f); 673 #endif /* CONFIG_PPC64 */ 674 } 675 } 676 677 678 static int __init vdso_init(void) 679 { 680 int i; 681 682 #ifdef CONFIG_PPC64 683 /* 684 * Fill up the "systemcfg" stuff for backward compatiblity 685 */ 686 strcpy((char *)vdso_data->eye_catcher, "SYSTEMCFG:PPC64"); 687 vdso_data->version.major = SYSTEMCFG_MAJOR; 688 vdso_data->version.minor = SYSTEMCFG_MINOR; 689 vdso_data->processor = mfspr(SPRN_PVR); 690 /* 691 * Fake the old platform number for pSeries and iSeries and add 692 * in LPAR bit if necessary 693 */ 694 vdso_data->platform = machine_is(iseries) ? 0x200 : 0x100; 695 if (firmware_has_feature(FW_FEATURE_LPAR)) 696 vdso_data->platform |= 1; 697 vdso_data->physicalMemorySize = lmb_phys_mem_size(); 698 vdso_data->dcache_size = ppc64_caches.dsize; 699 vdso_data->dcache_line_size = ppc64_caches.dline_size; 700 vdso_data->icache_size = ppc64_caches.isize; 701 vdso_data->icache_line_size = ppc64_caches.iline_size; 702 703 /* XXXOJN: Blocks should be added to ppc64_caches and used instead */ 704 vdso_data->dcache_block_size = ppc64_caches.dline_size; 705 vdso_data->icache_block_size = ppc64_caches.iline_size; 706 vdso_data->dcache_log_block_size = ppc64_caches.log_dline_size; 707 vdso_data->icache_log_block_size = ppc64_caches.log_iline_size; 708 709 /* 710 * Calculate the size of the 64 bits vDSO 711 */ 712 vdso64_pages = (&vdso64_end - &vdso64_start) >> PAGE_SHIFT; 713 DBG("vdso64_kbase: %p, 0x%x pages\n", vdso64_kbase, vdso64_pages); 714 #else 715 vdso_data->dcache_block_size = L1_CACHE_BYTES; 716 vdso_data->dcache_log_block_size = L1_CACHE_SHIFT; 717 vdso_data->icache_block_size = L1_CACHE_BYTES; 718 vdso_data->icache_log_block_size = L1_CACHE_SHIFT; 719 #endif /* CONFIG_PPC64 */ 720 721 722 /* 723 * Calculate the size of the 32 bits vDSO 724 */ 725 vdso32_pages = (&vdso32_end - &vdso32_start) >> PAGE_SHIFT; 726 DBG("vdso32_kbase: %p, 0x%x pages\n", vdso32_kbase, vdso32_pages); 727 728 729 /* 730 * Setup the syscall map in the vDOS 731 */ 732 vdso_setup_syscall_map(); 733 734 /* 735 * Initialize the vDSO images in memory, that is do necessary 736 * fixups of vDSO symbols, locate trampolines, etc... 737 */ 738 if (vdso_setup()) { 739 printk(KERN_ERR "vDSO setup failure, not enabled !\n"); 740 vdso32_pages = 0; 741 #ifdef CONFIG_PPC64 742 vdso64_pages = 0; 743 #endif 744 return 0; 745 } 746 747 /* Make sure pages are in the correct state */ 748 vdso32_pagelist = kzalloc(sizeof(struct page *) * (vdso32_pages + 2), 749 GFP_KERNEL); 750 BUG_ON(vdso32_pagelist == NULL); 751 for (i = 0; i < vdso32_pages; i++) { 752 struct page *pg = virt_to_page(vdso32_kbase + i*PAGE_SIZE); 753 ClearPageReserved(pg); 754 get_page(pg); 755 vdso32_pagelist[i] = pg; 756 } 757 vdso32_pagelist[i++] = virt_to_page(vdso_data); 758 vdso32_pagelist[i] = NULL; 759 760 #ifdef CONFIG_PPC64 761 vdso64_pagelist = kzalloc(sizeof(struct page *) * (vdso64_pages + 2), 762 GFP_KERNEL); 763 BUG_ON(vdso64_pagelist == NULL); 764 for (i = 0; i < vdso64_pages; i++) { 765 struct page *pg = virt_to_page(vdso64_kbase + i*PAGE_SIZE); 766 ClearPageReserved(pg); 767 get_page(pg); 768 vdso64_pagelist[i] = pg; 769 } 770 vdso64_pagelist[i++] = virt_to_page(vdso_data); 771 vdso64_pagelist[i] = NULL; 772 #endif /* CONFIG_PPC64 */ 773 774 get_page(virt_to_page(vdso_data)); 775 776 smp_wmb(); 777 vdso_ready = 1; 778 779 return 0; 780 } 781 #ifdef CONFIG_PPC_MERGE 782 arch_initcall(vdso_init); 783 #endif 784 785 int in_gate_area_no_task(unsigned long addr) 786 { 787 return 0; 788 } 789 790 int in_gate_area(struct task_struct *task, unsigned long addr) 791 { 792 return 0; 793 } 794 795 struct vm_area_struct *get_gate_vma(struct task_struct *tsk) 796 { 797 return NULL; 798 } 799 800