sysdeps/ia64/dl-fptr.c

   1 /* Unmap a loaded object.  IA-64 version.
   2    Copyright (C) 1999, 2000 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <unistd.h>
  21 #include <string.h>
  22 #include <sys/param.h>
  23 #include <sys/mman.h>
  24 #include <link.h>
  25 #include <ldsodefs.h>
  26 #include <elf/dynamic-link.h>
  27 #include <dl-machine.h>
  28 #ifdef _LIBC_REENTRANT
  29 # include <pt-machine.h>
  30
  31 static int __ia64_fptr_lock = 0;
  32 #endif
  33
  34 /* Because ld.so is now versioned, these functions can be in their own
  35    file; no relocations need to be done to call them.  Of course, if
  36    ld.so is not versioned...  */
  37 #if 0
  38 #ifndef DO_VERSIONING
  39 # error "This will not work with versioning turned off, sorry."
  40 #endif
  41 #endif
  42
  43 #ifdef MAP_ANON
  44 /* The fd is not examined when using MAP_ANON.  */
  45 #define ANONFD -1
  46 #else
  47 extern int _dl_zerofd;
  48 #define ANONFD _dl_zerofd
  49 #endif
  50
  51
  52 /* ld.so currently has 14 FPTR relocs, we take 256 and use them for
  53    the relocs for the dynamic app itself.  */
  54 struct ia64_fptr __boot_ldso_fptr[IA64_BOOT_FPTR_SIZE];
  55 struct ia64_fptr *__fptr_root = NULL;
  56 struct ia64_fptr *__fptr_next = __boot_ldso_fptr;
  57 static struct ia64_fptr *__fptr_free = NULL;
  58 int __fptr_count = IA64_BOOT_FPTR_SIZE;
  59
  60 Elf64_Addr
  61 __ia64_make_fptr (const struct link_map *sym_map, Elf64_Addr value,
  62                   struct ia64_fptr **root, struct ia64_fptr *mem)
  63 {
  64   struct ia64_fptr **loc;
  65   struct ia64_fptr *f;
  66
  67 #ifdef _LIBC_REENTRANT
  68   /* Make sure we are alone. We don't need a lock during bootstrap. */
  69   if (mem == NULL)
  70     while (testandset (&__ia64_fptr_lock));
  71 #endif
  72
  73   /* Search the sorted linked list for an existing entry for this
  74      symbol.  */
  75   loc = root;
  76   f = *loc;
  77   while (f != NULL && f->func <= value)
  78     {
  79       if (f->func == value)
  80         goto found;
  81       loc = &f->next;
  82       f = *loc;
  83     }
  84
  85   /* Not found.  Create a new one.  */
  86   if (mem != NULL)
  87     f = mem;
  88   else if (__fptr_free != NULL)
  89     {
  90       f = __fptr_free;
  91       __fptr_free = f->next;
  92     }
  93   else
  94     {
  95       if (__fptr_count == 0)
  96         {
  97 #ifndef MAP_ANON
  98 # define MAP_ANON 0
  99           if (_dl_zerofd == -1)
 100             {
 101               _dl_zerofd = _dl_sysdep_open_zero_fill ();
 102               if (_dl_zerofd == -1)
 103                 {
 104                   __close (fd);
 105                   _dl_signal_error (errno, NULL,
 106                                     "cannot open zero fill device");
 107                 }
 108             }
 109 #endif
 110
 111           __fptr_next = __mmap (0, _dl_pagesize, PROT_READ | PROT_WRITE,
 112                                 MAP_ANON | MAP_PRIVATE, ANONFD, 0);
 113           if (__fptr_next == MAP_FAILED)
 114             _dl_signal_error(errno, NULL, "cannot map page for fptr");
 115           __fptr_count = _dl_pagesize / sizeof (struct ia64_fptr);
 116         }
 117       f = __fptr_next++;
 118       __fptr_count--;
 119     }
 120
 121   f->func = value;
 122   /* GOT has already been relocated in elf_get_dynamic_info - don't
 123      try to relocate it again.  */
 124   f->gp = sym_map->l_info[DT_PLTGOT]->d_un.d_ptr;
 125   f->next = *loc;
 126   *loc = f;
 127
 128 found:
 129 #ifdef _LIBC_REENTRANT
 130   /* Release the lock.  */
 131   if (mem == NULL)
 132     __ia64_fptr_lock = 0;
 133 #endif
 134
 135   return (Elf64_Addr) f;
 136 }
 137
 138 void
 139 _dl_unmap (struct link_map *map)
 140 {
 141   struct ia64_fptr **floc;
 142   struct ia64_fptr *f;
 143   struct ia64_fptr **lloc;
 144   struct ia64_fptr *l;
 145
 146   __munmap ((void *) map->l_map_start, map->l_map_end - map->l_map_start);
 147
 148 #ifdef _LIBC_REENTRANT
 149   /* Make sure we are alone.  */
 150   while (testandset (&__ia64_fptr_lock));
 151 #endif
 152
 153   /* Search the sorted linked list for the first entry for this object.  */
 154   floc = &__fptr_root;
 155   f = *floc;
 156   while (f != NULL && f->func < map->l_map_start)
 157     {
 158       floc = &f->next;
 159       f = *floc;
 160     }
 161
 162   /* We found one.  */
 163   if (f != NULL && f->func < map->l_map_end)
 164     {
 165       /* Get the last entry.  */
 166       lloc = floc;
 167       l = f;
 168       while (l && l->func < map->l_map_end)
 169         {
 170           lloc = &l->next;
 171           l = *lloc;
 172         }
 173
 174       /* Updated FPTR.  */
 175       *floc = l;
 176
 177       /* Prepend them to the free list.  */
 178       *lloc = __fptr_free;
 179       __fptr_free = f;
 180     }
 181
 182 #ifdef _LIBC_REENTRANT
 183   /* Release the lock.   */
 184   __ia64_fptr_lock = 0;
 185 #endif
 186 }
 187
 188 Elf64_Addr
 189 _dl_lookup_address (const void *address)
 190 {
 191   Elf64_Addr addr = (Elf64_Addr) address;
 192   struct ia64_fptr *f;
 193
 194 #ifdef _LIBC_REENTRANT
 195   /* Make sure we are alone.  */
 196   while (testandset (&__ia64_fptr_lock));
 197 #endif
 198
 199   for (f = __fptr_root; f != NULL; f = f->next)
 200     if (f == address)
 201       {
 202         addr = f->func;
 203         break;
 204       }
 205
 206 #ifdef _LIBC_REENTRANT
 207   /* Release the lock.   */
 208   __ia64_fptr_lock = 0;
 209 #endif
 210
 211   return addr;
 212 }