lib/librtld_db/rtld_db.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2010 The FreeBSD Foundation
   5  * All rights reserved.
   6  *
   7  * This software was developed by Rui Paulo under sponsorship from the
   8  * FreeBSD Foundation.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/sysctl.h>
  37 #include <sys/user.h>
  38
  39 #include <assert.h>
  40 #include <err.h>
  41 #include <fcntl.h>
  42 #include <limits.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47
  48 #include <machine/elf.h>
  49
  50 #include <libelf.h>
  51 #include <libproc.h>
  52 #include <libprocstat.h>
  53 #include <libutil.h>
  54
  55 #include "rtld_db.h"
  56
  57 static int _librtld_db_debug = 0;
  58 #define DPRINTF(...) do {                               \
  59         if (_librtld_db_debug) {                        \
  60                 fprintf(stderr, "librtld_db: DEBUG: "); \
  61                 fprintf(stderr, __VA_ARGS__);           \
  62         }                                               \
  63 } while (0)
  64
  65 void
  66 rd_delete(rd_agent_t *rdap)
  67 {
  68
  69         if (rdap->rda_procstat != NULL)
  70                 procstat_close(rdap->rda_procstat);
  71         free(rdap);
  72 }
  73
  74 const char *
  75 rd_errstr(rd_err_e rderr)
  76 {
  77
  78         switch (rderr) {
  79         case RD_ERR:
  80                 return "generic error";
  81         case RD_OK:
  82                 return "no error";
  83         case RD_NOCAPAB:
  84                 return "capability not supported";
  85         case RD_DBERR:
  86                 return "database error";
  87         case RD_NOBASE:
  88                 return "NOBASE";
  89         case RD_NOMAPS:
  90                 return "NOMAPS";
  91         default:
  92                 return "unknown error";
  93         }
  94 }
  95
  96 rd_err_e
  97 rd_event_addr(rd_agent_t *rdap, rd_event_e event, rd_notify_t *notify)
  98 {
  99         rd_err_e ret;
 100
 101         DPRINTF("%s rdap %p event %d notify %p\n", __func__, rdap, event,
 102             notify);
 103
 104         ret = RD_OK;
 105         switch (event) {
 106         case RD_NONE:
 107                 break;
 108         case RD_PREINIT:
 109                 notify->type = RD_NOTIFY_BPT;
 110                 notify->u.bptaddr = rdap->rda_preinit_addr;
 111                 break;
 112         case RD_POSTINIT:
 113                 notify->type = RD_NOTIFY_BPT;
 114                 notify->u.bptaddr = rdap->rda_postinit_addr;
 115                 break;
 116         case RD_DLACTIVITY:
 117                 notify->type = RD_NOTIFY_BPT;
 118                 notify->u.bptaddr = rdap->rda_dlactivity_addr;
 119                 break;
 120         default:
 121                 ret = RD_ERR;
 122                 break;
 123         }
 124         return (ret);
 125 }
 126
 127 rd_err_e
 128 rd_event_enable(rd_agent_t *rdap __unused, int onoff)
 129 {
 130         DPRINTF("%s onoff %d\n", __func__, onoff);
 131
 132         return (RD_OK);
 133 }
 134
 135 rd_err_e
 136 rd_event_getmsg(rd_agent_t *rdap __unused, rd_event_msg_t *msg)
 137 {
 138         DPRINTF("%s\n", __func__);
 139
 140         msg->type = RD_POSTINIT;
 141         msg->u.state = RD_CONSISTENT;
 142
 143         return (RD_OK);
 144 }
 145
 146 rd_err_e
 147 rd_init(int version)
 148 {
 149         char *debug = NULL;
 150
 151         if (version == RD_VERSION) {
 152                 debug = getenv("LIBRTLD_DB_DEBUG");
 153                 _librtld_db_debug = debug ? atoi(debug) : 0;
 154                 return (RD_OK);
 155         } else
 156                 return (RD_NOCAPAB);
 157 }
 158
 159 rd_err_e
 160 rd_loadobj_iter(rd_agent_t *rdap, rl_iter_f *cb, void *clnt_data)
 161 {
 162         struct kinfo_vmentry *kves, *kve;
 163         const char *path;
 164         uint64_t fileid;
 165         rd_loadobj_t rdl;
 166         rd_err_e ret;
 167         uintptr_t base;
 168         int cnt, i;
 169
 170         DPRINTF("%s\n", __func__);
 171
 172         if ((kves = kinfo_getvmmap(proc_getpid(rdap->rda_php), &cnt)) == NULL) {
 173                 warn("ERROR: kinfo_getvmmap() failed");
 174                 return (RD_ERR);
 175         }
 176
 177         base = 0;
 178         fileid = 0;
 179         path = NULL;
 180         ret = RD_OK;
 181         for (i = 0; i < cnt; i++) {
 182                 kve = &kves[i];
 183                 /*
 184                  * Cache the base offset of the file mapping.  The kve_offset
 185                  * field gives the file offset of a particular mapping into the
 186                  * file, but we want the mapping offset relative to the base
 187                  * mapping.
 188                  */
 189                 if (kve->kve_type == KVME_TYPE_VNODE &&
 190                     kve->kve_vn_fileid != fileid) {
 191                         base = kve->kve_start;
 192                         fileid = kve->kve_vn_fileid;
 193                         path = kve->kve_path;
 194                 }
 195                 memset(&rdl, 0, sizeof(rdl));
 196                 /*
 197                  * Map the kinfo_vmentry struct to the rd_loadobj structure.
 198                  */
 199                 rdl.rdl_saddr = kve->kve_start;
 200                 rdl.rdl_eaddr = kve->kve_end;
 201                 rdl.rdl_offset = kve->kve_start - base;
 202                 if (kve->kve_protection & KVME_PROT_READ)
 203                         rdl.rdl_prot |= RD_RDL_R;
 204                 if (kve->kve_protection & KVME_PROT_WRITE)
 205                         rdl.rdl_prot |= RD_RDL_W;
 206                 if (kve->kve_protection & KVME_PROT_EXEC)
 207                         rdl.rdl_prot |= RD_RDL_X;
 208                 strlcpy(rdl.rdl_path, path, sizeof(rdl.rdl_path));
 209                 if ((*cb)(&rdl, clnt_data) != 0) {
 210                         ret = RD_ERR;
 211                         break;
 212                 }
 213         }
 214         free(kves);
 215         return (ret);
 216 }
 217
 218 void
 219 rd_log(const int onoff)
 220 {
 221         DPRINTF("%s\n", __func__);
 222
 223         (void)onoff;
 224 }
 225
 226 rd_agent_t *
 227 rd_new(struct proc_handle *php)
 228 {
 229         rd_agent_t *rdap;
 230
 231         rdap = malloc(sizeof(*rdap));
 232         if (rdap == NULL)
 233                 return (NULL);
 234
 235         memset(rdap, 0, sizeof(rd_agent_t));
 236         rdap->rda_php = php;
 237         rdap->rda_procstat = procstat_open_sysctl();
 238
 239         if (rd_reset(rdap) != RD_OK) {
 240                 rd_delete(rdap);
 241                 rdap = NULL;
 242         }
 243         return (rdap);
 244 }
 245
 246 rd_err_e
 247 rd_objpad_enable(rd_agent_t *rdap, size_t padsize)
 248 {
 249         DPRINTF("%s\n", __func__);
 250
 251         (void)rdap;
 252         (void)padsize;
 253
 254         return (RD_ERR);
 255 }
 256
 257 rd_err_e
 258 rd_plt_resolution(rd_agent_t *rdap, uintptr_t pc, struct proc *proc,
 259     uintptr_t plt_base, rd_plt_info_t *rpi)
 260 {
 261         DPRINTF("%s\n", __func__);
 262
 263         (void)rdap;
 264         (void)pc;
 265         (void)proc;
 266         (void)plt_base;
 267         (void)rpi;
 268
 269         return (RD_ERR);
 270 }
 271
 272 static int
 273 rtld_syms(rd_agent_t *rdap, const char *rtldpath, u_long base)
 274 {
 275         GElf_Shdr shdr;
 276         GElf_Sym sym;
 277         Elf *e;
 278         Elf_Data *data;
 279         Elf_Scn *scn;
 280         const char *symname;
 281         Elf64_Word strscnidx;
 282         int fd, i, ret;
 283
 284         ret = 1;
 285         e = NULL;
 286
 287         fd = open(rtldpath, O_RDONLY);
 288         if (fd < 0)
 289                 goto err;
 290
 291         if (elf_version(EV_CURRENT) == EV_NONE)
 292                 goto err;
 293         e = elf_begin(fd, ELF_C_READ, NULL);
 294         if (e == NULL)
 295                 goto err;
 296
 297         scn = NULL;
 298         while ((scn = elf_nextscn(e, scn)) != NULL) {
 299                 gelf_getshdr(scn, &shdr);
 300                 if (shdr.sh_type == SHT_DYNSYM)
 301                         break;
 302         }
 303         if (scn == NULL)
 304                 goto err;
 305
 306         strscnidx = shdr.sh_link;
 307         data = elf_getdata(scn, NULL);
 308         if (data == NULL)
 309                 goto err;
 310
 311         for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) {
 312                 if (GELF_ST_TYPE(sym.st_info) != STT_FUNC ||
 313                     GELF_ST_BIND(sym.st_info) != STB_GLOBAL)
 314                         continue;
 315                 symname = elf_strptr(e, strscnidx, sym.st_name);
 316                 if (symname == NULL)
 317                         continue;
 318
 319                 if (strcmp(symname, "r_debug_state") == 0) {
 320                         rdap->rda_preinit_addr = sym.st_value + base;
 321                         rdap->rda_dlactivity_addr = sym.st_value + base;
 322                 } else if (strcmp(symname, "_r_debug_postinit") == 0) {
 323                         rdap->rda_postinit_addr = sym.st_value + base;
 324                 }
 325         }
 326
 327         if (rdap->rda_preinit_addr != 0 &&
 328             rdap->rda_postinit_addr != 0 &&
 329             rdap->rda_dlactivity_addr != 0)
 330                 ret = 0;
 331
 332 err:
 333         if (e != NULL)
 334                 (void)elf_end(e);
 335         if (fd >= 0)
 336                 (void)close(fd);
 337         return (ret);
 338 }
 339
 340 rd_err_e
 341 rd_reset(rd_agent_t *rdap)
 342 {
 343         struct kinfo_proc *kp;
 344         struct kinfo_vmentry *kve;
 345         Elf_Auxinfo *auxv;
 346         const char *rtldpath;
 347         u_long base;
 348         rd_err_e rderr;
 349         int count, i;
 350
 351         kp = NULL;
 352         auxv = NULL;
 353         kve = NULL;
 354         rderr = RD_ERR;
 355
 356         kp = procstat_getprocs(rdap->rda_procstat, KERN_PROC_PID,
 357             proc_getpid(rdap->rda_php), &count);
 358         if (kp == NULL)
 359                 return (RD_ERR);
 360         assert(count == 1);
 361
 362         auxv = procstat_getauxv(rdap->rda_procstat, kp, &count);
 363         if (auxv == NULL)
 364                 goto err;
 365
 366         base = 0;
 367         for (i = 0; i < count; i++) {
 368                 if (auxv[i].a_type == AT_BASE) {
 369                         base = auxv[i].a_un.a_val;
 370                         break;
 371                 }
 372         }
 373         if (i == count)
 374                 goto err;
 375
 376         rtldpath = NULL;
 377         kve = procstat_getvmmap(rdap->rda_procstat, kp, &count);
 378         if (kve == NULL)
 379                 goto err;
 380         for (i = 0; i < count; i++) {
 381                 if (kve[i].kve_start == base) {
 382                         rtldpath = kve[i].kve_path;
 383                         break;
 384                 }
 385         }
 386         if (i == count)
 387                 goto err;
 388
 389         if (rtld_syms(rdap, rtldpath, base) != 0)
 390                 goto err;
 391
 392         rderr = RD_OK;
 393
 394 err:
 395         if (kve != NULL)
 396                 procstat_freevmmap(rdap->rda_procstat, kve);
 397         if (auxv != NULL)
 398                 procstat_freeauxv(rdap->rda_procstat, auxv);
 399         if (kp != NULL)
 400                 procstat_freeprocs(rdap->rda_procstat, kp);
 401         return (rderr);
 402 }