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         rd_loadobj_t rdl;
 164         rd_err_e ret;
 165         int cnt, i, lastvn;
 166
 167         DPRINTF("%s\n", __func__);
 168
 169         if ((kves = kinfo_getvmmap(proc_getpid(rdap->rda_php), &cnt)) == NULL) {
 170                 warn("ERROR: kinfo_getvmmap() failed");
 171                 return (RD_ERR);
 172         }
 173
 174         ret = RD_OK;
 175         lastvn = 0;
 176         for (i = 0; i < cnt; i++) {
 177                 kve = kves + i;
 178                 if (kve->kve_type == KVME_TYPE_VNODE)
 179                         lastvn = i;
 180                 memset(&rdl, 0, sizeof(rdl));
 181                 /*
 182                  * Map the kinfo_vmentry struct to the rd_loadobj structure.
 183                  */
 184                 rdl.rdl_saddr = kve->kve_start;
 185                 rdl.rdl_eaddr = kve->kve_end;
 186                 rdl.rdl_offset = kve->kve_offset;
 187                 if (kve->kve_protection & KVME_PROT_READ)
 188                         rdl.rdl_prot |= RD_RDL_R;
 189                 if (kve->kve_protection & KVME_PROT_WRITE)
 190                         rdl.rdl_prot |= RD_RDL_W;
 191                 if (kve->kve_protection & KVME_PROT_EXEC)
 192                         rdl.rdl_prot |= RD_RDL_X;
 193                 strlcpy(rdl.rdl_path, kves[lastvn].kve_path,
 194                     sizeof(rdl.rdl_path));
 195                 if ((*cb)(&rdl, clnt_data) != 0) {
 196                         ret = RD_ERR;
 197                         break;
 198                 }
 199         }
 200         free(kves);
 201         return (ret);
 202 }
 203
 204 void
 205 rd_log(const int onoff)
 206 {
 207         DPRINTF("%s\n", __func__);
 208
 209         (void)onoff;
 210 }
 211
 212 rd_agent_t *
 213 rd_new(struct proc_handle *php)
 214 {
 215         rd_agent_t *rdap;
 216
 217         rdap = malloc(sizeof(*rdap));
 218         if (rdap == NULL)
 219                 return (NULL);
 220
 221         memset(rdap, 0, sizeof(rd_agent_t));
 222         rdap->rda_php = php;
 223         rdap->rda_procstat = procstat_open_sysctl();
 224
 225         if (rd_reset(rdap) != RD_OK) {
 226                 rd_delete(rdap);
 227                 rdap = NULL;
 228         }
 229         return (rdap);
 230 }
 231
 232 rd_err_e
 233 rd_objpad_enable(rd_agent_t *rdap, size_t padsize)
 234 {
 235         DPRINTF("%s\n", __func__);
 236
 237         (void)rdap;
 238         (void)padsize;
 239
 240         return (RD_ERR);
 241 }
 242
 243 rd_err_e
 244 rd_plt_resolution(rd_agent_t *rdap, uintptr_t pc, struct proc *proc,
 245     uintptr_t plt_base, rd_plt_info_t *rpi)
 246 {
 247         DPRINTF("%s\n", __func__);
 248
 249         (void)rdap;
 250         (void)pc;
 251         (void)proc;
 252         (void)plt_base;
 253         (void)rpi;
 254
 255         return (RD_ERR);
 256 }
 257
 258 static int
 259 rtld_syms(rd_agent_t *rdap, const char *rtldpath, u_long base)
 260 {
 261         GElf_Shdr shdr;
 262         GElf_Sym sym;
 263         Elf *e;
 264         Elf_Data *data;
 265         Elf_Scn *scn;
 266         const char *symname;
 267         Elf64_Word strscnidx;
 268         int fd, i, ret;
 269
 270         ret = 1;
 271         e = NULL;
 272
 273         fd = open(rtldpath, O_RDONLY);
 274         if (fd < 0)
 275                 goto err;
 276
 277         if (elf_version(EV_CURRENT) == EV_NONE)
 278                 goto err;
 279         e = elf_begin(fd, ELF_C_READ, NULL);
 280         if (e == NULL)
 281                 goto err;
 282
 283         scn = NULL;
 284         while ((scn = elf_nextscn(e, scn)) != NULL) {
 285                 gelf_getshdr(scn, &shdr);
 286                 if (shdr.sh_type == SHT_DYNSYM)
 287                         break;
 288         }
 289         if (scn == NULL)
 290                 goto err;
 291
 292         strscnidx = shdr.sh_link;
 293         data = elf_getdata(scn, NULL);
 294         if (data == NULL)
 295                 goto err;
 296
 297         for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) {
 298                 if (GELF_ST_TYPE(sym.st_info) != STT_FUNC ||
 299                     GELF_ST_BIND(sym.st_info) != STB_GLOBAL)
 300                         continue;
 301                 symname = elf_strptr(e, strscnidx, sym.st_name);
 302                 if (symname == NULL)
 303                         continue;
 304
 305                 if (strcmp(symname, "r_debug_state") == 0) {
 306                         rdap->rda_preinit_addr = sym.st_value + base;
 307                         rdap->rda_dlactivity_addr = sym.st_value + base;
 308                 } else if (strcmp(symname, "_r_debug_postinit") == 0) {
 309                         rdap->rda_postinit_addr = sym.st_value + base;
 310                 }
 311         }
 312
 313         if (rdap->rda_preinit_addr != 0 &&
 314             rdap->rda_postinit_addr != 0 &&
 315             rdap->rda_dlactivity_addr != 0)
 316                 ret = 0;
 317
 318 err:
 319         if (e != NULL)
 320                 (void)elf_end(e);
 321         if (fd >= 0)
 322                 (void)close(fd);
 323         return (ret);
 324 }
 325
 326 rd_err_e
 327 rd_reset(rd_agent_t *rdap)
 328 {
 329         struct kinfo_proc *kp;
 330         struct kinfo_vmentry *kve;
 331         Elf_Auxinfo *auxv;
 332         const char *rtldpath;
 333         u_long base;
 334         rd_err_e rderr;
 335         int count, i;
 336
 337         kp = NULL;
 338         auxv = NULL;
 339         kve = NULL;
 340         rderr = RD_ERR;
 341
 342         kp = procstat_getprocs(rdap->rda_procstat, KERN_PROC_PID,
 343             proc_getpid(rdap->rda_php), &count);
 344         if (kp == NULL)
 345                 return (RD_ERR);
 346         assert(count == 1);
 347
 348         auxv = procstat_getauxv(rdap->rda_procstat, kp, &count);
 349         if (auxv == NULL)
 350                 goto err;
 351
 352         base = 0;
 353         for (i = 0; i < count; i++) {
 354                 if (auxv[i].a_type == AT_BASE) {
 355                         base = auxv[i].a_un.a_val;
 356                         break;
 357                 }
 358         }
 359         if (i == count)
 360                 goto err;
 361
 362         rtldpath = NULL;
 363         kve = procstat_getvmmap(rdap->rda_procstat, kp, &count);
 364         if (kve == NULL)
 365                 goto err;
 366         for (i = 0; i < count; i++) {
 367                 if (kve[i].kve_start == base) {
 368                         rtldpath = kve[i].kve_path;
 369                         break;
 370                 }
 371         }
 372         if (i == count)
 373                 goto err;
 374
 375         if (rtld_syms(rdap, rtldpath, base) != 0)
 376                 goto err;
 377
 378         rderr = RD_OK;
 379
 380 err:
 381         if (kve != NULL)
 382                 procstat_freevmmap(rdap->rda_procstat, kve);
 383         if (auxv != NULL)
 384                 procstat_freeauxv(rdap->rda_procstat, auxv);
 385         if (kp != NULL)
 386                 procstat_freeprocs(rdap->rda_procstat, kp);
 387         return (rderr);
 388 }