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