usr/src/common/ctf/ctf_lookup.c

   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 #pragma ident   "%Z%%M% %I%     %E% SMI"
  29
  30 #include <sys/sysmacros.h>
  31 #include <ctf_impl.h>
  32
  33 /*
  34  * Compare the given input string and length against a table of known C storage
  35  * qualifier keywords.  We just ignore these in ctf_lookup_by_name, below.  To
  36  * do this quickly, we use a pre-computed Perfect Hash Function similar to the
  37  * technique originally described in the classic paper:
  38  *
  39  * R.J. Cichelli, "Minimal Perfect Hash Functions Made Simple",
  40  * Communications of the ACM, Volume 23, Issue 1, January 1980, pp. 17-19.
  41  *
  42  * For an input string S of length N, we use hash H = S[N - 1] + N - 105, which
  43  * for the current set of qualifiers yields a unique H in the range [0 .. 20].
  44  * The hash can be modified when the keyword set changes as necessary.  We also
  45  * store the length of each keyword and check it prior to the final strcmp().
  46  */
  47 static int
  48 isqualifier(const char *s, size_t len)
  49 {
  50         static const struct qual {
  51                 const char *q_name;
  52                 size_t q_len;
  53         } qhash[] = {
  54                 { "static", 6 }, { "", 0 }, { "", 0 }, { "", 0 },
  55                 { "volatile", 8 }, { "", 0 }, { "", 0 }, { "", 0 }, { "", 0 },
  56                 { "", 0 }, { "auto", 4 }, { "extern", 6 }, { "", 0 }, { "", 0 },
  57                 { "", 0 }, { "", 0 }, { "const", 5 }, { "register", 8 },
  58                 { "", 0 }, { "restrict", 8 }, { "_Restrict", 9 }
  59         };
  60
  61         int h = s[len - 1] + (int)len - 105;
  62         const struct qual *qp = &qhash[h];
  63
  64         return (h >= 0 && h < sizeof (qhash) / sizeof (qhash[0]) &&
  65             len == qp->q_len && strncmp(qp->q_name, s, qp->q_len) == 0);
  66 }
  67
  68 /*
  69  * Attempt to convert the given C type name into the corresponding CTF type ID.
  70  * It is not possible to do complete and proper conversion of type names
  71  * without implementing a more full-fledged parser, which is necessary to
  72  * handle things like types that are function pointers to functions that
  73  * have arguments that are function pointers, and fun stuff like that.
  74  * Instead, this function implements a very simple conversion algorithm that
  75  * finds the things that we actually care about: structs, unions, enums,
  76  * integers, floats, typedefs, and pointers to any of these named types.
  77  */
  78 ctf_id_t
  79 ctf_lookup_by_name(ctf_file_t *fp, const char *name)
  80 {
  81         static const char delimiters[] = " \t\n\r\v\f*";
  82
  83         const ctf_lookup_t *lp;
  84         const ctf_helem_t *hp;
  85         const char *p, *q, *end;
  86         ctf_id_t type = 0;
  87         ctf_id_t ntype, ptype;
  88
  89         if (name == NULL)
  90                 return (ctf_set_errno(fp, EINVAL));
  91
  92         for (p = name, end = name + strlen(name); *p != '\0'; p = q) {
  93                 while (isspace(*p))
  94                         p++; /* skip leading ws */
  95
  96                 if (p == end)
  97                         break;
  98
  99                 if ((q = strpbrk(p + 1, delimiters)) == NULL)
 100                         q = end; /* compare until end */
 101
 102                 if (*p == '*') {
 103                         /*
 104                          * Find a pointer to type by looking in fp->ctf_ptrtab.
 105                          * If we can't find a pointer to the given type, see if
 106                          * we can compute a pointer to the type resulting from
 107                          * resolving the type down to its base type and use
 108                          * that instead.  This helps with cases where the CTF
 109                          * data includes "struct foo *" but not "foo_t *" and
 110                          * the user tries to access "foo_t *" in the debugger.
 111                          */
 112                         ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)];
 113                         if (ntype == 0) {
 114                                 ntype = ctf_type_resolve(fp, type);
 115                                 if (ntype == CTF_ERR || (ntype = fp->ctf_ptrtab[
 116                                     CTF_TYPE_TO_INDEX(ntype)]) == 0) {
 117                                         (void) ctf_set_errno(fp, ECTF_NOTYPE);
 118                                         goto err;
 119                                 }
 120                         }
 121
 122                         type = CTF_INDEX_TO_TYPE(ntype,
 123                             (fp->ctf_flags & LCTF_CHILD));
 124
 125                         q = p + 1;
 126                         continue;
 127                 }
 128
 129                 if (isqualifier(p, (size_t)(q - p)))
 130                         continue; /* skip qualifier keyword */
 131
 132                 for (lp = fp->ctf_lookups; lp->ctl_prefix != NULL; lp++) {
 133                         if (lp->ctl_prefix[0] == '\0' ||
 134                             strncmp(p, lp->ctl_prefix, (size_t)(q - p)) == 0) {
 135                                 for (p += lp->ctl_len; isspace(*p); p++)
 136                                         continue; /* skip prefix and next ws */
 137
 138                                 if ((q = strchr(p, '*')) == NULL)
 139                                         q = end;  /* compare until end */
 140
 141                                 while (isspace(q[-1]))
 142                                         q--;      /* exclude trailing ws */
 143
 144                                 if ((hp = ctf_hash_lookup(lp->ctl_hash, fp, p,
 145                                     (size_t)(q - p))) == NULL) {
 146                                         (void) ctf_set_errno(fp, ECTF_NOTYPE);
 147                                         goto err;
 148                                 }
 149
 150                                 type = hp->h_type;
 151                                 break;
 152                         }
 153                 }
 154
 155                 if (lp->ctl_prefix == NULL) {
 156                         (void) ctf_set_errno(fp, ECTF_NOTYPE);
 157                         goto err;
 158                 }
 159         }
 160
 161         if (*p != '\0' || type == 0)
 162                 return (ctf_set_errno(fp, ECTF_SYNTAX));
 163
 164         return (type);
 165
 166 err:
 167         if (fp->ctf_parent != NULL &&
 168             (ptype = ctf_lookup_by_name(fp->ctf_parent, name)) != CTF_ERR)
 169                 return (ptype);
 170
 171         return (CTF_ERR);
 172 }
 173
 174 /*
 175  * Given a symbol table index, return the type of the data object described
 176  * by the corresponding entry in the symbol table.
 177  */
 178 ctf_id_t
 179 ctf_lookup_by_symbol(ctf_file_t *fp, ulong_t symidx)
 180 {
 181         const ctf_sect_t *sp = &fp->ctf_symtab;
 182         ctf_id_t type;
 183
 184         if (sp->cts_data == NULL)
 185                 return (ctf_set_errno(fp, ECTF_NOSYMTAB));
 186
 187         if (symidx >= fp->ctf_nsyms)
 188                 return (ctf_set_errno(fp, EINVAL));
 189
 190         if (sp->cts_entsize == sizeof (Elf32_Sym)) {
 191                 const Elf32_Sym *symp = (Elf32_Sym *)sp->cts_data + symidx;
 192                 if (ELF32_ST_TYPE(symp->st_info) != STT_OBJECT)
 193                         return (ctf_set_errno(fp, ECTF_NOTDATA));
 194         } else {
 195                 const Elf64_Sym *symp = (Elf64_Sym *)sp->cts_data + symidx;
 196                 if (ELF64_ST_TYPE(symp->st_info) != STT_OBJECT)
 197                         return (ctf_set_errno(fp, ECTF_NOTDATA));
 198         }
 199
 200         if (fp->ctf_sxlate[symidx] == -1u)
 201                 return (ctf_set_errno(fp, ECTF_NOTYPEDAT));
 202
 203         type = *(ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]);
 204         if (type == 0)
 205                 return (ctf_set_errno(fp, ECTF_NOTYPEDAT));
 206
 207         return (type);
 208 }
 209
 210 /*
 211  * Return the pointer to the internal CTF type data corresponding to the
 212  * given type ID.  If the ID is invalid, the function returns NULL.
 213  * This function is not exported outside of the library.
 214  */
 215 const ctf_type_t *
 216 ctf_lookup_by_id(ctf_file_t **fpp, ctf_id_t type)
 217 {
 218         ctf_file_t *fp = *fpp; /* caller passes in starting CTF container */
 219
 220         if ((fp->ctf_flags & LCTF_CHILD) && CTF_TYPE_ISPARENT(type) &&
 221             (fp = fp->ctf_parent) == NULL) {
 222                 (void) ctf_set_errno(*fpp, ECTF_NOPARENT);
 223                 return (NULL);
 224         }
 225
 226         type = CTF_TYPE_TO_INDEX(type);
 227         if (type > 0 && type <= fp->ctf_typemax) {
 228                 *fpp = fp; /* function returns ending CTF container */
 229                 return (LCTF_INDEX_TO_TYPEPTR(fp, type));
 230         }
 231
 232         (void) ctf_set_errno(fp, ECTF_BADID);
 233         return (NULL);
 234 }
 235
 236 /*
 237  * Given a symbol table index, return the info for the function described
 238  * by the corresponding entry in the symbol table.
 239  */
 240 int
 241 ctf_func_info(ctf_file_t *fp, ulong_t symidx, ctf_funcinfo_t *fip)
 242 {
 243         const ctf_sect_t *sp = &fp->ctf_symtab;
 244         const ushort_t *dp;
 245         ushort_t info, kind, n;
 246
 247         if (sp->cts_data == NULL)
 248                 return (ctf_set_errno(fp, ECTF_NOSYMTAB));
 249
 250         if (symidx >= fp->ctf_nsyms)
 251                 return (ctf_set_errno(fp, EINVAL));
 252
 253         if (sp->cts_entsize == sizeof (Elf32_Sym)) {
 254                 const Elf32_Sym *symp = (Elf32_Sym *)sp->cts_data + symidx;
 255                 if (ELF32_ST_TYPE(symp->st_info) != STT_FUNC)
 256                         return (ctf_set_errno(fp, ECTF_NOTFUNC));
 257         } else {
 258                 const Elf64_Sym *symp = (Elf64_Sym *)sp->cts_data + symidx;
 259                 if (ELF64_ST_TYPE(symp->st_info) != STT_FUNC)
 260                         return (ctf_set_errno(fp, ECTF_NOTFUNC));
 261         }
 262
 263         if (fp->ctf_sxlate[symidx] == -1u)
 264                 return (ctf_set_errno(fp, ECTF_NOFUNCDAT));
 265
 266         dp = (ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]);
 267
 268         info = *dp++;
 269         kind = LCTF_INFO_KIND(fp, info);
 270         n = LCTF_INFO_VLEN(fp, info);
 271
 272         if (kind == CTF_K_UNKNOWN && n == 0)
 273                 return (ctf_set_errno(fp, ECTF_NOFUNCDAT));
 274
 275         if (kind != CTF_K_FUNCTION)
 276                 return (ctf_set_errno(fp, ECTF_CORRUPT));
 277
 278         fip->ctc_return = *dp++;
 279         fip->ctc_argc = n;
 280         fip->ctc_flags = 0;
 281
 282         if (n != 0 && dp[n - 1] == 0) {
 283                 fip->ctc_flags |= CTF_FUNC_VARARG;
 284                 fip->ctc_argc--;
 285         }
 286
 287         return (0);
 288 }
 289
 290 /*
 291  * Given a symbol table index, return the arguments for the function described
 292  * by the corresponding entry in the symbol table.
 293  */
 294 int
 295 ctf_func_args(ctf_file_t *fp, ulong_t symidx, uint_t argc, ctf_id_t *argv)
 296 {
 297         const ushort_t *dp;
 298         ctf_funcinfo_t f;
 299
 300         if (ctf_func_info(fp, symidx, &f) == CTF_ERR)
 301                 return (CTF_ERR); /* errno is set for us */
 302
 303         /*
 304          * The argument data is two ushort_t's past the translation table
 305          * offset: one for the function info, and one for the return type.
 306          */
 307         dp = (ushort_t *)((uintptr_t)fp->ctf_buf + fp->ctf_sxlate[symidx]) + 2;
 308
 309         for (argc = MIN(argc, f.ctc_argc); argc != 0; argc--)
 310                 *argv++ = *dp++;
 311
 312         return (0);
 313 }