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