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