elf/dl-object.c

   1 /* Storage management for the chain of loaded shared objects.
   2    Copyright (C) 1995-2021 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, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <errno.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <ldsodefs.h>
  24
  25 #include <assert.h>
  26
  27
  28 /* Add the new link_map NEW to the end of the namespace list.  */
  29 void
  30 _dl_add_to_namespace_list (struct link_map *new, Lmid_t nsid)
  31 {
  32   /* We modify the list of loaded objects.  */
  33   __rtld_lock_lock_recursive (GL(dl_load_write_lock));
  34
  35   if (GL(dl_ns)[nsid]._ns_loaded != NULL)
  36     {
  37       struct link_map *l = GL(dl_ns)[nsid]._ns_loaded;
  38       while (l->l_next != NULL)
  39         l = l->l_next;
  40       new->l_prev = l;
  41       /* new->l_next = NULL;   Would be necessary but we use calloc.  */
  42       l->l_next = new;
  43     }
  44   else
  45     GL(dl_ns)[nsid]._ns_loaded = new;
  46   ++GL(dl_ns)[nsid]._ns_nloaded;
  47   new->l_serial = GL(dl_load_adds);
  48   ++GL(dl_load_adds);
  49
  50   __rtld_lock_unlock_recursive (GL(dl_load_write_lock));
  51 }
  52
  53
  54 /* Allocate a `struct link_map' for a new object being loaded,
  55    and enter it into the _dl_loaded list.  */
  56 struct link_map *
  57 _dl_new_object (char *realname, const char *libname, int type,
  58                 struct link_map *loader, int mode, Lmid_t nsid)
  59 {
  60 #ifdef SHARED
  61   unsigned int naudit;
  62   if (__glibc_unlikely ((mode & __RTLD_OPENEXEC) != 0))
  63     {
  64       assert (type == lt_executable);
  65       assert (nsid == LM_ID_BASE);
  66
  67       /* Ignore the specified libname for the main executable.  It is
  68          only known with an explicit loader invocation.  */
  69       libname = "";
  70
  71       /* We create the map for the executable before we know whether
  72          we have auditing libraries and if yes, how many.  Assume the
  73          worst.  */
  74       naudit = DL_NNS;
  75     }
  76   else
  77     naudit = GLRO (dl_naudit);
  78 #endif
  79
  80   size_t libname_len = strlen (libname) + 1;
  81   struct link_map *new;
  82   struct libname_list *newname;
  83 #ifdef SHARED
  84   size_t audit_space = naudit * sizeof (struct auditstate);
  85 #else
  86 # define audit_space 0
  87 #endif
  88
  89   new = (struct link_map *) calloc (sizeof (*new) + audit_space
  90                                     + sizeof (struct link_map *)
  91                                     + sizeof (*newname) + libname_len, 1);
  92   if (new == NULL)
  93     return NULL;
  94
  95   new->l_real = new;
  96   new->l_symbolic_searchlist.r_list = (struct link_map **) ((char *) (new + 1)
  97                                                             + audit_space);
  98
  99   new->l_libname = newname
 100     = (struct libname_list *) (new->l_symbolic_searchlist.r_list + 1);
 101   newname->name = (char *) memcpy (newname + 1, libname, libname_len);
 102   /* newname->next = NULL;      We use calloc therefore not necessary.  */
 103   newname->dont_free = 1;
 104
 105   /* When we create the executable link map, or a VDSO link map, we start
 106      with "" for the l_name. In these cases "" points to ld.so rodata
 107      and won't get dumped during core file generation. Therefore to assist
 108      gdb and to create more self-contained core files we adjust l_name to
 109      point at the newly allocated copy (which will get dumped) instead of
 110      the ld.so rodata copy.
 111
 112      Furthermore, in case of explicit loader invocation, discard the
 113      name of the main executable, to match the regular behavior, where
 114      name of the executable is not known.  */
 115 #ifdef SHARED
 116   if (*realname != '\0' && (mode & __RTLD_OPENEXEC) == 0)
 117 #else
 118   if (*realname != '\0')
 119 #endif
 120     new->l_name = realname;
 121   else
 122     new->l_name = (char *) newname->name + libname_len - 1;
 123
 124   new->l_type = type;
 125   /* If we set the bit now since we know it is never used we avoid
 126      dirtying the cache line later.  */
 127   if ((GLRO(dl_debug_mask) & DL_DEBUG_UNUSED) == 0)
 128     new->l_used = 1;
 129   new->l_loader = loader;
 130 #if NO_TLS_OFFSET != 0
 131   new->l_tls_offset = NO_TLS_OFFSET;
 132 #endif
 133   new->l_ns = nsid;
 134
 135 #ifdef SHARED
 136   for (unsigned int cnt = 0; cnt < naudit; ++cnt)
 137     /* No need to initialize bindflags due to calloc.  */
 138     link_map_audit_state (new, cnt)->cookie = (uintptr_t) new;
 139 #endif
 140
 141   /* new->l_global = 0; We use calloc therefore not necessary.  */
 142
 143   /* Use the 'l_scope_mem' array by default for the 'l_scope'
 144      information.  If we need more entries we will allocate a large
 145      array dynamically.  */
 146   new->l_scope = new->l_scope_mem;
 147   new->l_scope_max = sizeof (new->l_scope_mem) / sizeof (new->l_scope_mem[0]);
 148
 149   /* Counter for the scopes we have to handle.  */
 150   int idx = 0;
 151
 152   if (GL(dl_ns)[nsid]._ns_loaded != NULL)
 153     /* Add the global scope.  */
 154     new->l_scope[idx++] = &GL(dl_ns)[nsid]._ns_loaded->l_searchlist;
 155
 156   /* If we have no loader the new object acts as it.  */
 157   if (loader == NULL)
 158     loader = new;
 159   else
 160     /* Determine the local scope.  */
 161     while (loader->l_loader != NULL)
 162       loader = loader->l_loader;
 163
 164   /* Insert the scope if it isn't the global scope we already added.  */
 165   if (idx == 0 || &loader->l_searchlist != new->l_scope[0])
 166     {
 167       if ((mode & RTLD_DEEPBIND) != 0 && idx != 0)
 168         {
 169           new->l_scope[1] = new->l_scope[0];
 170           idx = 0;
 171         }
 172
 173       new->l_scope[idx] = &loader->l_searchlist;
 174     }
 175
 176   new->l_local_scope[0] = &new->l_searchlist;
 177
 178   /* Determine the origin.  If allocating the link map for the main
 179      executable, the realname is not known and "".  In this case, the
 180      origin needs to be determined by other means.  However, in case
 181      of an explicit loader invocation, the pathname of the main
 182      executable is known and needs to be processed here: From the
 183      point of view of the kernel, the main executable is the
 184      dynamic loader, and this would lead to a computation of the wrong
 185      origin.  */
 186   if (realname[0] != '\0')
 187     {
 188       size_t realname_len = strlen (realname) + 1;
 189       char *origin;
 190       char *cp;
 191
 192       if (realname[0] == '/')
 193         {
 194           /* It is an absolute path.  Use it.  But we have to make a
 195              copy since we strip out the trailing slash.  */
 196           cp = origin = (char *) malloc (realname_len);
 197           if (origin == NULL)
 198             {
 199               origin = (char *) -1;
 200               goto out;
 201             }
 202         }
 203       else
 204         {
 205           size_t len = realname_len;
 206           char *result = NULL;
 207
 208           /* Get the current directory name.  */
 209           origin = NULL;
 210           do
 211             {
 212               char *new_origin;
 213
 214               len += 128;
 215               new_origin = (char *) realloc (origin, len);
 216               if (new_origin == NULL)
 217                 /* We exit the loop.  Note that result == NULL.  */
 218                 break;
 219               origin = new_origin;
 220             }
 221           while ((result = __getcwd (origin, len - realname_len)) == NULL
 222                  && errno == ERANGE);
 223
 224           if (result == NULL)
 225             {
 226               /* We were not able to determine the current directory.
 227                  Note that free(origin) is OK if origin == NULL.  */
 228               free (origin);
 229               origin = (char *) -1;
 230               goto out;
 231             }
 232
 233           /* Find the end of the path and see whether we have to add a
 234              slash.  We could use rawmemchr but this need not be
 235              fast.  */
 236           cp = (strchr) (origin, '\0');
 237           if (cp[-1] != '/')
 238             *cp++ = '/';
 239         }
 240
 241       /* Add the real file name.  */
 242       cp = __mempcpy (cp, realname, realname_len);
 243
 244       /* Now remove the filename and the slash.  Leave the slash if
 245          the name is something like "/foo".  */
 246       do
 247         --cp;
 248       while (*cp != '/');
 249
 250       if (cp == origin)
 251         /* Keep the only slash which is the first character.  */
 252         ++cp;
 253       *cp = '\0';
 254
 255     out:
 256       new->l_origin = origin;
 257     }
 258
 259   return new;
 260 }