git.oblomov.eu Git - linux-2.6/blob - arch/powerpc/kernel/vdso.c

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