cddl/contrib/opensolaris/common/ctf/ctf_impl.h

   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  * Copyright (c) 2012, Joyent, Inc.  All rights reserved.
  29  */
  30
  31 #ifndef _CTF_IMPL_H
  32 #define _CTF_IMPL_H
  33
  34 #include <sys/types.h>
  35 #include <sys/errno.h>
  36 #include <sys/sysmacros.h>
  37 #include <sys/ctf_api.h>
  38
  39 #ifdef _KERNEL
  40
  41 #include <sys/systm.h>
  42 #include <sys/cmn_err.h>
  43 #include <sys/varargs.h>
  44
  45 #define isspace(c) \
  46         ((c) == ' ' || (c) == '\t' || (c) == '\n' || \
  47         (c) == '\r' || (c) == '\f' || (c) == '\v')
  48
  49 #define MAP_FAILED      ((void *)-1)
  50
  51 #else   /* _KERNEL */
  52
  53 #include <strings.h>
  54 #include <stdlib.h>
  55 #include <stdarg.h>
  56 #include <stdio.h>
  57 #include <limits.h>
  58 #include <ctype.h>
  59
  60 #endif  /* _KERNEL */
  61
  62 #ifdef  __cplusplus
  63 extern "C" {
  64 #endif
  65
  66 typedef struct ctf_helem {
  67         uint_t h_name;          /* reference to name in string table */
  68         ushort_t h_type;        /* corresponding type ID number */
  69         ushort_t h_next;        /* index of next element in hash chain */
  70 } ctf_helem_t;
  71
  72 typedef struct ctf_hash {
  73         ushort_t *h_buckets;    /* hash bucket array (chain indices) */
  74         ctf_helem_t *h_chains;  /* hash chains buffer */
  75         ushort_t h_nbuckets;    /* number of elements in bucket array */
  76         ushort_t h_nelems;      /* number of elements in hash table */
  77         uint_t h_free;          /* index of next free hash element */
  78 } ctf_hash_t;
  79
  80 typedef struct ctf_strs {
  81         const char *cts_strs;   /* base address of string table */
  82         size_t cts_len;         /* size of string table in bytes */
  83 } ctf_strs_t;
  84
  85 typedef struct ctf_dmodel {
  86         const char *ctd_name;   /* data model name */
  87         int ctd_code;           /* data model code */
  88         size_t ctd_pointer;     /* size of void * in bytes */
  89         size_t ctd_char;        /* size of char in bytes */
  90         size_t ctd_short;       /* size of short in bytes */
  91         size_t ctd_int;         /* size of int in bytes */
  92         size_t ctd_long;        /* size of long in bytes */
  93 } ctf_dmodel_t;
  94
  95 typedef struct ctf_lookup {
  96         const char *ctl_prefix; /* string prefix for this lookup */
  97         size_t ctl_len;         /* length of prefix string in bytes */
  98         ctf_hash_t *ctl_hash;   /* pointer to hash table for lookup */
  99 } ctf_lookup_t;
 100
 101 typedef struct ctf_fileops {
 102         ushort_t (*ctfo_get_kind)(ushort_t);
 103         ushort_t (*ctfo_get_root)(ushort_t);
 104         ushort_t (*ctfo_get_vlen)(ushort_t);
 105 } ctf_fileops_t;
 106
 107 typedef struct ctf_list {
 108         struct ctf_list *l_prev; /* previous pointer or tail pointer */
 109         struct ctf_list *l_next; /* next pointer or head pointer */
 110 } ctf_list_t;
 111
 112 typedef enum {
 113         CTF_PREC_BASE,
 114         CTF_PREC_POINTER,
 115         CTF_PREC_ARRAY,
 116         CTF_PREC_FUNCTION,
 117         CTF_PREC_MAX
 118 } ctf_decl_prec_t;
 119
 120 typedef struct ctf_decl_node {
 121         ctf_list_t cd_list;                     /* linked list pointers */
 122         ctf_id_t cd_type;                       /* type identifier */
 123         uint_t cd_kind;                         /* type kind */
 124         uint_t cd_n;                            /* type dimension if array */
 125 } ctf_decl_node_t;
 126
 127 typedef struct ctf_decl {
 128         ctf_list_t cd_nodes[CTF_PREC_MAX];      /* declaration node stacks */
 129         int cd_order[CTF_PREC_MAX];             /* storage order of decls */
 130         ctf_decl_prec_t cd_qualp;               /* qualifier precision */
 131         ctf_decl_prec_t cd_ordp;                /* ordered precision */
 132         char *cd_buf;                           /* buffer for output */
 133         char *cd_ptr;                           /* buffer location */
 134         char *cd_end;                           /* buffer limit */
 135         size_t cd_len;                          /* buffer space required */
 136         int cd_err;                             /* saved error value */
 137 } ctf_decl_t;
 138
 139 typedef struct ctf_dmdef {
 140         ctf_list_t dmd_list;    /* list forward/back pointers */
 141         char *dmd_name;         /* name of this member */
 142         ctf_id_t dmd_type;      /* type of this member (for sou) */
 143         ulong_t dmd_offset;     /* offset of this member in bits (for sou) */
 144         int dmd_value;          /* value of this member (for enum) */
 145 } ctf_dmdef_t;
 146
 147 typedef struct ctf_dtdef {
 148         ctf_list_t dtd_list;    /* list forward/back pointers */
 149         struct ctf_dtdef *dtd_hash; /* hash chain pointer for ctf_dthash */
 150         char *dtd_name;         /* name associated with definition (if any) */
 151         ctf_id_t dtd_type;      /* type identifier for this definition */
 152         ctf_type_t dtd_data;    /* type node (see <sys/ctf.h>) */
 153         int dtd_ref;            /* recfount for dyanmic types */
 154         union {
 155                 ctf_list_t dtu_members; /* struct, union, or enum */
 156                 ctf_arinfo_t dtu_arr;   /* array */
 157                 ctf_encoding_t dtu_enc; /* integer or float */
 158                 ctf_id_t *dtu_argv;     /* function */
 159         } dtd_u;
 160 } ctf_dtdef_t;
 161
 162 typedef struct ctf_bundle {
 163         ctf_file_t *ctb_file;   /* CTF container handle */
 164         ctf_id_t ctb_type;      /* CTF type identifier */
 165         ctf_dtdef_t *ctb_dtd;   /* CTF dynamic type definition (if any) */
 166 } ctf_bundle_t;
 167
 168 /*
 169  * The ctf_file is the structure used to represent a CTF container to library
 170  * clients, who see it only as an opaque pointer.  Modifications can therefore
 171  * be made freely to this structure without regard to client versioning.  The
 172  * ctf_file_t typedef appears in <sys/ctf_api.h> and declares a forward tag.
 173  *
 174  * NOTE: ctf_update() requires that everything inside of ctf_file either be an
 175  * immediate value, a pointer to dynamically allocated data *outside* of the
 176  * ctf_file itself, or a pointer to statically allocated data.  If you add a
 177  * pointer to ctf_file that points to something within the ctf_file itself,
 178  * you must make corresponding changes to ctf_update().
 179  */
 180 struct ctf_file {
 181         const ctf_fileops_t *ctf_fileops; /* version-specific file operations */
 182         ctf_sect_t ctf_data;    /* CTF data from object file */
 183         ctf_sect_t ctf_symtab;  /* symbol table from object file */
 184         ctf_sect_t ctf_strtab;  /* string table from object file */
 185         ctf_hash_t ctf_structs; /* hash table of struct types */
 186         ctf_hash_t ctf_unions;  /* hash table of union types */
 187         ctf_hash_t ctf_enums;   /* hash table of enum types */
 188         ctf_hash_t ctf_names;   /* hash table of remaining type names */
 189         ctf_lookup_t ctf_lookups[5];    /* pointers to hashes for name lookup */
 190         ctf_strs_t ctf_str[2];  /* array of string table base and bounds */
 191         const uchar_t *ctf_base; /* base of CTF header + uncompressed buffer */
 192         const uchar_t *ctf_buf; /* uncompressed CTF data buffer */
 193         size_t ctf_size;        /* size of CTF header + uncompressed data */
 194         uint_t *ctf_sxlate;     /* translation table for symtab entries */
 195         ulong_t ctf_nsyms;      /* number of entries in symtab xlate table */
 196         uint_t *ctf_txlate;     /* translation table for type IDs */
 197         ushort_t *ctf_ptrtab;   /* translation table for pointer-to lookups */
 198         ulong_t ctf_typemax;    /* maximum valid type ID number */
 199         const ctf_dmodel_t *ctf_dmodel; /* data model pointer (see above) */
 200         struct ctf_file *ctf_parent;    /* parent CTF container (if any) */
 201         const char *ctf_parlabel;       /* label in parent container (if any) */
 202         const char *ctf_parname;        /* basename of parent (if any) */
 203         uint_t ctf_refcnt;      /* reference count (for parent links) */
 204         uint_t ctf_flags;       /* libctf flags (see below) */
 205         int ctf_errno;          /* error code for most recent error */
 206         int ctf_version;        /* CTF data version */
 207         ctf_dtdef_t **ctf_dthash; /* hash of dynamic type definitions */
 208         ulong_t ctf_dthashlen;  /* size of dynamic type hash bucket array */
 209         ctf_list_t ctf_dtdefs;  /* list of dynamic type definitions */
 210         size_t ctf_dtstrlen;    /* total length of dynamic type strings */
 211         ulong_t ctf_dtnextid;   /* next dynamic type id to assign */
 212         ulong_t ctf_dtoldid;    /* oldest id that has been committed */
 213         void *ctf_specific;     /* data for ctf_get/setspecific */
 214 };
 215
 216 #define LCTF_INDEX_TO_TYPEPTR(fp, i) \
 217         ((ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
 218
 219 #define LCTF_INFO_KIND(fp, info)        ((fp)->ctf_fileops->ctfo_get_kind(info))
 220 #define LCTF_INFO_ROOT(fp, info)        ((fp)->ctf_fileops->ctfo_get_root(info))
 221 #define LCTF_INFO_VLEN(fp, info)        ((fp)->ctf_fileops->ctfo_get_vlen(info))
 222
 223 #define LCTF_MMAP       0x0001  /* libctf should munmap buffers on close */
 224 #define LCTF_CHILD      0x0002  /* CTF container is a child */
 225 #define LCTF_RDWR       0x0004  /* CTF container is writable */
 226 #define LCTF_DIRTY      0x0008  /* CTF container has been modified */
 227
 228 #define ECTF_BASE       1000    /* base value for libctf errnos */
 229
 230 enum {
 231         ECTF_FMT = ECTF_BASE,   /* file is not in CTF or ELF format */
 232         ECTF_ELFVERS,           /* ELF version is more recent than libctf */
 233         ECTF_CTFVERS,           /* CTF version is more recent than libctf */
 234         ECTF_ENDIAN,            /* data is different endian-ness than lib */
 235         ECTF_SYMTAB,            /* symbol table uses invalid entry size */
 236         ECTF_SYMBAD,            /* symbol table data buffer invalid */
 237         ECTF_STRBAD,            /* string table data buffer invalid */
 238         ECTF_CORRUPT,           /* file data corruption detected */
 239         ECTF_NOCTFDATA,         /* ELF file does not contain CTF data */
 240         ECTF_NOCTFBUF,          /* buffer does not contain CTF data */
 241         ECTF_NOSYMTAB,          /* symbol table data is not available */
 242         ECTF_NOPARENT,          /* parent CTF container is not available */
 243         ECTF_DMODEL,            /* data model mismatch */
 244         ECTF_MMAP,              /* failed to mmap a data section */
 245         ECTF_ZMISSING,          /* decompression library not installed */
 246         ECTF_ZINIT,             /* failed to initialize decompression library */
 247         ECTF_ZALLOC,            /* failed to allocate decompression buffer */
 248         ECTF_DECOMPRESS,        /* failed to decompress CTF data */
 249         ECTF_STRTAB,            /* string table for this string is missing */
 250         ECTF_BADNAME,           /* string offset is corrupt w.r.t. strtab */
 251         ECTF_BADID,             /* invalid type ID number */
 252         ECTF_NOTSOU,            /* type is not a struct or union */
 253         ECTF_NOTENUM,           /* type is not an enum */
 254         ECTF_NOTSUE,            /* type is not a struct, union, or enum */
 255         ECTF_NOTINTFP,          /* type is not an integer or float */
 256         ECTF_NOTARRAY,          /* type is not an array */
 257         ECTF_NOTREF,            /* type does not reference another type */
 258         ECTF_NAMELEN,           /* buffer is too small to hold type name */
 259         ECTF_NOTYPE,            /* no type found corresponding to name */
 260         ECTF_SYNTAX,            /* syntax error in type name */
 261         ECTF_NOTFUNC,           /* symtab entry does not refer to a function */
 262         ECTF_NOFUNCDAT,         /* no func info available for function */
 263         ECTF_NOTDATA,           /* symtab entry does not refer to a data obj */
 264         ECTF_NOTYPEDAT,         /* no type info available for object */
 265         ECTF_NOLABEL,           /* no label found corresponding to name */
 266         ECTF_NOLABELDATA,       /* file does not contain any labels */
 267         ECTF_NOTSUP,            /* feature not supported */
 268         ECTF_NOENUMNAM,         /* enum element name not found */
 269         ECTF_NOMEMBNAM,         /* member name not found */
 270         ECTF_RDONLY,            /* CTF container is read-only */
 271         ECTF_DTFULL,            /* CTF type is full (no more members allowed) */
 272         ECTF_FULL,              /* CTF container is full */
 273         ECTF_DUPMEMBER,         /* duplicate member name definition */
 274         ECTF_CONFLICT,          /* conflicting type definition present */
 275         ECTF_REFERENCED,        /* type has outstanding references */
 276         ECTF_NOTDYN             /* type is not a dynamic type */
 277 };
 278
 279 extern ssize_t ctf_get_ctt_size(const ctf_file_t *, const ctf_type_t *,
 280     ssize_t *, ssize_t *);
 281
 282 extern const ctf_type_t *ctf_lookup_by_id(ctf_file_t **, ctf_id_t);
 283
 284 extern int ctf_hash_create(ctf_hash_t *, ulong_t);
 285 extern int ctf_hash_insert(ctf_hash_t *, ctf_file_t *, ushort_t, uint_t);
 286 extern int ctf_hash_define(ctf_hash_t *, ctf_file_t *, ushort_t, uint_t);
 287 extern ctf_helem_t *ctf_hash_lookup(ctf_hash_t *, ctf_file_t *,
 288     const char *, size_t);
 289 extern uint_t ctf_hash_size(const ctf_hash_t *);
 290 extern void ctf_hash_destroy(ctf_hash_t *);
 291
 292 #define ctf_list_prev(elem)     ((void *)(((ctf_list_t *)(elem))->l_prev))
 293 #define ctf_list_next(elem)     ((void *)(((ctf_list_t *)(elem))->l_next))
 294
 295 extern void ctf_list_append(ctf_list_t *, void *);
 296 extern void ctf_list_prepend(ctf_list_t *, void *);
 297 extern void ctf_list_delete(ctf_list_t *, void *);
 298
 299 extern void ctf_dtd_insert(ctf_file_t *, ctf_dtdef_t *);
 300 extern void ctf_dtd_delete(ctf_file_t *, ctf_dtdef_t *);
 301 extern ctf_dtdef_t *ctf_dtd_lookup(ctf_file_t *, ctf_id_t);
 302
 303 extern void ctf_decl_init(ctf_decl_t *, char *, size_t);
 304 extern void ctf_decl_fini(ctf_decl_t *);
 305 extern void ctf_decl_push(ctf_decl_t *, ctf_file_t *, ctf_id_t);
 306 extern void ctf_decl_sprintf(ctf_decl_t *, const char *, ...);
 307
 308 extern const char *ctf_strraw(ctf_file_t *, uint_t);
 309 extern const char *ctf_strptr(ctf_file_t *, uint_t);
 310
 311 extern ctf_file_t *ctf_set_open_errno(int *, int);
 312 extern long ctf_set_errno(ctf_file_t *, int);
 313
 314 extern const void *ctf_sect_mmap(ctf_sect_t *, int);
 315 extern void ctf_sect_munmap(const ctf_sect_t *);
 316
 317 extern void *ctf_data_alloc(size_t);
 318 extern void ctf_data_free(void *, size_t);
 319 extern void ctf_data_protect(void *, size_t);
 320
 321 extern void *ctf_alloc(size_t);
 322 extern void ctf_free(void *, size_t);
 323
 324 extern char *ctf_strdup(const char *);
 325 extern const char *ctf_strerror(int);
 326 extern void ctf_dprintf(const char *, ...);
 327
 328 extern void *ctf_zopen(int *);
 329
 330 extern const char _CTF_SECTION[];       /* name of CTF ELF section */
 331 extern const char _CTF_NULLSTR[];       /* empty string */
 332
 333 extern int _libctf_version;             /* library client version */
 334 extern int _libctf_debug;               /* debugging messages enabled */
 335
 336 #ifdef  __cplusplus
 337 }
 338 #endif
 339
 340 #endif  /* _CTF_IMPL_H */