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 2020 Joyent, Inc. 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 dsd_list; /* list forward/back pointers */ 171 ulong_t dsd_symidx; /* symbol id */ 172 ctf_id_t dsd_tid; /* type for obj, 0 if function */ 173 uint_t dsd_nargs; 174 ctf_id_t *dsd_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 void ctf_set_ctt_size(ctf_type_t *, ssize_t); 258 259 extern const ctf_type_t *ctf_lookup_by_id(ctf_file_t **, ctf_id_t); 260 261 extern ctf_file_t *ctf_fdcreate_int(int, int *, ctf_sect_t *); 262 263 extern int ctf_hash_create(ctf_hash_t *, ulong_t); 264 extern int ctf_hash_insert(ctf_hash_t *, ctf_file_t *, ushort_t, uint_t); 265 extern int ctf_hash_define(ctf_hash_t *, ctf_file_t *, ushort_t, uint_t); 266 extern ctf_helem_t *ctf_hash_lookup(ctf_hash_t *, ctf_file_t *, 267 const char *, size_t); 268 extern uint_t ctf_hash_size(const ctf_hash_t *); 269 extern void ctf_hash_destroy(ctf_hash_t *); 270 271 #define ctf_list_prev(elem) ((void *)(((ctf_list_t *)(elem))->l_prev)) 272 #define ctf_list_next(elem) ((void *)(((ctf_list_t *)(elem))->l_next)) 273 274 extern void ctf_list_append(ctf_list_t *, void *); 275 extern void ctf_list_prepend(ctf_list_t *, void *); 276 extern void ctf_list_insert_before(ctf_list_t *, void *, void *); 277 extern void ctf_list_delete(ctf_list_t *, void *); 278 279 extern void ctf_dtd_insert(ctf_file_t *, ctf_dtdef_t *); 280 extern void ctf_dtd_delete(ctf_file_t *, ctf_dtdef_t *); 281 extern ctf_dtdef_t *ctf_dtd_lookup(ctf_file_t *, ctf_id_t); 282 283 extern void ctf_dsd_delete(ctf_file_t *, ctf_dsdef_t *); 284 extern void ctf_dld_delete(ctf_file_t *, ctf_dldef_t *); 285 286 extern void ctf_decl_init(ctf_decl_t *, char *, size_t); 287 extern void ctf_decl_fini(ctf_decl_t *); 288 extern void ctf_decl_push(ctf_decl_t *, ctf_file_t *, ctf_id_t); 289 extern void ctf_decl_sprintf(ctf_decl_t *, const char *, ...); 290 291 extern const char *ctf_strraw(ctf_file_t *, uint_t); 292 extern const char *ctf_strptr(ctf_file_t *, uint_t); 293 294 extern ctf_file_t *ctf_set_open_errno(int *, int); 295 extern long ctf_set_errno(ctf_file_t *, int); 296 297 extern const void *ctf_sect_mmap(ctf_sect_t *, int); 298 extern void ctf_sect_munmap(const ctf_sect_t *); 299 300 extern void *ctf_data_alloc(size_t); 301 extern void ctf_data_free(void *, size_t); 302 extern void ctf_data_protect(void *, size_t); 303 304 extern void *ctf_alloc(size_t); 305 extern void ctf_free(void *, size_t); 306 307 extern char *ctf_strdup(const char *); 308 extern const char *ctf_strerror(int); 309 extern void ctf_dprintf(const char *, ...); 310 311 extern void *ctf_zopen(int *); 312 313 extern ctf_id_t ctf_add_encoded(ctf_file_t *, uint_t, const char *, 314 const ctf_encoding_t *, uint_t); 315 extern ctf_id_t ctf_add_reftype(ctf_file_t *, uint_t, const char *, ctf_id_t, 316 uint_t); 317 extern boolean_t ctf_sym_valid(uintptr_t, int, uint16_t, uint64_t, 318 uint32_t); 319 320 extern const ctf_type_t *ctf_dyn_lookup_by_id(ctf_file_t *, ctf_id_t); 321 extern int ctf_dyn_array_info(ctf_file_t *, ctf_id_t, ctf_arinfo_t *); 322 323 extern const char _CTF_SECTION[]; /* name of CTF ELF section */ 324 extern const char _CTF_NULLSTR[]; /* empty string */ 325 326 extern int _libctf_version; /* library client version */ 327 extern int _libctf_debug; /* debugging messages enabled */ 328 329 #ifdef __cplusplus 330 } 331 #endif 332 333 #endif /* _CTF_IMPL_H */ 334