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