libexec/ld.elf_so/load.c

   1 /*      $NetBSD: load.c,v 1.35 2007/12/07 20:34:04 ad Exp $      */
   2
   3 /*
   4  * Copyright 1996 John D. Polstra.
   5  * Copyright 1996 Matt Thomas <matt@3am-software.com>
   6  * Copyright 2002 Charles M. Hannum <root@ihack.net>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by John Polstra.
  20  * 4. The name of the author may not be used to endorse or promote products
  21  *    derived from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 /*
  36  * Dynamic linker for ELF.
  37  *
  38  * John Polstra <jdp@polstra.com>.
  39  */
  40
  41 #include <sys/cdefs.h>
  42 #ifndef lint
  43 __RCSID("$NetBSD: load.c,v 1.35 2007/12/07 20:34:04 ad Exp $");
  44 #endif /* not lint */
  45
  46 #include <err.h>
  47 #include <errno.h>
  48 #include <fcntl.h>
  49 #include <stdarg.h>
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <string.h>
  53 #include <unistd.h>
  54 #include <sys/types.h>
  55 #include <sys/param.h>
  56 #include <sys/mman.h>
  57 #include <sys/sysctl.h>
  58 #include <dirent.h>
  59
  60 #include "debug.h"
  61 #include "rtld.h"
  62
  63 static bool _rtld_load_by_name(const char *, Obj_Entry *, Needed_Entry **,
  64     int);
  65
  66 #ifdef RTLD_LOADER
  67 Objlist _rtld_list_main =       /* Objects loaded at program startup */
  68   SIMPLEQ_HEAD_INITIALIZER(_rtld_list_main);
  69 Objlist _rtld_list_global =     /* Objects dlopened with RTLD_GLOBAL */
  70   SIMPLEQ_HEAD_INITIALIZER(_rtld_list_global);
  71
  72 void
  73 _rtld_objlist_push_head(Objlist *list, Obj_Entry *obj)
  74 {
  75         Objlist_Entry *elm;
  76
  77         elm = NEW(Objlist_Entry);
  78         elm->obj = obj;
  79         SIMPLEQ_INSERT_HEAD(list, elm, link);
  80 }
  81
  82 void
  83 _rtld_objlist_push_tail(Objlist *list, Obj_Entry *obj)
  84 {
  85         Objlist_Entry *elm;
  86
  87         elm = NEW(Objlist_Entry);
  88         elm->obj = obj;
  89         SIMPLEQ_INSERT_TAIL(list, elm, link);
  90 }
  91
  92 Objlist_Entry *
  93 _rtld_objlist_find(Objlist *list, const Obj_Entry *obj)
  94 {
  95         Objlist_Entry *elm;
  96
  97         SIMPLEQ_FOREACH(elm, list, link) {
  98                 if (elm->obj == obj)
  99                         return elm;
 100         }
 101         return NULL;
 102 }
 103 #endif
 104
 105 /*
 106  * Load a shared object into memory, if it is not already loaded.
 107  *
 108  * Returns a pointer to the Obj_Entry for the object.  Returns NULL
 109  * on failure.
 110  */
 111 Obj_Entry *
 112 _rtld_load_object(const char *filepath, int mode)
 113 {
 114         Obj_Entry *obj;
 115         int fd = -1;
 116         struct stat sb;
 117         size_t pathlen = strlen(filepath);
 118
 119         for (obj = _rtld_objlist->next; obj != NULL; obj = obj->next)
 120                 if (pathlen == obj->pathlen && !strcmp(obj->path, filepath))
 121                         break;
 122
 123         /*
 124          * If we didn't find a match by pathname, open the file and check
 125          * again by device and inode.  This avoids false mismatches caused
 126          * by multiple links or ".." in pathnames.
 127          *
 128          * To avoid a race, we open the file and use fstat() rather than
 129          * using stat().
 130          */
 131         if (obj == NULL) {
 132                 if ((fd = open(filepath, O_RDONLY)) == -1) {
 133                         _rtld_error("Cannot open \"%s\"", filepath);
 134                         return NULL;
 135                 }
 136                 if (fstat(fd, &sb) == -1) {
 137                         _rtld_error("Cannot fstat \"%s\"", filepath);
 138                         close(fd);
 139                         return NULL;
 140                 }
 141                 for (obj = _rtld_objlist->next; obj != NULL; obj = obj->next) {
 142                         if (obj->ino == sb.st_ino && obj->dev == sb.st_dev) {
 143                                 close(fd);
 144                                 break;
 145                         }
 146                 }
 147         }
 148
 149         if (obj == NULL) { /* First use of this object, so we must map it in */
 150                 obj = _rtld_map_object(filepath, fd, &sb);
 151                 (void)close(fd);
 152                 if (obj == NULL)
 153                         return NULL;
 154                 _rtld_digest_dynamic(filepath, obj);
 155
 156                 *_rtld_objtail = obj;
 157                 _rtld_objtail = &obj->next;
 158 #ifdef RTLD_LOADER
 159                 _rtld_linkmap_add(obj); /* for GDB */
 160 #endif
 161                 dbg(("  %p .. %p: %s", obj->mapbase,
 162                     obj->mapbase + obj->mapsize - 1, obj->path));
 163                 if (obj->textrel)
 164                         dbg(("  WARNING: %s has impure text", obj->path));
 165         }
 166
 167         ++obj->refcount;
 168 #ifdef RTLD_LOADER
 169         if (mode & RTLD_MAIN && !obj->mainref) {
 170                 obj->mainref = 1;
 171                 rdbg(("adding %p (%s) to _rtld_list_main", obj, obj->path));
 172                 _rtld_objlist_push_tail(&_rtld_list_main, obj);
 173         }
 174         if (mode & RTLD_GLOBAL && !obj->globalref) {
 175                 obj->globalref = 1;
 176                 rdbg(("adding %p (%s) to _rtld_list_global", obj, obj->path));
 177                 _rtld_objlist_push_tail(&_rtld_list_global, obj);
 178         }
 179 #endif
 180         return obj;
 181 }
 182
 183 static bool
 184 _rtld_load_by_name(const char *name, Obj_Entry *obj, Needed_Entry **needed, int mode)
 185 {
 186         Library_Xform *x = _rtld_xforms;
 187         Obj_Entry *o = NULL;
 188         size_t j;
 189         ssize_t i;
 190         bool got = false;
 191         union {
 192                 int i;
 193                 u_quad_t q;
 194                 char s[16];
 195         } val;
 196
 197         dbg(("load by name %s %p", name, x));
 198         for (; x; x = x->next) {
 199                 if (strcmp(x->name, name) != 0)
 200                         continue;
 201
 202                 j = sizeof(val);
 203                 if ((i = _rtld_sysctl(x->ctlname, &val, &j)) == -1) {
 204                         xwarnx(_PATH_LD_HINTS ": invalid/unknown sysctl for %s (%d)",
 205                             name, errno);
 206                         break;
 207                 }
 208
 209                 switch (i) {
 210                 case CTLTYPE_QUAD:
 211                         xsnprintf(val.s, sizeof(val.s), "%" PRIu64, val.q);
 212                         break;
 213                 case CTLTYPE_INT:
 214                         xsnprintf(val.s, sizeof(val.s), "%d", val.i);
 215                         break;
 216                 case CTLTYPE_STRING:
 217                         break;
 218                 default:
 219                         xwarnx("unsupported sysctl type %d", (int)i);
 220                         break;
 221                 }
 222
 223                 dbg(("sysctl returns %s", val.s));
 224
 225                 for (i = 0; i < RTLD_MAX_ENTRY && x->entry[i].value != NULL;
 226                     i++) {
 227                         dbg(("entry %ld", (unsigned long)i));
 228                         if (strcmp(x->entry[i].value, val.s) == 0)
 229                                 break;
 230                 }
 231
 232                 if (i == RTLD_MAX_ENTRY) {
 233                         xwarnx("sysctl value %s not found for lib%s",
 234                             val.s, name);
 235                         break;
 236                 }
 237                 /* XXX: This can mess up debuggers, cause we lie about
 238                  * what we loaded in the needed objects */
 239                 for (j = 0; j < RTLD_MAX_LIBRARY &&
 240                     x->entry[i].library[j] != NULL; j++) {
 241                         o = _rtld_load_library(x->entry[i].library[j], obj,
 242                             mode);
 243                         if (o == NULL) {
 244                                 xwarnx("could not load %s for %s",
 245                                     x->entry[i].library[j], name);
 246                                 continue;
 247                         }
 248                         got = true;
 249                         if (j == 0)
 250                                 (*needed)->obj = o;
 251                         else {
 252                                 /* make a new one and put it in the chain */
 253                                 Needed_Entry *ne = xmalloc(sizeof(*ne));
 254                                 ne->name = (*needed)->name;
 255                                 ne->obj = o;
 256                                 ne->next = (*needed)->next;
 257                                 (*needed)->next = ne;
 258                                 *needed = ne;
 259                         }
 260
 261                 }
 262
 263         }
 264
 265         if (got)
 266                 return true;
 267
 268         return ((*needed)->obj = _rtld_load_library(name, obj, mode)) != NULL;
 269 }
 270
 271
 272 /*
 273  * Given a shared object, traverse its list of needed objects, and load
 274  * each of them.  Returns 0 on success.  Generates an error message and
 275  * returns -1 on failure.
 276  */
 277 int
 278 _rtld_load_needed_objects(Obj_Entry *first, int mode)
 279 {
 280         Obj_Entry *obj;
 281         int status = 0;
 282
 283         for (obj = first; obj != NULL; obj = obj->next) {
 284                 Needed_Entry *needed;
 285
 286                 for (needed = obj->needed; needed != NULL;
 287                     needed = needed->next) {
 288                         const char *name = obj->strtab + needed->name;
 289                         if (!_rtld_load_by_name(name, obj, &needed, mode))
 290                                 status = -1;    /* FIXME - cleanup */
 291 #ifdef RTLD_LOADER
 292                         if (status == -1)
 293                                 return status;
 294 #endif
 295                 }
 296         }
 297
 298         return status;
 299 }
 300
 301 #ifdef RTLD_LOADER
 302 int
 303 _rtld_preload(const char *preload_path)
 304 {
 305         const char *path;
 306         char *cp, *buf;
 307         int status = 0;
 308
 309         if (preload_path != NULL && *preload_path != '\0') {
 310                 cp = buf = xstrdup(preload_path);
 311                 while ((path = strsep(&cp, " :")) != NULL && status == 0) {
 312                         if (!_rtld_load_object(path, RTLD_MAIN))
 313                                 status = -1;
 314                         else
 315                                 dbg((" preloaded \"%s\"", path));
 316                 }
 317                 xfree(buf);
 318         }
 319
 320         return (status);
 321 }
 322 #endif