proc_sym.c revision 259895 
1/*-
2 * Copyright (c) 2010 The FreeBSD Foundation
3 * Copyright (c) 2008 John Birrell (jb@freebsd.org)
4 * All rights reserved.
5 *
6 * Portions of this software were developed by Rui Paulo under sponsorship
7 * from the FreeBSD Foundation.
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 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 *
30 * $FreeBSD: stable/10/lib/libproc/proc_sym.c 259895 2013-12-25 22:36:27Z markj $
31 */
32
33#include <sys/types.h>
34#include <sys/user.h>
35
36#include <assert.h>
37#include <err.h>
38#include <stdio.h>
39#include <libgen.h>
40#include <string.h>
41#include <stdlib.h>
42#include <fcntl.h>
43#include <string.h>
44#include <unistd.h>
45#include <libutil.h>
46
47#include "_libproc.h"
48
49extern char *__cxa_demangle(const char *, char *, size_t *, int *);
50
51static void	proc_rdl2prmap(rd_loadobj_t *, prmap_t *);
52
53static void
54demangle(const char *symbol, char *buf, size_t len)
55{
56	char *dembuf;
57	size_t demlen = len;
58
59	dembuf = malloc(len);
60	if (!dembuf)
61		goto fail;
62	dembuf = __cxa_demangle(symbol, dembuf, &demlen, NULL);
63	if (!dembuf)
64		goto fail;
65	strlcpy(buf, dembuf, len);
66	free(dembuf);
67
68	return;
69fail:
70	strlcpy(buf, symbol, len);
71}
72
73static void
74proc_rdl2prmap(rd_loadobj_t *rdl, prmap_t *map)
75{
76	map->pr_vaddr = rdl->rdl_saddr;
77	map->pr_size = rdl->rdl_eaddr - rdl->rdl_saddr;
78	map->pr_offset = rdl->rdl_offset;
79	map->pr_mflags = 0;
80	if (rdl->rdl_prot & RD_RDL_R)
81		map->pr_mflags |= MA_READ;
82	if (rdl->rdl_prot & RD_RDL_W)
83		map->pr_mflags |= MA_WRITE;
84	if (rdl->rdl_prot & RD_RDL_X)
85		map->pr_mflags |= MA_EXEC;
86	strlcpy(map->pr_mapname, rdl->rdl_path,
87	    sizeof(map->pr_mapname));
88}
89
90char *
91proc_objname(struct proc_handle *p, uintptr_t addr, char *objname,
92    size_t objnamesz)
93{
94	size_t i;
95	rd_loadobj_t *rdl;
96
97	for (i = 0; i < p->nobjs; i++) {
98		rdl = &p->rdobjs[i];
99		if (addr >= rdl->rdl_saddr && addr <= rdl->rdl_eaddr) {
100			strlcpy(objname, rdl->rdl_path, objnamesz);
101			return (objname);
102		}
103	}
104	return (NULL);
105}
106
107prmap_t *
108proc_obj2map(struct proc_handle *p, const char *objname)
109{
110	size_t i;
111	prmap_t *map;
112	rd_loadobj_t *rdl;
113	char path[MAXPATHLEN];
114
115	for (i = 0; i < p->nobjs; i++) {
116		rdl = &p->rdobjs[i];
117		basename_r(rdl->rdl_path, path);
118		if (strcmp(path, objname) == 0) {
119			if ((map = malloc(sizeof(*map))) == NULL)
120				return (NULL);
121			proc_rdl2prmap(rdl, map);
122			return (map);
123		}
124	}
125	return (NULL);
126}
127
128int
129proc_iter_objs(struct proc_handle *p, proc_map_f *func, void *cd)
130{
131	size_t i;
132	rd_loadobj_t *rdl;
133	prmap_t map;
134	char path[MAXPATHLEN];
135	char last[MAXPATHLEN];
136
137	if (p->nobjs == 0)
138		return (-1);
139	memset(last, 0, sizeof(last));
140	for (i = 0; i < p->nobjs; i++) {
141		rdl = &p->rdobjs[i];
142		proc_rdl2prmap(rdl, &map);
143		basename_r(rdl->rdl_path, path);
144		/*
145		 * We shouldn't call the callback twice with the same object.
146		 * To do that we are assuming the fact that if there are
147		 * repeated object names (i.e. different mappings for the
148		 * same object) they occur next to each other.
149		 */
150		if (strcmp(path, last) == 0)
151			continue;
152		(*func)(cd, &map, path);
153		strlcpy(last, path, sizeof(last));
154	}
155
156	return (0);
157}
158
159prmap_t *
160proc_addr2map(struct proc_handle *p, uintptr_t addr)
161{
162	size_t i;
163	int cnt, lastvn = 0;
164	prmap_t *map;
165	rd_loadobj_t *rdl;
166	struct kinfo_vmentry *kves, *kve;
167
168	/*
169	 * If we don't have a cache of listed objects, we need to query
170	 * it ourselves.
171	 */
172	if (p->nobjs == 0) {
173		if ((kves = kinfo_getvmmap(p->pid, &cnt)) == NULL)
174			return (NULL);
175		for (i = 0; i < (size_t)cnt; i++) {
176			kve = kves + i;
177			if (kve->kve_type == KVME_TYPE_VNODE)
178				lastvn = i;
179			if (addr >= kve->kve_start && addr <= kve->kve_end) {
180				if ((map = malloc(sizeof(*map))) == NULL) {
181					free(kves);
182					return (NULL);
183				}
184				map->pr_vaddr = kve->kve_start;
185				map->pr_size = kve->kve_end - kve->kve_start;
186				map->pr_offset = kve->kve_offset;
187				map->pr_mflags = 0;
188				if (kve->kve_protection & KVME_PROT_READ)
189					map->pr_mflags |= MA_READ;
190				if (kve->kve_protection & KVME_PROT_WRITE)
191					map->pr_mflags |= MA_WRITE;
192				if (kve->kve_protection & KVME_PROT_EXEC)
193					map->pr_mflags |= MA_EXEC;
194				if (kve->kve_flags & KVME_FLAG_COW)
195					map->pr_mflags |= MA_COW;
196				if (kve->kve_flags & KVME_FLAG_NEEDS_COPY)
197					map->pr_mflags |= MA_NEEDS_COPY;
198				if (kve->kve_flags & KVME_FLAG_NOCOREDUMP)
199					map->pr_mflags |= MA_NOCOREDUMP;
200				strlcpy(map->pr_mapname, kves[lastvn].kve_path,
201				    sizeof(map->pr_mapname));
202				free(kves);
203				return (map);
204			}
205		}
206		free(kves);
207		return (NULL);
208	}
209
210	for (i = 0; i < p->nobjs; i++) {
211		rdl = &p->rdobjs[i];
212		if (addr >= rdl->rdl_saddr && addr <= rdl->rdl_eaddr) {
213			if ((map = malloc(sizeof(*map))) == NULL)
214				return (NULL);
215			proc_rdl2prmap(rdl, map);
216			return (map);
217		}
218	}
219	return (NULL);
220}
221
222int
223proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name,
224    size_t namesz, GElf_Sym *symcopy)
225{
226	Elf *e;
227	Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL;
228	Elf_Data *data;
229	GElf_Shdr shdr;
230	GElf_Sym sym;
231	GElf_Ehdr ehdr;
232	int fd, error = -1;
233	size_t i;
234	uint64_t rsym;
235	prmap_t *map;
236	char *s;
237	unsigned long symtabstridx = 0, dynsymstridx = 0;
238
239	if ((map = proc_addr2map(p, addr)) == NULL)
240		return (-1);
241	if ((fd = open(map->pr_mapname, O_RDONLY, 0)) < 0) {
242		DPRINTF("ERROR: open %s failed", map->pr_mapname);
243		goto err0;
244	}
245	if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
246		DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
247		goto err1;
248	}
249	if (gelf_getehdr(e, &ehdr) == NULL) {
250		DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
251		goto err2;
252	}
253	/*
254	 * Find the index of the STRTAB and SYMTAB sections to locate
255	 * symbol names.
256	 */
257	scn = NULL;
258	while ((scn = elf_nextscn(e, scn)) != NULL) {
259		gelf_getshdr(scn, &shdr);
260		switch (shdr.sh_type) {
261		case SHT_SYMTAB:
262			symtabscn = scn;
263			symtabstridx = shdr.sh_link;
264			break;
265		case SHT_DYNSYM:
266			dynsymscn = scn;
267			dynsymstridx = shdr.sh_link;
268			break;
269		default:
270			break;
271		}
272	}
273	/*
274	 * Iterate over the Dynamic Symbols table to find the symbol.
275	 * Then look up the string name in STRTAB (.dynstr)
276	 */
277	if ((data = elf_getdata(dynsymscn, NULL)) == NULL) {
278		DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1));
279		goto symtab;
280	}
281	i = 0;
282	while (gelf_getsym(data, i++, &sym) != NULL) {
283		/*
284		 * Calculate the address mapped to the virtual memory
285		 * by rtld.
286		 */
287		rsym = map->pr_vaddr + sym.st_value;
288		if (addr >= rsym && addr <= (rsym + sym.st_size)) {
289			s = elf_strptr(e, dynsymstridx, sym.st_name);
290			if (s) {
291				if (s[0] == '_' && s[1] == 'Z' && s[2])
292					demangle(s, name, namesz);
293				else
294					strlcpy(name, s, namesz);
295				memcpy(symcopy, &sym, sizeof(sym));
296				/*
297				 * DTrace expects the st_value to contain
298				 * only the address relative to the start of
299				 * the function.
300				 */
301				symcopy->st_value = rsym;
302				error = 0;
303				goto out;
304			}
305		}
306	}
307symtab:
308	/*
309	 * Iterate over the Symbols Table to find the symbol.
310	 * Then look up the string name in STRTAB (.dynstr)
311	 */
312	if (symtabscn == NULL)
313		goto err2;
314	if ((data = elf_getdata(symtabscn, NULL)) == NULL) {
315		DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1));
316		goto err2;
317	}
318	i = 0;
319	while (gelf_getsym(data, i++, &sym) != NULL) {
320		/*
321		 * Calculate the address mapped to the virtual memory
322		 * by rtld.
323		 */
324		if (ehdr.e_type != ET_EXEC)
325			rsym = map->pr_vaddr + sym.st_value;
326		else
327			rsym = sym.st_value;
328		if (addr >= rsym && addr <= (rsym + sym.st_size)) {
329			s = elf_strptr(e, symtabstridx, sym.st_name);
330			if (s) {
331				if (s[0] == '_' && s[1] == 'Z' && s[2])
332					demangle(s, name, namesz);
333				else
334					strlcpy(name, s, namesz);
335				memcpy(symcopy, &sym, sizeof(sym));
336				/*
337				 * DTrace expects the st_value to contain
338				 * only the address relative to the start of
339				 * the function.
340				 */
341				symcopy->st_value = rsym;
342				error = 0;
343				goto out;
344			}
345		}
346	}
347out:
348err2:
349	elf_end(e);
350err1:
351	close(fd);
352err0:
353	free(map);
354	return (error);
355}
356
357prmap_t *
358proc_name2map(struct proc_handle *p, const char *name)
359{
360	size_t i;
361	int cnt;
362	prmap_t *map;
363	char tmppath[MAXPATHLEN];
364	struct kinfo_vmentry *kves, *kve;
365	rd_loadobj_t *rdl;
366
367	/*
368	 * If we haven't iterated over the list of loaded objects,
369	 * librtld_db isn't yet initialized and it's very likely
370	 * that librtld_db called us. We need to do the heavy
371	 * lifting here to find the symbol librtld_db is looking for.
372	 */
373	if (p->nobjs == 0) {
374		if ((kves = kinfo_getvmmap(proc_getpid(p), &cnt)) == NULL)
375			return (NULL);
376		for (i = 0; i < (size_t)cnt; i++) {
377			kve = kves + i;
378			basename_r(kve->kve_path, tmppath);
379			if (strcmp(tmppath, name) == 0) {
380				map = proc_addr2map(p, kve->kve_start);
381				free(kves);
382				return (map);
383			}
384		}
385		free(kves);
386		return (NULL);
387	}
388	if (name == NULL || strcmp(name, "a.out") == 0) {
389		map = proc_addr2map(p, p->rdobjs[0].rdl_saddr);
390		return (map);
391	}
392	for (i = 0; i < p->nobjs; i++) {
393		rdl = &p->rdobjs[i];
394		basename_r(rdl->rdl_path, tmppath);
395		if (strcmp(tmppath, name) == 0) {
396			if ((map = malloc(sizeof(*map))) == NULL)
397				return (NULL);
398			proc_rdl2prmap(rdl, map);
399			return (map);
400		}
401	}
402
403	return (NULL);
404}
405
406int
407proc_name2sym(struct proc_handle *p, const char *object, const char *symbol,
408    GElf_Sym *symcopy)
409{
410	Elf *e;
411	Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL;
412	Elf_Data *data;
413	GElf_Shdr shdr;
414	GElf_Sym sym;
415	GElf_Ehdr ehdr;
416	int fd, error = -1;
417	size_t i;
418	prmap_t *map;
419	char *s;
420	unsigned long symtabstridx = 0, dynsymstridx = 0;
421
422	if ((map = proc_name2map(p, object)) == NULL) {
423		DPRINTFX("ERROR: couldn't find object %s", object);
424		goto err0;
425	}
426	if ((fd = open(map->pr_mapname, O_RDONLY, 0)) < 0) {
427		DPRINTF("ERROR: open %s failed", map->pr_mapname);
428		goto err0;
429	}
430	if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
431		DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
432		goto err1;
433	}
434	if (gelf_getehdr(e, &ehdr) == NULL) {
435		DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
436		goto err2;
437	}
438	/*
439	 * Find the index of the STRTAB and SYMTAB sections to locate
440	 * symbol names.
441	 */
442	scn = NULL;
443	while ((scn = elf_nextscn(e, scn)) != NULL) {
444		gelf_getshdr(scn, &shdr);
445		switch (shdr.sh_type) {
446		case SHT_SYMTAB:
447			symtabscn = scn;
448			symtabstridx = shdr.sh_link;
449			break;
450		case SHT_DYNSYM:
451			dynsymscn = scn;
452			dynsymstridx = shdr.sh_link;
453			break;
454		default:
455			break;
456		}
457	}
458	/*
459	 * Iterate over the Dynamic Symbols table to find the symbol.
460	 * Then look up the string name in STRTAB (.dynstr)
461	 */
462	if ((data = elf_getdata(dynsymscn, NULL))) {
463		i = 0;
464		while (gelf_getsym(data, i++, &sym) != NULL) {
465			s = elf_strptr(e, dynsymstridx, sym.st_name);
466			if (s && strcmp(s, symbol) == 0) {
467				memcpy(symcopy, &sym, sizeof(sym));
468				symcopy->st_value = map->pr_vaddr + sym.st_value;
469				error = 0;
470				goto out;
471			}
472		}
473	}
474	/*
475	 * Iterate over the Symbols Table to find the symbol.
476	 * Then look up the string name in STRTAB (.dynstr)
477	 */
478	if (symtabscn == NULL)
479		goto err2;
480	if ((data = elf_getdata(symtabscn, NULL))) {
481		i = 0;
482		while (gelf_getsym(data, i++, &sym) != NULL) {
483			s = elf_strptr(e, symtabstridx, sym.st_name);
484			if (s && strcmp(s, symbol) == 0) {
485				memcpy(symcopy, &sym, sizeof(sym));
486				error = 0;
487				goto out;
488			}
489		}
490	}
491out:
492err2:
493	elf_end(e);
494err1:
495	close(fd);
496err0:
497	free(map);
498
499	return (error);
500}
501
502
503int
504proc_iter_symbyaddr(struct proc_handle *p, const char *object, int which,
505    int mask, proc_sym_f *func, void *cd)
506{
507	Elf *e;
508	int i, fd;
509	prmap_t *map;
510	Elf_Scn *scn, *foundscn = NULL;
511	Elf_Data *data;
512	GElf_Shdr shdr;
513	GElf_Sym sym;
514	unsigned long stridx = -1;
515	char *s;
516	int error = -1;
517
518	if ((map = proc_name2map(p, object)) == NULL)
519		return (-1);
520	if ((fd = open(map->pr_mapname, O_RDONLY)) < 0) {
521		DPRINTF("ERROR: open %s failed", map->pr_mapname);
522		goto err0;
523	}
524	if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
525		DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
526		goto err1;
527	}
528	/*
529	 * Find the section we are looking for.
530	 */
531	scn = NULL;
532	while ((scn = elf_nextscn(e, scn)) != NULL) {
533		gelf_getshdr(scn, &shdr);
534		if (which == PR_SYMTAB &&
535		    shdr.sh_type == SHT_SYMTAB) {
536			foundscn = scn;
537			break;
538		} else if (which == PR_DYNSYM &&
539		    shdr.sh_type == SHT_DYNSYM) {
540			foundscn = scn;
541			break;
542		}
543	}
544	if (!foundscn)
545		return (-1);
546	stridx = shdr.sh_link;
547	if ((data = elf_getdata(foundscn, NULL)) == NULL) {
548		DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1));
549		goto err2;
550	}
551	i = 0;
552	while (gelf_getsym(data, i++, &sym) != NULL) {
553		if (GELF_ST_BIND(sym.st_info) == STB_LOCAL &&
554		    (mask & BIND_LOCAL) == 0)
555			continue;
556		if (GELF_ST_BIND(sym.st_info) == STB_GLOBAL &&
557		    (mask & BIND_GLOBAL) == 0)
558			continue;
559		if (GELF_ST_BIND(sym.st_info) == STB_WEAK &&
560		    (mask & BIND_WEAK) == 0)
561			continue;
562		if (GELF_ST_TYPE(sym.st_info) == STT_NOTYPE &&
563		    (mask & TYPE_NOTYPE) == 0)
564			continue;
565		if (GELF_ST_TYPE(sym.st_info) == STT_OBJECT &&
566		    (mask & TYPE_OBJECT) == 0)
567			continue;
568		if (GELF_ST_TYPE(sym.st_info) == STT_FUNC &&
569		    (mask & TYPE_FUNC) == 0)
570			continue;
571		if (GELF_ST_TYPE(sym.st_info) == STT_SECTION &&
572		    (mask & TYPE_SECTION) == 0)
573			continue;
574		if (GELF_ST_TYPE(sym.st_info) == STT_FILE &&
575		    (mask & TYPE_FILE) == 0)
576			continue;
577		s = elf_strptr(e, stridx, sym.st_name);
578		sym.st_value += map->pr_vaddr;
579		(*func)(cd, &sym, s);
580	}
581	error = 0;
582err2:
583	elf_end(e);
584err1:
585	close(fd);
586err0:
587	free(map);
588	return (error);
589}
590