xref: /illumos-gate/usr/src/common/ctf/ctf_lookup.c (revision d15d17d4)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 
23 /*
24  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 /*
29  * Copyright 2019, Joyent, Inc.
30  */
31 
32 #include <sys/sysmacros.h>
33 #include <ctf_impl.h>
34 
35 /*
36  * Compare the given input string and length against a table of known C storage
37  * qualifier keywords.  We just ignore these in ctf_lookup_by_name, below.  To
38  * do this quickly, we use a pre-computed Perfect Hash Function similar to the
39  * technique originally described in the classic paper:
40  *
41  * R.J. Cichelli, "Minimal Perfect Hash Functions Made Simple",
42  * Communications of the ACM, Volume 23, Issue 1, January 1980, pp. 17-19.
43  *
44  * For an input string S of length N, we use hash H = S[N - 1] + N - 105, which
45  * for the current set of qualifiers yields a unique H in the range [0 .. 20].
46  * The hash can be modified when the keyword set changes as necessary.  We also
47  * store the length of each keyword and check it prior to the final strcmp().
48  */
49 static int
isqualifier(const char * s,size_t len)50 isqualifier(const char *s, size_t len)
51 {
52 	static const struct qual {
53 		const char *q_name;
54 		size_t q_len;
55 	} qhash[] = {
56 		{ "static", 6 }, { "", 0 }, { "", 0 }, { "", 0 },
57 		{ "volatile", 8 }, { "", 0 }, { "", 0 }, { "", 0 }, { "", 0 },
58 		{ "", 0 }, { "auto", 4 }, { "extern", 6 }, { "", 0 }, { "", 0 },
59 		{ "", 0 }, { "", 0 }, { "const", 5 }, { "register", 8 },
60 		{ "", 0 }, { "restrict", 8 }, { "_Restrict", 9 }
61 	};
62 
63 	int h = s[len - 1] + (int)len - 105;
64 	const struct qual *qp = &qhash[h];
65 
66 	return (h >= 0 && h < sizeof (qhash) / sizeof (qhash[0]) &&
67 	    len == qp->q_len && strncmp(qp->q_name, s, qp->q_len) == 0);
68 }
69 
70 /*
71  * Attempt to convert the given C type name into the corresponding CTF type ID.
72  * It is not possible to do complete and proper conversion of type names
73  * without implementing a more full-fledged parser, which is necessary to
74  * handle things like types that are function pointers to functions that
75  * have arguments that are function pointers, and fun stuff like that.
76  * Instead, this function implements a very simple conversion algorithm that
77  * finds the things that we actually care about: structs, unions, enums,
78  * integers, floats, typedefs, and pointers to any of these named types.
79  */
80 ctf_id_t
ctf_lookup_by_name(ctf_file_t * fp,const char * name)81 ctf_lookup_by_name(ctf_file_t *fp, const char *name)
82 {
83 	static const char delimiters[] = " \t\n\r\v\f*";
84 
85 	const ctf_lookup_t *lp;
86 	const ctf_helem_t *hp;
87 	const char *p, *q, *end;
88 	ctf_id_t type = 0;
89 	ctf_id_t ntype, ptype;
90 
91 	if (name == NULL)
92 		return (ctf_set_errno(fp, EINVAL));
93 
94 	for (p = name, end = name + strlen(name); *p != '\0'; p = q) {
95 		while (isspace(*p))
96 			p++; /* skip leading ws */
97 
98 		if (p == end)
99 			break;
100 
101 		if ((q = strpbrk(p + 1, delimiters)) == NULL)
102 			q = end; /* compare until end */
103 
104 		if (*p == '*') {
105 			/*
106 			 * Find a pointer to type by looking in fp->ctf_ptrtab.
107 			 * If we can't find a pointer to the given type, see if
108 			 * we can compute a pointer to the type resulting from
109 			 * resolving the type down to its base type and use
110 			 * that instead.  This helps with cases where the CTF
111 			 * data includes "struct foo *" but not "foo_t *" and
112 			 * the user tries to access "foo_t *" in the debugger.
113 			 */
114 			ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)];
115 			if (ntype == 0) {
116 				ntype = ctf_type_resolve(fp, type);
117 				if (ntype == CTF_ERR || (ntype = fp->ctf_ptrtab[
118 				    CTF_TYPE_TO_INDEX(ntype)]) == 0) {
119 					(void) ctf_set_errno(fp, ECTF_NOTYPE);
120 					goto err;
121 				}
122 			}
123 
124 			type = CTF_INDEX_TO_TYPE(ntype,
125 			    (fp->ctf_flags & LCTF_CHILD));
126 
127 			q = p + 1;
128 			continue;
129 		}
130 
131 		if (isqualifier(p, (size_t)(q - p)))
132 			continue; /* skip qualifier keyword */
133 
134 		for (lp = fp->ctf_lookups; lp->ctl_prefix != NULL; lp++) {
135 			if (lp->ctl_prefix[0] == '\0' ||
136 			    ((size_t)(q - p) >= lp->ctl_len && strncmp(p,
137 			    lp->ctl_prefix, (size_t)(q - p)) == 0)) {
138 				for (p += lp->ctl_len; isspace(*p); p++)
139 					continue; /* skip prefix and next ws */
140 
141 				if ((q = strchr(p, '*')) == NULL)
142 					q = end;  /* compare until end */
143 
144 				while (isspace(q[-1]))
145 					q--;	  /* exclude trailing ws */
146 
147 				if ((hp = ctf_hash_lookup(lp->ctl_hash, fp, p,
148 				    (size_t)(q - p))) == NULL) {
149 					(void) ctf_set_errno(fp, ECTF_NOTYPE);
150 					goto err;
151 				}
152 
153 				type = hp->h_type;
154 				break;
155 			}
156 		}
157 
158 		if (lp->ctl_prefix == NULL) {
159 			(void) ctf_set_errno(fp, ECTF_NOTYPE);
160 			goto err;
161 		}
162 	}
163 
164 	if (*p != '\0' || type == 0)
165 		return (ctf_set_errno(fp, ECTF_SYNTAX));
166 
167 	return (type);
168 
169 err:
170 	if (fp->ctf_parent != NULL &&
171 	    (ptype = ctf_lookup_by_name(fp->ctf_parent, name)) != CTF_ERR)
172 		return (ptype);
173 
174 	return (CTF_ERR);
175 }
176 
177 /*
178  * Given a symbol table index, return the type of the data object described
179  * by the corresponding entry in the symbol table.
180  */
181 ctf_id_t
ctf_lookup_by_symbol(ctf_file_t * fp,ulong_t symidx)182 ctf_lookup_by_symbol(ctf_file_t *fp, ulong_t symidx)
183 {
184 	const ctf_sect_t *sp = &fp->ctf_symtab;
185 	ctf_id_t type;
186 
187 	if (sp->cts_data == NULL)
188 		return (ctf_set_errno(fp, ECTF_NOSYMTAB));
189 
190 	if (symidx >= fp->ctf_nsyms)
191 		return (ctf_set_errno(fp, EINVAL));
192 
193 	if (sp->cts_entsize == sizeof (Elf32_Sym)) {
194 		const Elf32_Sym *symp = (Elf32_Sym *)sp->cts_data + symidx;
195 		if (ELF32_ST_TYPE(symp->st_info) != STT_OBJECT)
196 			return (ctf_set_errno(fp, ECTF_NOTDATA));
197 	} else {
198 		const Elf64_Sym *symp = (Elf64_Sym *)sp->cts_data + symidx;
199 		if (ELF64_ST_TYPE(symp->st_info) != STT_OBJECT)
200 			return (ctf_set_errno(fp, ECTF_NOTDATA));
201 	}
202 
203 	if (fp->ctf_sxlate[symidx] == -1u)
204 		return (ctf_set_errno(fp, ECTF_NOTYPEDAT));
205 
206 	type = *(ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]);
207 	if (type == 0)
208 		return (ctf_set_errno(fp, ECTF_NOTYPEDAT));
209 
210 	return (type);
211 }
212 
213 /*
214  * Return the pointer to the internal CTF type data corresponding to the
215  * given type ID.  If the ID is invalid, the function returns NULL.
216  * This function is not exported outside of the library.
217  */
218 const ctf_type_t *
ctf_lookup_by_id(ctf_file_t ** fpp,ctf_id_t type)219 ctf_lookup_by_id(ctf_file_t **fpp, ctf_id_t type)
220 {
221 	ctf_file_t *fp = *fpp; /* caller passes in starting CTF container */
222 
223 	if ((fp->ctf_flags & LCTF_CHILD) && CTF_TYPE_ISPARENT(type) &&
224 	    (fp = fp->ctf_parent) == NULL) {
225 		(void) ctf_set_errno(*fpp, ECTF_NOPARENT);
226 		return (NULL);
227 	}
228 
229 	type = CTF_TYPE_TO_INDEX(type);
230 	if (type > 0 && type <= fp->ctf_typemax) {
231 		*fpp = fp; /* function returns ending CTF container */
232 		return (LCTF_INDEX_TO_TYPEPTR(fp, type));
233 	}
234 
235 	(void) ctf_set_errno(fp, ECTF_BADID);
236 	return (NULL);
237 }
238 
239 /*
240  * Given a symbol table index, return the info for the function described
241  * by the corresponding entry in the symbol table.
242  */
243 int
ctf_func_info(ctf_file_t * fp,ulong_t symidx,ctf_funcinfo_t * fip)244 ctf_func_info(ctf_file_t *fp, ulong_t symidx, ctf_funcinfo_t *fip)
245 {
246 	const ctf_sect_t *sp = &fp->ctf_symtab;
247 	const ushort_t *dp;
248 	ushort_t info, kind, n;
249 
250 	if (sp->cts_data == NULL)
251 		return (ctf_set_errno(fp, ECTF_NOSYMTAB));
252 
253 	if (symidx >= fp->ctf_nsyms)
254 		return (ctf_set_errno(fp, EINVAL));
255 
256 	if (sp->cts_entsize == sizeof (Elf32_Sym)) {
257 		const Elf32_Sym *symp = (Elf32_Sym *)sp->cts_data + symidx;
258 		if (ELF32_ST_TYPE(symp->st_info) != STT_FUNC)
259 			return (ctf_set_errno(fp, ECTF_NOTFUNC));
260 	} else {
261 		const Elf64_Sym *symp = (Elf64_Sym *)sp->cts_data + symidx;
262 		if (ELF64_ST_TYPE(symp->st_info) != STT_FUNC)
263 			return (ctf_set_errno(fp, ECTF_NOTFUNC));
264 	}
265 
266 	if (fp->ctf_sxlate[symidx] == -1u)
267 		return (ctf_set_errno(fp, ECTF_NOFUNCDAT));
268 
269 	dp = (ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]);
270 
271 	info = *dp++;
272 	kind = LCTF_INFO_KIND(fp, info);
273 	n = LCTF_INFO_VLEN(fp, info);
274 
275 	if (kind == CTF_K_UNKNOWN && n == 0)
276 		return (ctf_set_errno(fp, ECTF_NOFUNCDAT));
277 
278 	if (kind != CTF_K_FUNCTION)
279 		return (ctf_set_errno(fp, ECTF_CORRUPT));
280 
281 	fip->ctc_return = *dp++;
282 	fip->ctc_argc = n;
283 	fip->ctc_flags = 0;
284 
285 	if (n != 0 && dp[n - 1] == 0) {
286 		fip->ctc_flags |= CTF_FUNC_VARARG;
287 		fip->ctc_argc--;
288 	}
289 
290 	return (0);
291 }
292 
293 /*
294  * Given a symbol table index, return the arguments for the function described
295  * by the corresponding entry in the symbol table.
296  */
297 int
ctf_func_args(ctf_file_t * fp,ulong_t symidx,uint_t argc,ctf_id_t * argv)298 ctf_func_args(ctf_file_t *fp, ulong_t symidx, uint_t argc, ctf_id_t *argv)
299 {
300 	const ushort_t *dp;
301 	ctf_funcinfo_t f;
302 
303 	if (ctf_func_info(fp, symidx, &f) == CTF_ERR)
304 		return (CTF_ERR); /* errno is set for us */
305 
306 	/*
307 	 * The argument data is two ushort_t's past the translation table
308 	 * offset: one for the function info, and one for the return type.
309 	 */
310 	dp = (ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]) + 2;
311 
312 	for (argc = MIN(argc, f.ctc_argc); argc != 0; argc--)
313 		*argv++ = *dp++;
314 
315 	return (0);
316 }
317 
318 /*
319  * Unlike the normal lookup routines, ctf_dyn_*() variants consult both the
320  * processed CTF contents of a ctf_file_t as well as the dynamic types in the
321  * dtdef list.
322  */
323 
324 const ctf_type_t *
ctf_dyn_lookup_by_id(ctf_file_t * fp,ctf_id_t id)325 ctf_dyn_lookup_by_id(ctf_file_t *fp, ctf_id_t id)
326 {
327 	ctf_file_t **fpp = &fp;
328 	const ctf_type_t *t;
329 	ctf_dtdef_t *dtd;
330 
331 	if ((t = ctf_lookup_by_id(fpp, id)) != NULL)
332 		return (t);
333 
334 	if ((dtd = ctf_dtd_lookup(fp, id)) == NULL)
335 		return (NULL);
336 
337 	return (&dtd->dtd_data);
338 }
339 
340 int
ctf_dyn_array_info(ctf_file_t * infp,ctf_id_t id,ctf_arinfo_t * arinfop)341 ctf_dyn_array_info(ctf_file_t *infp, ctf_id_t id, ctf_arinfo_t *arinfop)
342 {
343 	ctf_file_t *fp = infp;
344 	const ctf_type_t *t;
345 	ctf_dtdef_t *dtd;
346 
347 	if ((t = ctf_lookup_by_id(&fp, id)) != NULL) {
348 
349 		if (LCTF_INFO_KIND(fp, t->ctt_info) != CTF_K_ARRAY)
350 			return (ctf_set_errno(infp, ECTF_NOTARRAY));
351 
352 		return (ctf_array_info(fp, id, arinfop));
353 	}
354 
355 	if ((dtd = ctf_dtd_lookup(fp, id)) == NULL)
356 		return (ctf_set_errno(infp, ENOENT));
357 
358 	if (LCTF_INFO_KIND(fp, dtd->dtd_data.ctt_info) != CTF_K_ARRAY)
359 		return (ctf_set_errno(infp, ECTF_NOTARRAY));
360 
361 	bcopy(&dtd->dtd_u.dtu_arr, arinfop, sizeof (*arinfop));
362 	return (0);
363 }
364