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 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 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 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 * 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 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 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 * 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 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