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                             strncmp(p, lp->ctl_prefix, (size_t)(q - p)) == 0) {
 137                                 for (p += lp->ctl_len; isspace(*p); p++)
 138                                         continue; /* skip prefix and next ws */
 139 
 140                                 if ((q = strchr(p, '*')) == NULL)
 141                                         q = end;  /* compare until end */
 142 
 143                                 while (isspace(q[-1]))
 144                                         q--;      /* exclude trailing ws */
 145 
 146                                 if ((hp = ctf_hash_lookup(lp->ctl_hash, fp, p,
 147                                     (size_t)(q - p))) == NULL) {
 148                                         (void) ctf_set_errno(fp, ECTF_NOTYPE);
 149                                         goto err;
 150                                 }
 151 
 152                                 type = hp->h_type;
 153                                 break;
 154                         }
 155                 }
 156 
 157                 if (lp->ctl_prefix == NULL) {
 158                         (void) ctf_set_errno(fp, ECTF_NOTYPE);
 159                         goto err;
 160                 }
 161         }
 162 
 163         if (*p != '\0' || type == 0)
 164                 return (ctf_set_errno(fp, ECTF_SYNTAX));
 165 
 166         return (type);
 167 
 168 err:
 169         if (fp->ctf_parent != NULL &&
 170             (ptype = ctf_lookup_by_name(fp->ctf_parent, name)) != CTF_ERR)
 171                 return (ptype);
 172 
 173         return (CTF_ERR);
 174 }
 175 
 176 /*
 177  * Given a symbol table index, return the type of the data object described
 178  * by the corresponding entry in the symbol table.
 179  */
 180 ctf_id_t
 181 ctf_lookup_by_symbol(ctf_file_t *fp, ulong_t symidx)
 182 {
 183         const ctf_sect_t *sp = &fp->ctf_symtab;
 184         ctf_id_t type;
 185 
 186         if (sp->cts_data == NULL)
 187                 return (ctf_set_errno(fp, ECTF_NOSYMTAB));
 188 
 189         if (symidx >= fp->ctf_nsyms)
 190                 return (ctf_set_errno(fp, EINVAL));
 191 
 192         if (sp->cts_entsize == sizeof (Elf32_Sym)) {
 193                 const Elf32_Sym *symp = (Elf32_Sym *)sp->cts_data + symidx;
 194                 if (ELF32_ST_TYPE(symp->st_info) != STT_OBJECT)
 195                         return (ctf_set_errno(fp, ECTF_NOTDATA));
 196         } else {
 197                 const Elf64_Sym *symp = (Elf64_Sym *)sp->cts_data + symidx;
 198                 if (ELF64_ST_TYPE(symp->st_info) != STT_OBJECT)
 199                         return (ctf_set_errno(fp, ECTF_NOTDATA));
 200         }
 201 
 202         if (fp->ctf_sxlate[symidx] == -1u)
 203                 return (ctf_set_errno(fp, ECTF_NOTYPEDAT));
 204 
 205         type = *(ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]);
 206         if (type == 0)
 207                 return (ctf_set_errno(fp, ECTF_NOTYPEDAT));
 208 
 209         return (type);
 210 }
 211 
 212 /*
 213  * Return the pointer to the internal CTF type data corresponding to the
 214  * given type ID.  If the ID is invalid, the function returns NULL.
 215  * This function is not exported outside of the library.
 216  */
 217 const ctf_type_t *
 218 ctf_lookup_by_id(ctf_file_t **fpp, ctf_id_t type)
 219 {
 220         ctf_file_t *fp = *fpp; /* caller passes in starting CTF container */
 221 
 222         if ((fp->ctf_flags & LCTF_CHILD) && CTF_TYPE_ISPARENT(type) &&
 223             (fp = fp->ctf_parent) == NULL) {
 224                 (void) ctf_set_errno(*fpp, ECTF_NOPARENT);
 225                 return (NULL);
 226         }
 227 
 228         type = CTF_TYPE_TO_INDEX(type);
 229         if (type > 0 && type <= fp->ctf_typemax) {
 230                 *fpp = fp; /* function returns ending CTF container */
 231                 return (LCTF_INDEX_TO_TYPEPTR(fp, type));
 232         }
 233 
 234         (void) ctf_set_errno(fp, ECTF_BADID);
 235         return (NULL);
 236 }
 237 
 238 /*
 239  * Given a symbol table index, return the info for the function described
 240  * by the corresponding entry in the symbol table.
 241  */
 242 int
 243 ctf_func_info(ctf_file_t *fp, ulong_t symidx, ctf_funcinfo_t *fip)
 244 {
 245         const ctf_sect_t *sp = &fp->ctf_symtab;
 246         const ushort_t *dp;
 247         ushort_t info, kind, n;
 248 
 249         if (sp->cts_data == NULL)
 250                 return (ctf_set_errno(fp, ECTF_NOSYMTAB));
 251 
 252         if (symidx >= fp->ctf_nsyms)
 253                 return (ctf_set_errno(fp, EINVAL));
 254 
 255         if (sp->cts_entsize == sizeof (Elf32_Sym)) {
 256                 const Elf32_Sym *symp = (Elf32_Sym *)sp->cts_data + symidx;
 257                 if (ELF32_ST_TYPE(symp->st_info) != STT_FUNC)
 258                         return (ctf_set_errno(fp, ECTF_NOTFUNC));
 259         } else {
 260                 const Elf64_Sym *symp = (Elf64_Sym *)sp->cts_data + symidx;
 261                 if (ELF64_ST_TYPE(symp->st_info) != STT_FUNC)
 262                         return (ctf_set_errno(fp, ECTF_NOTFUNC));
 263         }
 264 
 265         if (fp->ctf_sxlate[symidx] == -1u)
 266                 return (ctf_set_errno(fp, ECTF_NOFUNCDAT));
 267 
 268         dp = (ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]);
 269 
 270         info = *dp++;
 271         kind = LCTF_INFO_KIND(fp, info);
 272         n = LCTF_INFO_VLEN(fp, info);
 273 
 274         if (kind == CTF_K_UNKNOWN && n == 0)
 275                 return (ctf_set_errno(fp, ECTF_NOFUNCDAT));
 276 
 277         if (kind != CTF_K_FUNCTION)
 278                 return (ctf_set_errno(fp, ECTF_CORRUPT));
 279 
 280         fip->ctc_return = *dp++;
 281         fip->ctc_argc = n;
 282         fip->ctc_flags = 0;
 283 
 284         if (n != 0 && dp[n - 1] == 0) {
 285                 fip->ctc_flags |= CTF_FUNC_VARARG;
 286                 fip->ctc_argc--;
 287         }
 288 
 289         return (0);
 290 }
 291 
 292 /*
 293  * Given a symbol table index, return the arguments for the function described
 294  * by the corresponding entry in the symbol table.
 295  */
 296 int
 297 ctf_func_args(ctf_file_t *fp, ulong_t symidx, uint_t argc, ctf_id_t *argv)
 298 {
 299         const ushort_t *dp;
 300         ctf_funcinfo_t f;
 301 
 302         if (ctf_func_info(fp, symidx, &f) == CTF_ERR)
 303                 return (CTF_ERR); /* errno is set for us */
 304 
 305         /*
 306          * The argument data is two ushort_t's past the translation table
 307          * offset: one for the function info, and one for the return type.
 308          */
 309         dp = (ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]) + 2;
 310 
 311         for (argc = MIN(argc, f.ctc_argc); argc != 0; argc--)
 312                 *argv++ = *dp++;
 313 
 314         return (0);
 315 }
 316 
 317 /*
 318  * Unlike the normal lookup routines, ctf_dyn_*() variants consult both the
 319  * processed CTF contents of a ctf_file_t as well as the dynamic types in the
 320  * dtdef list.
 321  */
 322 
 323 const ctf_type_t *
 324 ctf_dyn_lookup_by_id(ctf_file_t *fp, ctf_id_t id)
 325 {
 326         ctf_file_t **fpp = &fp;
 327         const ctf_type_t *t;
 328         ctf_dtdef_t *dtd;
 329 
 330         if ((t = ctf_lookup_by_id(fpp, id)) != NULL)
 331                 return (t);
 332 
 333         if ((dtd = ctf_dtd_lookup(fp, id)) == NULL)
 334                 return (NULL);
 335 
 336         return (&dtd->dtd_data);
 337 }
 338 
 339 int
 340 ctf_dyn_array_info(ctf_file_t *infp, ctf_id_t id, ctf_arinfo_t *arinfop)
 341 {
 342         ctf_file_t *fp = infp;
 343         const ctf_type_t *t;
 344         ctf_dtdef_t *dtd;
 345 
 346         if ((t = ctf_lookup_by_id(&fp, id)) != NULL) {
 347 
 348                 if (LCTF_INFO_KIND(fp, t->ctt_info) != CTF_K_ARRAY)
 349                         return (ctf_set_errno(infp, ECTF_NOTARRAY));
 350 
 351                 return (ctf_array_info(fp, id, arinfop));
 352         }
 353 
 354         if ((dtd = ctf_dtd_lookup(fp, id)) == NULL)
 355                 return (ctf_set_errno(infp, ENOENT));
 356 
 357         if (LCTF_INFO_KIND(fp, dtd->dtd_data.ctt_info) != CTF_K_ARRAY)
 358                 return (ctf_set_errno(infp, ECTF_NOTARRAY));
 359 
 360         bcopy(&dtd->dtd_u.dtu_arr, arinfop, sizeof (*arinfop));
 361         return (0);
 362 }