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