# # CDDL HEADER START # # The contents of this file are subject to the terms of the # Common Development and Distribution License (the "License"). # You may not use this file except in compliance with the License. # # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE # or http://www.opensolaris.org/os/licensing. # See the License for the specific language governing permissions # and limitations under the License. # # When distributing Covered Code, include this CDDL HEADER in each # file and include the License file at usr/src/OPENSOLARIS.LICENSE. # If applicable, add the following below this CDDL HEADER, with the # fields enclosed by brackets "[]" replaced with your own identifying # information: Portions Copyright [yyyy] [name of copyright owner] # # CDDL HEADER END # # # Copyright 2006 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # BUILD32 = $(POUND_SIGN) include $(SRC)/cmd/sgs/Makefile.sub # # CDDL HEADER START # # The contents of this file are subject to the terms of the # Common Development and Distribution License (the "License"). # You may not use this file except in compliance with the License. # # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE # or http://www.opensolaris.org/os/licensing. # See the License for the specific language governing permissions # and limitations under the License. # # When distributing Covered Code, include this CDDL HEADER in each # file and include the License file at usr/src/OPENSOLARIS.LICENSE. # If applicable, add the following below this CDDL HEADER, with the # fields enclosed by brackets "[]" replaced with your own identifying # information: Portions Copyright [yyyy] [name of copyright owner] # # CDDL HEADER END # # # Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. # Copyright (c) 2018, Joyent, Inc. # Copyright 2019 OmniOS Community Edition (OmniOSce) Association. # Copyright 2024 Oxide Computer Company # PROG= elfdump include $(SRC)/cmd/Makefile.cmd include $(SRC)/cmd/sgs/Makefile.com include $(SRC)/common/hexdump/Makefile.com # Hammerhead: removed struct_layout_sparc.o and struct_layout_sparcv9.o (amd64-only) COMOBJ = main.o corenote.o \ dwarf.o struct_layout.o \ struct_layout_i386.o struct_layout_amd64.o COMOBJ32 = elfdump32.o fake_shdr32.o COMOBJ64 = elfdump64.o fake_shdr64.o SGSCOMMONOBJ = leb128.o BLTOBJ = msg.o EXTOBJ = $(HEXDUMP_OBJS) OBJS= $(BLTOBJ) $(COMOBJ) $(COMOBJ32) $(COMOBJ64) $(SGSCOMMONOBJ) \ $(EXTOBJ) MAPFILE= $(MAPFILE.NGB) MAPOPT= $(MAPFILE:%=-Wl,-M%) CPPFLAGS= -I. -I../common -I../../include -I../../include/$(MACH) \ -I$(SRC)/lib/libc/inc -I$(SRC)/uts/$(ARCH)/sys \ $(CPPFLAGS.master) -I$(ELFCAP) LDFLAGS += $(VERSREF) $(MAPOPT) '-R$$ORIGIN/../../lib/$(MACH64)' LDLIBS += $(ELFLIBDIR64) -lelf $(LDDBGLIBDIR64) -llddbg \ $(CONVLIBDIR64) -lconv NATIVE_LDFLAGS = $(LDASSERTS) $(BDIRECT) BLTDEFS = msg.h BLTDATA = msg.c BLTMESG = $(SGSMSGDIR)/elfdump BLTFILES = $(BLTDEFS) $(BLTDATA) $(BLTMESG) SGSMSGCOM = ../common/elfdump.msg SGSMSGTARG = $(SGSMSGCOM) SGSMSGALL = $(SGSMSGCOM) SGSMSGFLAGS += -h $(BLTDEFS) -d $(BLTDATA) -m $(BLTMESG) -n elfdump_msg SRCS = $(COMOBJ:%.o=../common/%.c) \ $(COMOBJ32:%32.o=../common/%.c) \ $(SGSCOMMONOBJ:%.o=$(SGSCOMMON)/%.c) $(BLTDATA) # Hammerhead: Suppress return-type warnings in legacy elfdump common code # The ELF printing functions use complex switch statements that GCC 14 # incorrectly flags as potentially missing return values CERRWARN += -Wno-return-type CLEANFILES += $(BLTFILES) gen_struct_layout # # CDDL HEADER START # # The contents of this file are subject to the terms of the # Common Development and Distribution License (the "License"). # You may not use this file except in compliance with the License. # # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE # or http://www.opensolaris.org/os/licensing. # See the License for the specific language governing permissions # and limitations under the License. # # When distributing Covered Code, include this CDDL HEADER in each # file and include the License file at usr/src/OPENSOLARIS.LICENSE. # If applicable, add the following below this CDDL HEADER, with the # fields enclosed by brackets "[]" replaced with your own identifying # information: Portions Copyright [yyyy] [name of copyright owner] # # CDDL HEADER END # # # Copyright 2008 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # # Copyright 2015 Nexenta Systems, Inc. All rights reserved. # Copyright 2019 OmniOS Community Edition (OmniOSce) Association. # %.o: ../common/%.c $(COMPILE.c) -o $@ $< $(POST_PROCESS_O) %32.o: ../common/%.c $(COMPILE.c) -o $@ $< $(POST_PROCESS_O) %64.o: ../common/%.c $(COMPILE.c) -D_ELF64 -o $@ $< $(POST_PROCESS_O) %.o: $(SGSCOMMON)/%.c $(COMPILE.c) -o $@ $< $(POST_PROCESS_O) # Hammerhead: Ensure message header is generated before compiling objects $(OBJS): $(BLTDEFS) all: $(PROG) $(PROG): $(OBJS) $(MAPFILE) check_struct_layout $(LINK.c) -o $@ $(OBJS) $(LDLIBS) $(POST_PROCESS) check_struct_layout: gen_struct_layout gen_layout_obj.o sed -e '/^#include /q' \ ../common/struct_layout_$(ARCH).c | sed -e '$$d' \ > struct_layout_$(ARCH).tmp ./gen_struct_layout gen_layout_obj.o $(ARCH) \ >> struct_layout_$(ARCH).tmp @diff -u struct_layout_$(ARCH).tmp \ ../common/struct_layout_$(ARCH).c ||\ { echo "Error: struct_layout_$(ARCH).c needs update!" ; exit 1; } touch $@ # We need CTF data in this object. gen_layout_obj.o : CFLAGS += $(CTF_FLAGS) gen_layout_obj.o : CFLAGS64 += $(CTF_FLAGS) gen_layout_obj.o : POST_PROCESS_O = $(CTFCONVERT_O) gen_struct_layout: ../common/gen_struct_layout.c $(NATIVECC) $(NATIVE_CFLAGS) -o $@ \ ../common/gen_struct_layout.c -lctf clean: $(RM) $(OBJS) $(CLEANFILES) gen_struct_layout \ check_struct_layout gen_layout_obj.o \ struct_layout_$(ARCH).tmp install: all $(ROOTPROG) $(ROOTCCSBINLINK) include $(SRC)/common/hexdump/Makefile.targ include $(SRC)/cmd/Makefile.targ # Derived source and header files (messaging). catalog: $(BLTMESG) chkmsg: $(SRCS) sh $(CHKMSG) $(CHKMSGFLAGS) $(SRCS) # Hammerhead: GNU Make grouped target syntax (&:) - was dmake + syntax $(BLTDEFS) $(BLTDATA) $(BLTMESG) &: $(SGSMSGALL) $(SGSMSG) $(SGSMSGFLAGS) $(SGSMSGALL) # # CDDL HEADER START # # The contents of this file are subject to the terms of the # Common Development and Distribution License (the "License"). # You may not use this file except in compliance with the License. # # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE # or http://www.opensolaris.org/os/licensing. # See the License for the specific language governing permissions # and limitations under the License. # # When distributing Covered Code, include this CDDL HEADER in each # file and include the License file at usr/src/OPENSOLARIS.LICENSE. # If applicable, add the following below this CDDL HEADER, with the # fields enclosed by brackets "[]" replaced with your own identifying # information: Portions Copyright [yyyy] [name of copyright owner] # # CDDL HEADER END # # # Copyright 2007 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # # Copyright 2019 OmniOS Community Edition (OmniOSce) Association. # include ../Makefile.com .KEEP_STATE: ARCH = amd64 include ../Makefile.targ include $(SRC)/Makefile.master.64 # Hammerhead: ROOTPROG64=ROOTPROG, ROOTCCSBINLINK64=ROOTCCSBINLINK (path flattening) # Removed duplicate 64-bit targets and ../../bin symlink (circular when /bin -> usr/bin) install: $(ROOTPROG) \ $(ROOTCCSBINLINK) /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #ifndef __ELFDUMP_H #define __ELFDUMP_H #include <_machelf.h> #include /* * Local include file for elfdump. */ #ifdef __cplusplus extern "C" { #endif /* * flags: This is a bitmask that controls elfdump's operations. There * are three categories of flag: * * SHOW - Specify categories of things in the ELF object to display. * CALC - Compute something based on the contents of the ELF object. * CTL - Control options specify general options that are not * specific to any specific part of the ELF object, but * which apply at a higher level. * * To simplify masking these categories, they are assigned bit ranges * as follows: * SHOW: Bottom 24-bits * CALC: Upper 2 bits of most significant byte * CTL: Lower 6 bits of most significant byte */ #define FLG_SHOW_DYNAMIC 0x00000001 #define FLG_SHOW_EHDR 0x00000002 #define FLG_SHOW_INTERP 0x00000004 #define FLG_SHOW_SHDR 0x00000008 #define FLG_SHOW_NOTE 0x00000010 #define FLG_SHOW_PHDR 0x00000020 #define FLG_SHOW_RELOC 0x00000040 #define FLG_SHOW_SYMBOLS 0x00000080 #define FLG_SHOW_VERSIONS 0x00000100 #define FLG_SHOW_HASH 0x00000200 #define FLG_SHOW_GOT 0x00000400 #define FLG_SHOW_SYMINFO 0x00000800 #define FLG_SHOW_MOVE 0x00001000 #define FLG_SHOW_GROUP 0x00002000 #define FLG_SHOW_CAP 0x00004000 #define FLG_SHOW_UNWIND 0x00008000 #define FLG_SHOW_SORT 0x00010000 #define FLG_CTL_LONGNAME 0x01000000 #define FLG_CTL_DEMANGLE 0x02000000 #define FLG_CTL_FAKESHDR 0x04000000 #define FLG_CTL_MATCH 0x08000000 #define FLG_CTL_OSABI 0x10000000 #define FLG_CALC_CHECKSUM 0x40000000 /* Bitmasks that isolate the parts of a flag value */ #define FLG_MASK_SHOW 0x00ffffff #define FLG_MASK_CTL 0x3f000000 #define FLG_MASK_CALC 0xc0000000 /* * Mask that selects the show flags that do not require the ELF * object to have a section header array. */ #define FLG_MASK_SHOW_NOSHDR (FLG_SHOW_EHDR | FLG_SHOW_PHDR) /* * Masks to select the flags that require the ELF object to * have a section header array, within each flag type. */ #define FLG_MASK_SHOW_SHDR (FLG_MASK_SHOW & ~FLG_MASK_SHOW_NOSHDR) #define FLG_MASK_CALC_SHDR FLG_CALC_CHECKSUM /* Size of buffer used for formatting an index into textual representation */ #define MAXNDXSIZE 10 typedef struct cache { Elf_Scn *c_scn; Shdr *c_shdr; Elf_Data *c_data; char *c_name; int c_ndx; /* Section index */ } Cache; typedef struct got_info { Word g_reltype; /* it will never happen, but */ /* support mixed relocations */ void *g_rel; const char *g_symname; } Got_info; extern const Cache cache_init; extern void failure(const char *, const char *); extern const char *demangle(const char *, uint_t); /* * Flags for the match() function: * MATCH_F_STRICT * A strict match requires an explicit match to * a user specified match (-I, -N, -T) option. A * non-strict match also succeeds if the match * list is empty. * * MATCH_F_PHDR * The match item is a program header. If this * flag is not set, the match item is a section * header. * * MATCH_F_NAME * The name parameter contains valid information. * * MATCH_F_NDX * The ndx argument contains valid information * * MATCH_F_TYPE * The type argument contains valid information */ typedef enum { MATCH_F_STRICT = 1, MATCH_F_PHDR = 2, MATCH_F_NAME = 4, MATCH_F_NDX = 8, MATCH_F_TYPE = 16 } match_flags_t; /* It is common for calls to match() to specify all three arguments */ #define MATCH_F_ALL (MATCH_F_NAME | MATCH_F_NDX | MATCH_F_TYPE) extern int match(match_flags_t, const char *, uint_t, uint_t); /* * Possible return values from corenote() */ typedef enum { CORENOTE_R_OK = 0, /* Note data successfully displayed */ CORENOTE_R_OK_DUMP = 1, /* Note OK, but not handled. Display Hex dump */ CORENOTE_R_BADDATA = 2, /* Note data truncated or otherwise malformed */ CORENOTE_R_BADARCH = 3, /* core file note code does not contain */ /* support for given architecture */ CORENOTE_R_BADTYPE = 4 /* Unknown note type */ } corenote_ret_t; /* * Define various elfdump() functions into their 32-bit and 64-bit variants. */ #if defined(_ELF64) #define cap cap64 #define checksum checksum64 #define dynamic dynamic64 #define fake_shdr_cache fake_shdr_cache64 #define fake_shdr_cache_free fake_shdr_cache_free64 #define got got64 #define group group64 #define hash hash64 #define interp interp64 #define move move64 #define note note64 #define note_entry note_entry64 #define regular regular64 #define reloc reloc64 #define sections sections64 #define string string64 #define symbols symbols64 #define syminfo syminfo64 #define symlookup symlookup64 #define unwind unwind64 #define versions versions64 #define version_def version_def64 #define version_need version_need64 #else #define cap cap32 #define checksum checksum32 #define dynamic dynamic32 #define fake_shdr_cache fake_shdr_cache32 #define fake_shdr_cache_free fake_shdr_cache_free32 #define got got32 #define group group32 #define hash hash32 #define interp interp32 #define move move32 #define note note32 #define note_entry note_entry32 #define regular regular32 #define reloc reloc32 #define sections sections32 #define string string32 #define symbols symbols32 #define syminfo syminfo32 #define symlookup symlookup32 #define unwind unwind32 #define versions versions32 #define version_def version_def32 #define version_need version_need32 #endif extern corenote_ret_t corenote(Half, int, Word, const char *, Word); extern void dump_eh_frame(const char *, char *, uchar_t *, size_t, uint64_t, Half e_machine, uchar_t *e_ident, uint64_t gotaddr); extern void dump_hex_bytes(const void *, size_t, int, int, int); extern int fake_shdr_cache32(const char *, int, Elf *, Elf32_Ehdr *, Cache **, size_t *); extern int fake_shdr_cache64(const char *, int, Elf *, Elf64_Ehdr *, Cache **, size_t *); extern void fake_shdr_cache_free32(Cache *, size_t); extern void fake_shdr_cache_free64(Cache *, size_t); extern int regular32(const char *, int, Elf *, uint_t, const char *, int, uchar_t); extern int regular64(const char *, int, Elf *, uint_t, const char *, int, uchar_t); #ifdef __cplusplus } #endif #endif /* __ELFDUMP_H */ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. * Copyright (c) 2018, Joyent, Inc. * Copyright 2024 Oxide Computer Company */ #include #include #include #include #include #include #include #include #include <_elfdump.h> #include #include #include #include /* * This module contains the code that displays data from the note * sections found in illumos core files. The format of these * note sections are described in the core(5) manpage. */ /* * Much of the code in this file uses the "%*s" format to set * the left margin indentation. This macro combines the indent * integer argument and the NULL string that follows it. */ #define INDENT state->ns_indent, MSG_ORIG(MSG_STR_EMPTY) /* * Indent unit, used for each nesting */ #define INDENT_STEP 4 /* * The PRINT_ macros are convenience wrappers on print_num(), * print_subtype(), and print_strbuf(). They reduce code * clutter by hiding the boilerplate arguments. * * Assumptions: * - A variable named "layout" exists in the compilation * environment, referencing the layout information for the * current type. * - The variable "state" references the current note state. */ #define PRINT_DEC(_title, _field) \ print_num(state, _title, &layout->_field, SL_FMT_NUM_DEC) #define PRINT_DEC_2UP(_title1, _field1, _title2, _field2) \ print_num_2up(state, _title1, &layout->_field1, SL_FMT_NUM_DEC, \ _title2, &layout->_field2, SL_FMT_NUM_DEC) #define PRINT_HEX(_title, _field) \ print_num(state, _title, &layout->_field, SL_FMT_NUM_HEX) #define PRINT_HEX_2UP(_title1, _field1, _title2, _field2) \ print_num_2up(state, _title1, &layout->_field1, SL_FMT_NUM_HEX, \ _title2, &layout->_field2, SL_FMT_NUM_HEX) #define PRINT_ZHEX(_title, _field) \ print_num(state, _title, &layout->_field, SL_FMT_NUM_ZHEX) #define PRINT_ZHEX_2UP(_title1, _field1, _title2, _field2) \ print_num_2up(state, _title1, &layout->_field1, SL_FMT_NUM_ZHEX, \ _title2, &layout->_field2, SL_FMT_NUM_ZHEX) #define PRINT_SUBTYPE(_title, _field, _func) \ print_subtype(state, _title, &layout->_field, _func) #define PRINT_STRBUF(_title, _field) \ print_strbuf(state, _title, &layout->_field) /* * Structure used to maintain state data for a core note, or a subregion * (sub-struct) of a core note. These values would otherwise need to be * passed to nearly every routine. */ typedef struct { Half ns_mach; /* ELF machine type of core file */ const sl_arch_layout_t *ns_arch; /* structure layout def for mach */ int ns_swap; /* True if byte swapping is needed */ int ns_indent; /* Left margin indentation */ int ns_vcol; /* Column where value starts */ int ns_t2col; /* Column where 2up title starts */ int ns_v2col; /* Column where 2up value starts */ const char *ns_data; /* Pointer to struct data area */ Word ns_len; /* Length of struct data area */ } note_state_t; /* * Standard signature for a dump function used to process a note * or a sub-structure within a note. */ typedef void (* dump_func_t)(note_state_t *state, const char *title); /* * Some core notes contain string buffers of fixed size * that are expected to contain NULL terminated strings. * If the NULL is there, we can print these strings directly. * However, the potential exists for a corrupt file to have * a non-terminated buffer. This routine examines the given * string, and if the string is terminated, the string itself * is returned. Otherwise, it is copied to a static buffer, * and a pointer to the buffer is returned. */ static const char * safe_str(const char *str, size_t n) { static char buf[2048]; size_t i, used; if (n == 0) return (MSG_ORIG(MSG_STR_EMPTY)); /* * If the string is terminated and doesn't need escaping, we can return * it as is. */ for (i = 0; i < n; i++) { if (str[i] == '\0') return (str); if (!isascii(str[i]) || !isprint(str[i])) { break; } } for (i = 0, used = 0; i < n; i++) { if (str[i] == '\0') { if (used + 1 > sizeof (buf)) break; buf[used++] = str[i]; return (buf); } else if (isascii(str[i]) && isprint(str[i])) { if (used + 1 > sizeof (buf)) break; buf[used++] = str[i]; } else { size_t len = snprintf(NULL, 0, "\\x%02x", str[i]); if (used + len > sizeof (buf)) break; (void) snprintf(buf + used, sizeof (buf) - used, "\\x%02x", str[i]); used += len; } } if (i == n && used < sizeof (buf)) { buf[used] = '\0'; return (buf); } /* * If we got here, we would have overflowed. Figure out where we need to * start and truncate. */ used = MIN(used, sizeof (buf) - 4); buf[used++] = '.'; buf[used++] = '.'; buf[used++] = '.'; buf[used++] = '\0'; return (buf); } /* * Convenience wrappers on top of the corresponding sl_XXX() functions. */ static Word extract_as_word(note_state_t *state, const sl_field_t *fdesc) { return (sl_extract_as_word(state->ns_data, state->ns_swap, fdesc)); } static Lword extract_as_lword(note_state_t *state, const sl_field_t *fdesc) { return (sl_extract_as_lword(state->ns_data, state->ns_swap, fdesc)); } static int extract_as_sword(note_state_t *state, const sl_field_t *fdesc) { return (sl_extract_as_sword(state->ns_data, state->ns_swap, fdesc)); } static const char * fmt_num(note_state_t *state, const sl_field_t *fdesc, sl_fmt_num_t fmt_type, sl_fmtbuf_t buf) { return (sl_fmt_num(state->ns_data, state->ns_swap, fdesc, fmt_type, buf)); } /* * Return true of the data for the specified field is available. */ inline static int data_present(note_state_t *state, const sl_field_t *fdesc) { return ((fdesc->slf_offset + fdesc->slf_eltlen) <= state->ns_len); } /* * indent_enter/exit are used to start/end output for a subitem. * On entry, a title is output, and the indentation level is raised * by one unit. On exit, the indentation level is restored to its * previous value. */ static void indent_enter(note_state_t *state, const char *title, const sl_field_t *first_fdesc) { /* * If the first field offset and extent fall past the end of the * available data, then return without printing a title. That note * is from an older core file that doesn't have all the fields * that we know about. */ if (data_present(state, first_fdesc)) dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_TITLE), INDENT, title); state->ns_indent += INDENT_STEP; } static void indent_exit(note_state_t *state) { state->ns_indent -= INDENT_STEP; } /* * print_num outputs a field on one line, in the format: * * title: value */ static void print_num(note_state_t *state, const char *title, const sl_field_t *fdesc, sl_fmt_num_t fmt_type) { sl_fmtbuf_t buf; /* * If the field offset and extent fall past the end of the * available data, then return without doing anything. That note * is from an older core file that doesn't have all the fields * that we know about. */ if (!data_present(state, fdesc)) return; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), INDENT, state->ns_vcol - state->ns_indent, title, fmt_num(state, fdesc, fmt_type, buf)); } /* * print_num_2up outputs two fields on one line, in the format: * * title1: value1 title2: value2 */ static void print_num_2up(note_state_t *state, const char *title1, const sl_field_t *fdesc1, sl_fmt_num_t fmt_type1, const char *title2, const sl_field_t *fdesc2, sl_fmt_num_t fmt_type2) { sl_fmtbuf_t buf1, buf2; /* * If the field offset and extent fall past the end of the * available data, then return without doing anything. That note * is from an older core file that doesn't have all the fields * that we know about. */ if (!(data_present(state, fdesc1) && data_present(state, fdesc2))) return; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, state->ns_vcol - state->ns_indent, title1, state->ns_t2col - state->ns_vcol, fmt_num(state, fdesc1, fmt_type1, buf1), state->ns_v2col - state->ns_t2col, title2, fmt_num(state, fdesc2, fmt_type2, buf2)); } /* * print_strbuf outputs a fixed sized character buffer field * on one line, in the format: * * title: value */ static void print_strbuf(note_state_t *state, const char *title, const sl_field_t *fdesc) { Word n; /* * If we are past the end of the data area, then return * without doing anything. That note is from an older core * file that doesn't have all the fields that we know about. * * Note that we are willing to accept a partial buffer, * so we don't use data_present() for this test. */ if (fdesc->slf_offset >= state->ns_len) return; /* * We expect the full buffer to be present, but if there * is less than that, we will still proceed. The use of safe_str() * protects us from the effect of printing garbage data. */ n = state->ns_len - fdesc->slf_offset; if (n > fdesc->slf_nelts) n = fdesc->slf_nelts; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), INDENT, state->ns_vcol - state->ns_indent, title, safe_str(fdesc->slf_offset + state->ns_data, n)); } /* * print_str outputs an arbitrary string value item * on one line, in the format: * * title: str */ static void print_str(note_state_t *state, const char *title, const char *str) { dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), INDENT, state->ns_vcol - state->ns_indent, title, str); } /* * Used when one dump function needs to call another dump function * in order to display a subitem. This routine constructs a state * block for the sub-region, and then calls the dump function with it. * This limits the amount of data visible to the sub-function to that * for the sub-item. */ static void print_subtype(note_state_t *state, const char *title, const sl_field_t *fdesc, dump_func_t dump_func) { note_state_t sub_state; /* * If there is no data for the sub-item, return immediately. * Partial data is left to the dump function to handle, * as that can be a sign of an older core file with less data, * which can still be interpreted. */ if (fdesc->slf_offset >= state->ns_len) return; /* * Construct a state block that reflects the sub-item */ sub_state = *state; sub_state.ns_data += fdesc->slf_offset; sub_state.ns_len -= fdesc->slf_offset; if (sub_state.ns_len > fdesc->slf_eltlen) sub_state.ns_len = fdesc->slf_eltlen; (* dump_func)(&sub_state, title); } /* * Output a sequence of array elements, giving each * element an index, in the format: * * [ndx] value * * entry: * state - Current state * base_desc - Field descriptor for 1st element of array * nelts - # of array elements to display * check_nelts - If True (1), nelts is clipped to fdesc->slf_nelts. * If False (1), nelts is not clipped. * title - Name of array */ static void print_array(note_state_t *state, const sl_field_t *base_desc, sl_fmt_num_t fmt_type, int nelts, int check_nelts, const char *title) { char index1[MAXNDXSIZE], index2[MAXNDXSIZE]; int i; sl_field_t fdesc1, fdesc2; if (check_nelts && (check_nelts > base_desc->slf_nelts)) nelts = base_desc->slf_nelts; if (nelts == 0) return; indent_enter(state, title, base_desc); fdesc1 = fdesc2 = *base_desc; for (i = 0; i < nelts; ) { if (i == (nelts - 1)) { /* One final value is left */ if (!data_present(state, &fdesc1)) break; (void) snprintf(index1, sizeof (index1), MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(i)); print_num(state, index1, &fdesc1, fmt_type); fdesc1.slf_offset += fdesc1.slf_eltlen; i++; continue; } /* There are at least 2 items left. Show 2 up. */ fdesc2.slf_offset = fdesc1.slf_offset + fdesc1.slf_eltlen; if (!(data_present(state, &fdesc1) && data_present(state, &fdesc2))) break; (void) snprintf(index1, sizeof (index1), MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(i)); (void) snprintf(index2, sizeof (index2), MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(i + 1)); print_num_2up(state, index1, &fdesc1, fmt_type, index2, &fdesc2, fmt_type); fdesc1.slf_offset += 2 * fdesc1.slf_eltlen; i += 2; } indent_exit(state); } /* * Output information from auxv_t structure. */ static void dump_auxv(note_state_t *state, const char *title) { const sl_auxv_layout_t *layout = state->ns_arch->auxv; union { Conv_cap_val_hw1_buf_t hw1; Conv_cap_val_hw2_buf_t hw2; Conv_cap_val_hw3_buf_t hw3; Conv_cnote_auxv_af_buf_t auxv_af; Conv_ehdr_flags_buf_t ehdr_flags; Conv_secflags_buf_t secflags; Conv_inv_buf_t inv; } conv_buf; sl_fmtbuf_t buf; int ndx, ndx_start; Word sizeof_auxv; sizeof_auxv = layout->sizeof_struct.slf_eltlen; indent_enter(state, title, &layout->sizeof_struct); /* * Immediate indent_exit() restores the indent level to * that of the title. We include indentation as part of * the index string, which is right justified, and don't * want the usual indentation spacing. */ indent_exit(state); ndx = 0; while (state->ns_len > sizeof_auxv) { char index[(MAXNDXSIZE * 2) + 1]; sl_fmt_num_t num_fmt = SL_FMT_NUM_ZHEX; const char *vstr = NULL; Word w; int type; sl_field_t a_type_next; type = extract_as_word(state, &layout->a_type); ndx_start = ndx; switch (type) { case AT_NULL: a_type_next = layout->a_type; a_type_next.slf_offset += sizeof_auxv; while ((state->ns_len - sizeof_auxv) >= sizeof_auxv) { type = extract_as_word(state, &a_type_next); if (type != AT_NULL) break; ndx++; state->ns_data += sizeof_auxv; state->ns_len -= sizeof_auxv; } num_fmt = SL_FMT_NUM_HEX; break; case AT_IGNORE: case AT_SUN_IFLUSH: num_fmt = SL_FMT_NUM_HEX; break; case AT_EXECFD: case AT_PHENT: case AT_PHNUM: case AT_PAGESZ: case AT_SUN_UID: case AT_SUN_RUID: case AT_SUN_GID: case AT_SUN_RGID: case AT_SUN_LPAGESZ: case AT_SUN_FPSIZE: case AT_SUN_FPTYPE: num_fmt = SL_FMT_NUM_DEC; break; case AT_FLAGS: /* processor flags */ w = extract_as_word(state, &layout->a_val); vstr = conv_ehdr_flags(state->ns_mach, w, 0, &conv_buf.ehdr_flags); break; case AT_SUN_HWCAP: w = extract_as_word(state, &layout->a_val); vstr = conv_cap_val_hw1(w, state->ns_mach, 0, &conv_buf.hw1); /* * conv_cap_val_hw1() produces output like: * * 0xfff [ flg1 flg2 0xff] * * where the first hex value is the complete value, * and the second is the leftover bits. We only * want the part in brackets, and failing that, * would rather fall back to formatting the full * value ourselves. */ while ((*vstr != '\0') && (*vstr != '[')) vstr++; if (*vstr != '[') vstr = NULL; num_fmt = SL_FMT_NUM_HEX; break; case AT_SUN_HWCAP2: w = extract_as_word(state, &layout->a_val); vstr = conv_cap_val_hw2(w, state->ns_mach, 0, &conv_buf.hw2); /* * conv_cap_val_hw2() produces output like: * * 0xfff [ flg1 flg2 0xff] * * where the first hex value is the complete value, * and the second is the leftover bits. We only * want the part in brackets, and failing that, * would rather fall back to formatting the full * value ourselves. */ while ((*vstr != '\0') && (*vstr != '[')) vstr++; if (*vstr != '[') vstr = NULL; num_fmt = SL_FMT_NUM_HEX; break; case AT_SUN_HWCAP3: w = extract_as_word(state, &layout->a_val); vstr = conv_cap_val_hw3(w, state->ns_mach, 0, &conv_buf.hw3); /* * conv_cap_val_hw3() produces output like: * * 0xfff [ flg1 flg2 0xff] * * where the first hex value is the complete value, * and the second is the leftover bits. We only * want the part in brackets, and failing that, * would rather fall back to formatting the full * value ourselves. */ while ((*vstr != '\0') && (*vstr != '[')) vstr++; if (*vstr != '[') vstr = NULL; num_fmt = SL_FMT_NUM_HEX; break; case AT_SUN_AUXFLAGS: w = extract_as_word(state, &layout->a_val); vstr = conv_cnote_auxv_af(w, 0, &conv_buf.auxv_af); num_fmt = SL_FMT_NUM_HEX; break; } if (ndx == ndx_start) (void) snprintf(index, sizeof (index), MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(ndx)); else (void) snprintf(index, sizeof (index), MSG_ORIG(MSG_FMT_INDEXRNG), EC_WORD(ndx_start), EC_WORD(ndx)); if (vstr == NULL) vstr = fmt_num(state, &layout->a_val, num_fmt, buf); dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_AUXVLINE), INDENT, index, state->ns_vcol - state->ns_indent, conv_cnote_auxv_type(type, CONV_FMT_DECIMAL, &conv_buf.inv), vstr); state->ns_data += sizeof_auxv; state->ns_len -= sizeof_auxv; ndx++; } } /* * Output information from fltset_t structure. */ static void dump_fltset(note_state_t *state, const char *title) { #define NELTS 4 const sl_fltset_layout_t *layout = state->ns_arch->fltset; Conv_cnote_fltset_buf_t buf; sl_field_t fdesc; uint32_t mask[NELTS]; int i, nelts; if (!data_present(state, &layout->sizeof_struct)) return; fdesc = layout->word; nelts = fdesc.slf_nelts; if (nelts > NELTS) /* Type has grown? Show what we understand */ nelts = NELTS; for (i = 0; i < nelts; i++) { mask[i] = extract_as_word(state, &fdesc); fdesc.slf_offset += fdesc.slf_eltlen; } print_str(state, title, conv_cnote_fltset(mask, nelts, 0, &buf)); #undef NELTS } /* * Output information from sigset_t structure. */ static void dump_sigset(note_state_t *state, const char *title) { #define NELTS 4 const sl_sigset_layout_t *layout = state->ns_arch->sigset; Conv_cnote_sigset_buf_t buf; sl_field_t fdesc; uint32_t mask[NELTS]; int i, nelts; if (!data_present(state, &layout->sizeof_struct)) return; fdesc = layout->sigbits; nelts = fdesc.slf_nelts; if (nelts > NELTS) /* Type has grown? Show what we understand */ nelts = NELTS; for (i = 0; i < nelts; i++) { mask[i] = extract_as_word(state, &fdesc); fdesc.slf_offset += fdesc.slf_eltlen; } print_str(state, title, conv_cnote_sigset(mask, nelts, 0, &buf)); #undef NELTS } /* * Output information from sigaction structure. */ static void dump_sigaction(note_state_t *state, const char *title) { const sl_sigaction_layout_t *layout = state->ns_arch->sigaction; Conv_cnote_sa_flags_buf_t conv_buf; Word w; indent_enter(state, title, &layout->sa_flags); if (data_present(state, &layout->sa_flags)) { w = extract_as_word(state, &layout->sa_flags); print_str(state, MSG_ORIG(MSG_CNOTE_T_SA_FLAGS), conv_cnote_sa_flags(w, 0, &conv_buf)); } PRINT_ZHEX_2UP(MSG_ORIG(MSG_CNOTE_T_SA_HANDLER), sa_hand, MSG_ORIG(MSG_CNOTE_T_SA_SIGACTION), sa_sigact); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_SA_MASK), sa_mask, dump_sigset); indent_exit(state); } /* * Output information from siginfo structure. */ static void dump_siginfo(note_state_t *state, const char *title) { const sl_siginfo_layout_t *layout = state->ns_arch->siginfo; Conv_inv_buf_t inv_buf; Word w; int v_si_code, v_si_signo; if (!data_present(state, &layout->sizeof_struct)) return; indent_enter(state, title, &layout->f_si_signo); v_si_signo = extract_as_sword(state, &layout->f_si_signo); print_str(state, MSG_ORIG(MSG_CNOTE_T_SI_SIGNO), conv_cnote_signal(v_si_signo, CONV_FMT_DECIMAL, &inv_buf)); w = extract_as_word(state, &layout->f_si_errno); print_str(state, MSG_ORIG(MSG_CNOTE_T_SI_ERRNO), conv_cnote_errno(w, CONV_FMT_DECIMAL, &inv_buf)); v_si_code = extract_as_sword(state, &layout->f_si_code); print_str(state, MSG_ORIG(MSG_CNOTE_T_SI_CODE), conv_cnote_si_code(state->ns_mach, v_si_signo, v_si_code, CONV_FMT_DECIMAL, &inv_buf)); if ((v_si_signo == 0) || (v_si_code == SI_NOINFO)) { indent_exit(state); return; } /* User generated signals have (si_code <= 0) */ if (v_si_code <= 0) { PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_PID), f_si_pid); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_UID), f_si_uid); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_CTID), f_si_ctid); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_ZONEID), f_si_zoneid); switch (v_si_code) { case SI_QUEUE: case SI_TIMER: case SI_ASYNCIO: case SI_MESGQ: indent_enter(state, MSG_ORIG(MSG_CNOTE_T_SI_VALUE), &layout->f_si_value_int); PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_SIVAL_INT), f_si_value_int); PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_SIVAL_PTR), f_si_value_ptr); indent_exit(state); break; } indent_exit(state); return; } /* * Remaining cases are kernel generated signals. Output any * signal or code specific information. */ if (v_si_code == SI_RCTL) PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_SI_ENTITY), f_si_entity); switch (v_si_signo) { case SIGILL: case SIGFPE: case SIGSEGV: case SIGBUS: PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_SI_ADDR), f_si_addr); break; case SIGCHLD: PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_PID), f_si_pid); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_STATUS), f_si_status); break; case SIGPOLL: PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_BAND), f_si_band); break; } indent_exit(state); } /* * Output information from stack_t structure. */ static void dump_stack(note_state_t *state, const char *title) { const sl_stack_layout_t *layout = state->ns_arch->stack; Conv_cnote_ss_flags_buf_t conv_buf; Word w; indent_enter(state, title, &layout->ss_size); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_SS_SP), &layout->ss_sp, SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_SS_SIZE), &layout->ss_size, SL_FMT_NUM_HEX); if (data_present(state, &layout->ss_flags)) { w = extract_as_word(state, &layout->ss_flags); print_str(state, MSG_ORIG(MSG_CNOTE_T_SS_FLAGS), conv_cnote_ss_flags(w, 0, &conv_buf)); } indent_exit(state); } /* * Output information from sysset_t structure. */ static void dump_sysset(note_state_t *state, const char *title) { #define NELTS 16 const sl_sysset_layout_t *layout = state->ns_arch->sysset; Conv_cnote_sysset_buf_t buf; sl_field_t fdesc; uint32_t mask[NELTS]; int i, nelts; if (!data_present(state, &layout->sizeof_struct)) return; fdesc = layout->word; nelts = fdesc.slf_nelts; if (nelts > NELTS) /* Type has grown? Show what we understand */ nelts = NELTS; for (i = 0; i < nelts; i++) { mask[i] = extract_as_word(state, &fdesc); fdesc.slf_offset += fdesc.slf_eltlen; } print_str(state, title, conv_cnote_sysset(mask, nelts, 0, &buf)); #undef NELTS } /* * Output information from timestruc_t structure. */ static void dump_timestruc(note_state_t *state, const char *title) { const sl_timestruc_layout_t *layout = state->ns_arch->timestruc; indent_enter(state, title, &layout->tv_sec); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_TV_SEC), tv_sec, MSG_ORIG(MSG_CNOTE_T_TV_NSEC), tv_nsec); indent_exit(state); } /* * Output information from prsecflags_t structure. */ static void dump_secflags(note_state_t *state, const char *title) { const sl_prsecflags_layout_t *layout = state->ns_arch->prsecflags; Conv_secflags_buf_t inv; Lword lw; Word w; indent_enter(state, title, &layout->pr_version); w = extract_as_word(state, &layout->pr_version); if (w != PRSECFLAGS_VERSION_1) { PRINT_DEC(MSG_INTL(MSG_NOTE_BAD_SECFLAGS_VER), pr_version); dump_hex_bytes(state->ns_data, state->ns_len, state->ns_indent, 4, 3); } else { PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_VERSION), pr_version); lw = extract_as_lword(state, &layout->pr_effective); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_EFFECTIVE), conv_prsecflags(lw, 0, &inv)); lw = extract_as_lword(state, &layout->pr_inherit); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_INHERIT), conv_prsecflags(lw, 0, &inv)); lw = extract_as_lword(state, &layout->pr_lower); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_LOWER), conv_prsecflags(lw, 0, &inv)); lw = extract_as_lword(state, &layout->pr_upper); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_UPPER), conv_prsecflags(lw, 0, &inv)); } indent_exit(state); } /* * Output information from utsname structure. */ static void dump_utsname(note_state_t *state, const char *title) { const sl_utsname_layout_t *layout = state->ns_arch->utsname; indent_enter(state, title, &layout->sysname); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_SYSNAME), sysname); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_NODENAME), nodename); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_RELEASE), release); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_VERSION), version); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_MACHINE), machine); indent_exit(state); } /* * Dump register contents */ static void dump_prgregset(note_state_t *state, const char *title) { sl_field_t fdesc1, fdesc2; sl_fmtbuf_t buf1, buf2; Conv_inv_buf_t inv_buf1, inv_buf2; Word w; fdesc1 = fdesc2 = state->ns_arch->prgregset->elt0; indent_enter(state, title, &fdesc1); for (w = 0; w < fdesc1.slf_nelts; ) { if (w == (fdesc1.slf_nelts - 1)) { /* One last register is left */ if (!data_present(state, &fdesc1)) break; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), INDENT, state->ns_vcol - state->ns_indent, conv_cnote_pr_regname(state->ns_mach, w, CONV_FMT_DECIMAL, &inv_buf1), fmt_num(state, &fdesc1, SL_FMT_NUM_ZHEX, buf1)); fdesc1.slf_offset += fdesc1.slf_eltlen; w++; continue; } /* There are at least 2 more registers left. Show 2 up */ fdesc2.slf_offset = fdesc1.slf_offset + fdesc1.slf_eltlen; if (!(data_present(state, &fdesc1) && data_present(state, &fdesc2))) break; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, state->ns_vcol - state->ns_indent, conv_cnote_pr_regname(state->ns_mach, w, CONV_FMT_DECIMAL, &inv_buf1), state->ns_t2col - state->ns_vcol, fmt_num(state, &fdesc1, SL_FMT_NUM_ZHEX, buf1), state->ns_v2col - state->ns_t2col, conv_cnote_pr_regname(state->ns_mach, w + 1, CONV_FMT_DECIMAL, &inv_buf2), fmt_num(state, &fdesc2, SL_FMT_NUM_ZHEX, buf2)); fdesc1.slf_offset += 2 * fdesc1.slf_eltlen; w += 2; } indent_exit(state); } /* * Output information from lwpstatus_t structure. */ static void dump_lwpstatus(note_state_t *state, const char *title) { const sl_lwpstatus_layout_t *layout = state->ns_arch->lwpstatus; Word w, w2; int32_t i; union { Conv_inv_buf_t inv; Conv_cnote_pr_flags_buf_t flags; } conv_buf; indent_enter(state, title, &layout->pr_flags); if (data_present(state, &layout->pr_flags)) { w = extract_as_word(state, &layout->pr_flags); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAGS), conv_cnote_pr_flags(w, 0, &conv_buf.flags)); } PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_LWPID), pr_lwpid); if (data_present(state, &layout->pr_why)) { w = extract_as_word(state, &layout->pr_why); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_WHY), conv_cnote_pr_why(w, 0, &conv_buf.inv)); if (data_present(state, &layout->pr_what)) { w2 = extract_as_word(state, &layout->pr_what); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_WHAT), conv_cnote_pr_what(w, w2, 0, &conv_buf.inv)); } } if (data_present(state, &layout->pr_cursig)) { w = extract_as_word(state, &layout->pr_cursig); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_CURSIG), conv_cnote_signal(w, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_INFO), pr_info, dump_siginfo); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWPPEND), pr_lwppend, dump_sigset); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWPHOLD), pr_lwphold, dump_sigset); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_ACTION), pr_action, dump_sigaction); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_ALTSTACK), pr_altstack, dump_stack); PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_PR_OLDCONTEXT), pr_oldcontext); if (data_present(state, &layout->pr_syscall)) { w = extract_as_word(state, &layout->pr_syscall); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_SYSCALL), conv_cnote_syscall(w, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NSYSARG), pr_nsysarg); if (data_present(state, &layout->pr_errno)) { w = extract_as_word(state, &layout->pr_errno); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_ERRNO), conv_cnote_errno(w, CONV_FMT_DECIMAL, &conv_buf.inv)); } if (data_present(state, &layout->pr_nsysarg)) { w2 = extract_as_word(state, &layout->pr_nsysarg); print_array(state, &layout->pr_sysarg, SL_FMT_NUM_ZHEX, w2, 1, MSG_ORIG(MSG_CNOTE_T_PR_SYSARG)); } PRINT_HEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_RVAL1), pr_rval1, MSG_ORIG(MSG_CNOTE_T_PR_RVAL2), pr_rval2); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_CLNAME), pr_clname); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_TSTAMP), pr_tstamp, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_UTIME), pr_utime, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_STIME), pr_stime, dump_timestruc); if (data_present(state, &layout->pr_errpriv)) { i = extract_as_sword(state, &layout->pr_errpriv); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_ERRPRIV), conv_cnote_priv(i, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_ZHEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_USTACK), pr_ustack, MSG_ORIG(MSG_CNOTE_T_PR_INSTR), pr_instr); /* * In order to line up all the values in a single column, * we would have to set vcol to a very high value, which results * in ugly looking output that runs off column 80. So, we use * two levels of vcol, one for the contents so far, and a * higher one for the pr_reg sub-struct. */ state->ns_vcol += 3; state->ns_t2col += 3; state->ns_v2col += 2; PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_REG), pr_reg, dump_prgregset); state->ns_vcol -= 3; state->ns_t2col -= 3; state->ns_v2col -= 2; /* * The floating point register state is complex, and highly * platform dependent. For now, we simply display it as * a hex dump. This can be replaced if better information * is required. */ if (data_present(state, &layout->pr_fpreg)) { indent_enter(state, MSG_ORIG(MSG_CNOTE_T_PR_FPREG), &layout->pr_fpreg); dump_hex_bytes(layout->pr_fpreg.slf_offset + state->ns_data, layout->pr_fpreg.slf_eltlen, state->ns_indent, 4, 3); indent_exit(state); } indent_exit(state); } /* * Output information from pstatus_t structure. */ static void dump_pstatus(note_state_t *state, const char *title) { const sl_pstatus_layout_t *layout = state->ns_arch->pstatus; Word w; union { Conv_inv_buf_t inv; Conv_cnote_pr_flags_buf_t flags; } conv_buf; indent_enter(state, title, &layout->pr_flags); if (data_present(state, &layout->pr_flags)) { w = extract_as_word(state, &layout->pr_flags); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAGS), conv_cnote_pr_flags(w, 0, &conv_buf.flags)); } PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NLWP), pr_nlwp); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PID), pr_pid, MSG_ORIG(MSG_CNOTE_T_PR_PPID), pr_ppid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PGID), pr_pgid, MSG_ORIG(MSG_CNOTE_T_PR_SID), pr_sid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ASLWPID), pr_aslwpid, MSG_ORIG(MSG_CNOTE_T_PR_AGENTID), pr_agentid); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SIGPEND), pr_sigpend, dump_sigset); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_BRKBASE), &layout->pr_brkbase, SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_BRKSIZE), &layout->pr_brksize, SL_FMT_NUM_HEX); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_STKBASE), &layout->pr_stkbase, SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_STKSIZE), &layout->pr_stksize, SL_FMT_NUM_HEX); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_UTIME), pr_utime, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_STIME), pr_stime, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CUTIME), pr_cutime, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CSTIME), pr_cstime, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SIGTRACE), pr_sigtrace, dump_sigset); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_FLTTRACE), pr_flttrace, dump_fltset); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SYSENTRY), pr_sysentry, dump_sysset); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SYSEXIT), pr_sysexit, dump_sysset); if (data_present(state, &layout->pr_dmodel)) { w = extract_as_word(state, &layout->pr_dmodel); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_DMODEL), conv_cnote_pr_dmodel(w, 0, &conv_buf.inv)); } PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_TASKID), pr_taskid, MSG_ORIG(MSG_CNOTE_T_PR_PROJID), pr_projid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_NZOMB), pr_nzomb, MSG_ORIG(MSG_CNOTE_T_PR_ZONEID), pr_zoneid); /* * In order to line up all the values in a single column, * we would have to set vcol to a very high value, which results * in ugly looking output that runs off column 80. So, we use * two levels of vcol, one for the contents so far, and a * higher one for the pr_lwp sub-struct. */ state->ns_vcol += 5; state->ns_t2col += 5; state->ns_v2col += 5; PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWP), pr_lwp, dump_lwpstatus); state->ns_vcol -= 5; state->ns_t2col -= 5; state->ns_v2col -= 5; indent_exit(state); } /* * Output information from prstatus_t () structure. */ static void dump_prstatus(note_state_t *state, const char *title) { const sl_prstatus_layout_t *layout = state->ns_arch->prstatus; Word w, w2; int i; union { Conv_inv_buf_t inv; Conv_cnote_old_pr_flags_buf_t flags; } conv_buf; indent_enter(state, title, &layout->pr_flags); if (data_present(state, &layout->pr_flags)) { w = extract_as_word(state, &layout->pr_flags); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAGS), conv_cnote_old_pr_flags(w, 0, &conv_buf.flags)); } if (data_present(state, &layout->pr_why)) { w = extract_as_word(state, &layout->pr_why); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_WHY), conv_cnote_pr_why(w, 0, &conv_buf.inv)); if (data_present(state, &layout->pr_what)) { w2 = extract_as_word(state, &layout->pr_what); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_WHAT), conv_cnote_pr_what(w, w2, 0, &conv_buf.inv)); } } PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_INFO), pr_info, dump_siginfo); if (data_present(state, &layout->pr_cursig)) { w = extract_as_word(state, &layout->pr_cursig); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_CURSIG), conv_cnote_signal(w, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NLWP), pr_nlwp); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SIGPEND), pr_sigpend, dump_sigset); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SIGHOLD), pr_sighold, dump_sigset); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_ALTSTACK), pr_altstack, dump_stack); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_ACTION), pr_action, dump_sigaction); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PID), pr_pid, MSG_ORIG(MSG_CNOTE_T_PR_PPID), pr_ppid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PGRP), pr_pgrp, MSG_ORIG(MSG_CNOTE_T_PR_SID), pr_sid); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_UTIME), pr_utime, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_STIME), pr_stime, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CUTIME), pr_cutime, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CSTIME), pr_cstime, dump_timestruc); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_CLNAME), pr_clname); if (data_present(state, &layout->pr_syscall)) { w = extract_as_word(state, &layout->pr_syscall); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_SYSCALL), conv_cnote_syscall(w, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NSYSARG), pr_nsysarg); if (data_present(state, &layout->pr_nsysarg)) { w2 = extract_as_word(state, &layout->pr_nsysarg); print_array(state, &layout->pr_sysarg, SL_FMT_NUM_ZHEX, w2, 1, MSG_ORIG(MSG_CNOTE_T_PR_SYSARG)); } PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_WHO), pr_who); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWPPEND), pr_sigpend, dump_sigset); PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_PR_OLDCONTEXT), pr_oldcontext); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_BRKBASE), &layout->pr_brkbase, SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_BRKSIZE), &layout->pr_brksize, SL_FMT_NUM_HEX); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_STKBASE), &layout->pr_stkbase, SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_STKSIZE), &layout->pr_stksize, SL_FMT_NUM_HEX); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_PROCESSOR), pr_processor); if (data_present(state, &layout->pr_bind)) { i = extract_as_sword(state, &layout->pr_bind); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_BIND), conv_cnote_psetid(i, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_PR_INSTR), pr_instr); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_REG), pr_reg, dump_prgregset); indent_exit(state); } static void dump_lwpname(note_state_t *state, const char *title) { const sl_prlwpname_layout_t *layout = state->ns_arch->prlwpname; indent_enter(state, title, &layout->pr_lwpid); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_LWPID), pr_lwpid); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_LWPNAME), pr_lwpname); indent_exit(state); } /* * Print percent from 16-bit binary fraction [0 .. 1] * Round up .01 to .1 to indicate some small percentage (the 0x7000 below). * * Note: This routine was copied from ps(1) and then modified. */ static const char * prtpct_value(note_state_t *state, const sl_field_t *fdesc, sl_fmtbuf_t buf) { uint_t value; /* need 32 bits to compute with */ value = extract_as_word(state, fdesc); value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */ if (value >= 1000) value = 999; (void) snprintf(buf, sizeof (sl_fmtbuf_t), MSG_ORIG(MSG_CNOTE_FMT_PRTPCT), value / 10, value % 10); return (buf); } /* * Version of prtpct() used for a 2-up display of two adjacent percentages. */ static void prtpct_2up(note_state_t *state, const sl_field_t *fdesc1, const char *title1, const sl_field_t *fdesc2, const char *title2) { sl_fmtbuf_t buf1, buf2; if (!(data_present(state, fdesc1) && data_present(state, fdesc2))) return; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, state->ns_vcol - state->ns_indent, title1, state->ns_t2col - state->ns_vcol, prtpct_value(state, fdesc1, buf1), state->ns_v2col - state->ns_t2col, title2, prtpct_value(state, fdesc2, buf2)); } /* * The psinfo_t and prpsinfo_t structs have pr_state and pr_sname * fields that we wish to print in a 2up format. The pr_state is * an integer, while pr_sname is a single character. */ static void print_state_sname_2up(note_state_t *state, const sl_field_t *state_fdesc, const sl_field_t *sname_fdesc) { sl_fmtbuf_t buf1, buf2; int sname; /* * If the field slf_offset and extent fall past the end of the * available data, then return without doing anything. That note * is from an older core file that doesn't have all the fields * that we know about. */ if (!(data_present(state, state_fdesc) && data_present(state, sname_fdesc))) return; sname = extract_as_sword(state, sname_fdesc); buf2[0] = sname; buf2[1] = '\0'; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, state->ns_vcol - state->ns_indent, MSG_ORIG(MSG_CNOTE_T_PR_STATE), state->ns_t2col - state->ns_vcol, fmt_num(state, state_fdesc, SL_FMT_NUM_DEC, buf1), state->ns_v2col - state->ns_t2col, MSG_ORIG(MSG_CNOTE_T_PR_SNAME), buf2); } /* * Output information from lwpsinfo_t structure. */ static void dump_lwpsinfo(note_state_t *state, const char *title) { const sl_lwpsinfo_layout_t *layout = state->ns_arch->lwpsinfo; Word w; int32_t i; union { Conv_cnote_proc_flag_buf_t proc_flag; Conv_inv_buf_t inv; } conv_buf; indent_enter(state, title, &layout->pr_flag); if (data_present(state, &layout->pr_flag)) { w = extract_as_word(state, &layout->pr_flag); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAG), conv_cnote_proc_flag(w, 0, &conv_buf.proc_flag)); } print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_LWPID), &layout->pr_lwpid, SL_FMT_NUM_DEC, MSG_ORIG(MSG_CNOTE_T_PR_ADDR), &layout->pr_addr, SL_FMT_NUM_ZHEX); PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_PR_WCHAN), pr_wchan); if (data_present(state, &layout->pr_stype)) { w = extract_as_word(state, &layout->pr_stype); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_STYPE), conv_cnote_pr_stype(w, CONV_FMT_DECIMAL, &conv_buf.inv)); } print_state_sname_2up(state, &layout->pr_state, &layout->pr_sname); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NICE), pr_nice); if (data_present(state, &layout->pr_syscall)) { w = extract_as_word(state, &layout->pr_syscall); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_SYSCALL), conv_cnote_syscall(w, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_OLDPRI), pr_oldpri, MSG_ORIG(MSG_CNOTE_T_PR_CPU), pr_cpu); if (data_present(state, &layout->pr_pri) && data_present(state, &layout->pr_pctcpu)) { sl_fmtbuf_t buf1, buf2; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, state->ns_vcol - state->ns_indent, MSG_ORIG(MSG_CNOTE_T_PR_PRI), state->ns_t2col - state->ns_vcol, fmt_num(state, &layout->pr_pri, SL_FMT_NUM_DEC, buf1), state->ns_v2col - state->ns_t2col, MSG_ORIG(MSG_CNOTE_T_PR_PCTCPU), prtpct_value(state, &layout->pr_pctcpu, buf2)); } PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_START), pr_start, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_TIME), pr_time, dump_timestruc); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_CLNAME), pr_clname); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_NAME), pr_name); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ONPRO), pr_onpro, MSG_ORIG(MSG_CNOTE_T_PR_BINDPRO), pr_bindpro); if (data_present(state, &layout->pr_bindpset)) { i = extract_as_sword(state, &layout->pr_bindpset); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_BINDPSET), conv_cnote_psetid(i, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_LGRP), pr_lgrp); indent_exit(state); } /* * Output information from psinfo_t structure. */ static void dump_psinfo(note_state_t *state, const char *title) { const sl_psinfo_layout_t *layout = state->ns_arch->psinfo; Word w; union { Conv_cnote_proc_flag_buf_t proc_flag; Conv_inv_buf_t inv; } conv_buf; indent_enter(state, title, &layout->pr_flag); if (data_present(state, &layout->pr_flag)) { w = extract_as_word(state, &layout->pr_flag); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAG), conv_cnote_proc_flag(w, 0, &conv_buf.proc_flag)); } PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NLWP), pr_nlwp); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PID), pr_pid, MSG_ORIG(MSG_CNOTE_T_PR_PPID), pr_ppid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PGID), pr_pgid, MSG_ORIG(MSG_CNOTE_T_PR_SID), pr_sid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_UID), pr_uid, MSG_ORIG(MSG_CNOTE_T_PR_EUID), pr_euid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_GID), pr_gid, MSG_ORIG(MSG_CNOTE_T_PR_EGID), pr_egid); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_ADDR), &layout->pr_addr, SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_SIZE), &layout->pr_size, SL_FMT_NUM_HEX); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_RSSIZE), &layout->pr_rssize, SL_FMT_NUM_HEX, MSG_ORIG(MSG_CNOTE_T_PR_TTYDEV), &layout->pr_ttydev, SL_FMT_NUM_DEC); prtpct_2up(state, &layout->pr_pctcpu, MSG_ORIG(MSG_CNOTE_T_PR_PCTCPU), &layout->pr_pctmem, MSG_ORIG(MSG_CNOTE_T_PR_PCTMEM)); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_START), pr_start, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_TIME), pr_time, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CTIME), pr_ctime, dump_timestruc); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_FNAME), pr_fname); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_PSARGS), pr_psargs); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_WSTAT), &layout->pr_wstat, SL_FMT_NUM_HEX, MSG_ORIG(MSG_CNOTE_T_PR_ARGC), &layout->pr_argc, SL_FMT_NUM_DEC); PRINT_ZHEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ARGV), pr_argv, MSG_ORIG(MSG_CNOTE_T_PR_ENVP), pr_envp); if (data_present(state, &layout->pr_dmodel)) { w = extract_as_word(state, &layout->pr_dmodel); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_DMODEL), conv_cnote_pr_dmodel(w, 0, &conv_buf.inv)); } PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_TASKID), pr_taskid, MSG_ORIG(MSG_CNOTE_T_PR_PROJID), pr_projid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_NZOMB), pr_nzomb, MSG_ORIG(MSG_CNOTE_T_PR_POOLID), pr_poolid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ZONEID), pr_zoneid, MSG_ORIG(MSG_CNOTE_T_PR_CONTRACT), pr_contract); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWP), pr_lwp, dump_lwpsinfo); indent_exit(state); } /* * Output information from prpsinfo_t structure. */ static void dump_prpsinfo(note_state_t *state, const char *title) { const sl_prpsinfo_layout_t *layout = state->ns_arch->prpsinfo; Word w; union { Conv_cnote_proc_flag_buf_t proc_flag; Conv_inv_buf_t inv; } conv_buf; indent_enter(state, title, &layout->pr_state); print_state_sname_2up(state, &layout->pr_state, &layout->pr_sname); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ZOMB), pr_zomb, MSG_ORIG(MSG_CNOTE_T_PR_NICE), pr_nice); if (data_present(state, &layout->pr_flag)) { w = extract_as_word(state, &layout->pr_flag); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAG), conv_cnote_proc_flag(w, 0, &conv_buf.proc_flag)); } PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_UID), pr_uid, MSG_ORIG(MSG_CNOTE_T_PR_GID), pr_gid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PID), pr_pid, MSG_ORIG(MSG_CNOTE_T_PR_PPID), pr_ppid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PGRP), pr_pgrp, MSG_ORIG(MSG_CNOTE_T_PR_SID), pr_sid); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_ADDR), &layout->pr_addr, SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_SIZE), &layout->pr_size, SL_FMT_NUM_HEX); PRINT_HEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_RSSIZE), pr_rssize, MSG_ORIG(MSG_CNOTE_T_PR_WCHAN), pr_wchan); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_START), pr_start, dump_timestruc); PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_TIME), pr_time, dump_timestruc); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PRI), pr_pri, MSG_ORIG(MSG_CNOTE_T_PR_OLDPRI), pr_oldpri); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_CPU), pr_cpu); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_OTTYDEV), pr_ottydev, MSG_ORIG(MSG_CNOTE_T_PR_LTTYDEV), pr_lttydev); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_CLNAME), pr_clname); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_FNAME), pr_fname); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_PSARGS), pr_psargs); if (data_present(state, &layout->pr_syscall)) { w = extract_as_word(state, &layout->pr_syscall); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_SYSCALL), conv_cnote_syscall(w, CONV_FMT_DECIMAL, &conv_buf.inv)); } PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CTIME), pr_ctime, dump_timestruc); PRINT_HEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_BYSIZE), pr_bysize, MSG_ORIG(MSG_CNOTE_T_PR_BYRSSIZE), pr_byrssize); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_ARGC), &layout->pr_argc, SL_FMT_NUM_DEC, MSG_ORIG(MSG_CNOTE_T_PR_ARGV), &layout->pr_argv, SL_FMT_NUM_ZHEX); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_ENVP), &layout->pr_envp, SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_WSTAT), &layout->pr_wstat, SL_FMT_NUM_HEX); prtpct_2up(state, &layout->pr_pctcpu, MSG_ORIG(MSG_CNOTE_T_PR_PCTCPU), &layout->pr_pctmem, MSG_ORIG(MSG_CNOTE_T_PR_PCTMEM)); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_EUID), pr_euid, MSG_ORIG(MSG_CNOTE_T_PR_EGID), pr_egid); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_ASLWPID), pr_aslwpid); if (data_present(state, &layout->pr_dmodel)) { w = extract_as_word(state, &layout->pr_dmodel); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_DMODEL), conv_cnote_pr_dmodel(w, 0, &conv_buf.inv)); } indent_exit(state); } /* * Output information from prcred_t structure. */ static void dump_prcred(note_state_t *state, const char *title) { const sl_prcred_layout_t *layout = state->ns_arch->prcred; Word ngroups; indent_enter(state, title, &layout->pr_euid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_EUID), pr_euid, MSG_ORIG(MSG_CNOTE_T_PR_RUID), pr_ruid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_SUID), pr_suid, MSG_ORIG(MSG_CNOTE_T_PR_EGID), pr_egid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_RGID), pr_rgid, MSG_ORIG(MSG_CNOTE_T_PR_SGID), pr_sgid); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NGROUPS), pr_ngroups); if (data_present(state, &layout->pr_ngroups)) { ngroups = extract_as_word(state, &layout->pr_ngroups); print_array(state, &layout->pr_groups, SL_FMT_NUM_DEC, ngroups, 0, MSG_ORIG(MSG_CNOTE_T_PR_GROUPS)); } indent_exit(state); } /* * Output information from prpriv_t structure. */ static void dump_prpriv(note_state_t *state, const char *title) { const sl_prpriv_layout_t *layout = state->ns_arch->prpriv; Word nsets; indent_enter(state, title, &layout->pr_nsets); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NSETS), pr_nsets); PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_PR_SETSIZE), pr_setsize); PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_PR_INFOSIZE), pr_infosize); if (data_present(state, &layout->pr_nsets)) { nsets = extract_as_word(state, &layout->pr_nsets); print_array(state, &layout->pr_sets, SL_FMT_NUM_ZHEX, nsets, 0, MSG_ORIG(MSG_CNOTE_T_PR_SETS)); } indent_exit(state); } static void dump_prfdinfo(note_state_t *state, const char *title) { const sl_prfdinfo_layout_t *layout = state->ns_arch->prfdinfo; char buf[1024]; uint32_t fileflags, mode, fdflags; indent_enter(state, title, &layout->pr_fd); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_FD), pr_fd); mode = extract_as_word(state, &layout->pr_mode); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_MODE), conv_cnote_filemode(mode, 0, buf, sizeof (buf))); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_UID), pr_uid, MSG_ORIG(MSG_CNOTE_T_PR_GID), pr_gid); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_MAJOR), pr_major, MSG_ORIG(MSG_CNOTE_T_PR_MINOR), pr_minor); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_RMAJOR), pr_rmajor, MSG_ORIG(MSG_CNOTE_T_PR_RMINOR), pr_rminor); PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_INO), pr_ino); PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_SIZE), pr_size, MSG_ORIG(MSG_CNOTE_T_PR_OFFSET), pr_offset); fileflags = extract_as_word(state, &layout->pr_fileflags); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FILEFLAGS), conv_cnote_fileflags(fileflags, 0, buf, sizeof (buf))); fdflags = extract_as_word(state, &layout->pr_fdflags); print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FDFLAGS), conv_cnote_fdflags(fdflags, 0, buf, sizeof (buf))); PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_PATH), pr_path); indent_exit(state); } /* * Output information from priv_impl_info_t structure. */ static void dump_priv_impl_info(note_state_t *state, const char *title) { const sl_priv_impl_info_layout_t *layout; layout = state->ns_arch->priv_impl_info; indent_enter(state, title, &layout->priv_headersize); PRINT_HEX_2UP(MSG_ORIG(MSG_CNOTE_T_PRIV_HEADERSIZE), priv_headersize, MSG_ORIG(MSG_CNOTE_T_PRIV_FLAGS), priv_flags); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PRIV_NSETS), &layout->priv_nsets, SL_FMT_NUM_DEC, MSG_ORIG(MSG_CNOTE_T_PRIV_SETSIZE), &layout->priv_setsize, SL_FMT_NUM_HEX); print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PRIV_MAX), &layout->priv_max, SL_FMT_NUM_DEC, MSG_ORIG(MSG_CNOTE_T_PRIV_INFOSIZE), &layout->priv_infosize, SL_FMT_NUM_HEX); PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_PRIV_GLOBALINFOSIZE), priv_globalinfosize); indent_exit(state); } /* * Dump information from an asrset_t array. This data * structure is specific to sparcv9, and does not appear * on any other platform. * * asrset_t is a simple array, defined in as * typedef int64_t asrset_t[16]; %asr16 - > %asr31 * * As such, we do not make use of the struct_layout facilities * for this routine. */ static void dump_asrset(note_state_t *state, const char *title) { static const sl_field_t ftemplate = { 0, sizeof (int64_t), 16, 0 }; sl_field_t fdesc1, fdesc2; sl_fmtbuf_t buf1, buf2; char index1[MAXNDXSIZE * 2], index2[MAXNDXSIZE * 2]; Word w, nelts; fdesc1 = fdesc2 = ftemplate; /* We expect 16 values, but will print whatever is actually there */ nelts = state->ns_len / ftemplate.slf_eltlen; if (nelts == 0) return; indent_enter(state, title, &fdesc1); for (w = 0; w < nelts; ) { (void) snprintf(index1, sizeof (index1), MSG_ORIG(MSG_FMT_ASRINDEX), w + 16); if (w == (nelts - 1)) { /* One last register is left */ dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), INDENT, state->ns_vcol - state->ns_indent, index1, fmt_num(state, &fdesc1, SL_FMT_NUM_ZHEX, buf1)); fdesc1.slf_offset += fdesc1.slf_eltlen; w++; continue; } /* There are at least 2 more registers left. Show 2 up */ (void) snprintf(index2, sizeof (index2), MSG_ORIG(MSG_FMT_ASRINDEX), w + 17); fdesc2.slf_offset = fdesc1.slf_offset + fdesc1.slf_eltlen; dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, state->ns_vcol - state->ns_indent, index1, state->ns_t2col - state->ns_vcol, fmt_num(state, &fdesc1, SL_FMT_NUM_ZHEX, buf1), state->ns_v2col - state->ns_t2col, index2, fmt_num(state, &fdesc2, SL_FMT_NUM_ZHEX, buf2)); fdesc1.slf_offset += 2 * fdesc1.slf_eltlen; w += 2; } indent_exit(state); } static void dump_upanic(note_state_t *state, const char *title) { const sl_prupanic_layout_t *layout = state->ns_arch->prupanic; Conv_upanic_buf_t inv; Word w; indent_enter(state, title, &layout->pru_version); w = extract_as_word(state, &layout->pru_version); if (w != PRUPANIC_VERSION_1) { PRINT_DEC(MSG_INTL(MSG_NOTE_BAD_UPANIC_VER), pru_version); dump_hex_bytes(state->ns_data, state->ns_len, state->ns_indent, 4, 3); } else { PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PRU_VERSION), pru_version); w = extract_as_word(state, &layout->pru_flags); print_str(state, MSG_ORIG(MSG_CNOTE_T_PRU_FLAGS), conv_prupanic(w, 0, &inv)); if ((w & PRUPANIC_FLAG_MSG_VALID) != 0) { /* * We have a message that is _probably_ a text string, * but the interface allows for arbitrary data. The only * guarantee is that someone using this is probably up * to no good. As a result, we basically try to print * this as a string, but in the face of certain types of * data, we hex escape it. */ print_strbuf(state, MSG_ORIG(MSG_CNOTE_T_PRU_DATA), &layout->pru_data); } } } static void dump_cwd(note_state_t *state, const char *title) { const sl_prcwd_layout_t *layout = state->ns_arch->prcwd; indent_enter(state, title, &layout->prcwd_fsid); if (data_present(state, &layout->prcwd_fsid)) { PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_CWD_FSID), prcwd_fsid); } if (data_present(state, &layout->prcwd_fsname)) { print_strbuf(state, MSG_ORIG(MSG_CNOTE_T_CWD_FSNAME), &layout->prcwd_fsname); } if (data_present(state, &layout->prcwd_mntpt)) { print_strbuf(state, MSG_ORIG(MSG_CNOTE_T_CWD_MNTPT), &layout->prcwd_mntpt); } if (data_present(state, &layout->prcwd_mntspec)) { print_strbuf(state, MSG_ORIG(MSG_CNOTE_T_CWD_MNTSPEC), &layout->prcwd_mntspec); } if (data_present(state, &layout->prcwd_cwd)) { print_strbuf(state, MSG_ORIG(MSG_CNOTE_T_CWD_CWD), &layout->prcwd_cwd); } indent_exit(state); } corenote_ret_t corenote(Half mach, int do_swap, Word type, const char *desc, Word descsz) { note_state_t state; /* * Get the per-architecture layout definition */ state.ns_mach = mach; state.ns_arch = sl_mach(state.ns_mach); if (sl_mach(state.ns_mach) == NULL) return (CORENOTE_R_BADARCH); state.ns_swap = do_swap; state.ns_indent = 4; state.ns_t2col = state.ns_v2col = 0; state.ns_data = desc; state.ns_len = descsz; switch (type) { case NT_PRSTATUS: /* prstatus_t */ state.ns_vcol = 26; state.ns_t2col = 46; state.ns_v2col = 60; dump_prstatus(&state, MSG_ORIG(MSG_CNOTE_DESC_PRSTATUS_T)); return (CORENOTE_R_OK); case NT_PRFPREG: /* prfpregset_t */ return (CORENOTE_R_OK_DUMP); case NT_PRPSINFO: /* prpsinfo_t */ state.ns_vcol = 20; state.ns_t2col = 41; state.ns_v2col = 54; dump_prpsinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_PRPSINFO_T)); return (CORENOTE_R_OK); case NT_PRXREG: /* prxregset_t */ return (CORENOTE_R_OK_DUMP); case NT_PLATFORM: /* string from sysinfo(SI_PLATFORM) */ dbg_print(0, MSG_ORIG(MSG_NOTE_DESC)); dbg_print(0, MSG_ORIG(MSG_FMT_INDENT), safe_str(desc, descsz)); return (CORENOTE_R_OK); case NT_AUXV: /* auxv_t array */ state.ns_vcol = 18; dump_auxv(&state, MSG_ORIG(MSG_CNOTE_DESC_AUXV_T)); return (CORENOTE_R_OK); case NT_GWINDOWS: /* gwindows_t SPARC only */ return (CORENOTE_R_OK_DUMP); case NT_ASRS: /* asrset_t sparcv9 only */ state.ns_vcol = 18; state.ns_t2col = 38; state.ns_v2col = 46; dump_asrset(&state, MSG_ORIG(MSG_CNOTE_DESC_ASRSET_T)); return (CORENOTE_R_OK); case NT_LDT: /* ssd array IA32 only */ return (CORENOTE_R_OK_DUMP); case NT_PSTATUS: /* pstatus_t */ state.ns_vcol = 22; state.ns_t2col = 42; state.ns_v2col = 54; dump_pstatus(&state, MSG_ORIG(MSG_CNOTE_DESC_PSTATUS_T)); return (CORENOTE_R_OK); case NT_PSINFO: /* psinfo_t */ state.ns_vcol = 25; state.ns_t2col = 45; state.ns_v2col = 58; dump_psinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_PSINFO_T)); return (CORENOTE_R_OK); case NT_PRCRED: /* prcred_t */ state.ns_vcol = 20; state.ns_t2col = 34; state.ns_v2col = 44; dump_prcred(&state, MSG_ORIG(MSG_CNOTE_DESC_PRCRED_T)); return (CORENOTE_R_OK); case NT_UTSNAME: /* struct utsname */ state.ns_vcol = 18; dump_utsname(&state, MSG_ORIG(MSG_CNOTE_DESC_STRUCT_UTSNAME)); return (CORENOTE_R_OK); case NT_LWPSTATUS: /* lwpstatus_t */ state.ns_vcol = 24; state.ns_t2col = 44; state.ns_v2col = 54; dump_lwpstatus(&state, MSG_ORIG(MSG_CNOTE_DESC_LWPSTATUS_T)); return (CORENOTE_R_OK); case NT_LWPSINFO: /* lwpsinfo_t */ state.ns_vcol = 22; state.ns_t2col = 42; state.ns_v2col = 54; dump_lwpsinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_LWPSINFO_T)); return (CORENOTE_R_OK); case NT_PRPRIV: /* prpriv_t */ state.ns_vcol = 21; state.ns_t2col = 34; state.ns_v2col = 38; dump_prpriv(&state, MSG_ORIG(MSG_CNOTE_DESC_PRPRIV_T)); return (CORENOTE_R_OK); case NT_PRPRIVINFO: /* priv_impl_info_t */ state.ns_vcol = 29; state.ns_t2col = 41; state.ns_v2col = 56; dump_priv_impl_info(&state, MSG_ORIG(MSG_CNOTE_DESC_PRIV_IMPL_INFO_T)); return (CORENOTE_R_OK); case NT_CONTENT: /* core_content_t */ if (sizeof (core_content_t) > descsz) return (CORENOTE_R_BADDATA); { static sl_field_t fdesc = { 0, 8, 0, 0 }; Conv_cnote_cc_content_buf_t conv_buf; core_content_t content; state.ns_vcol = 8; indent_enter(&state, MSG_ORIG(MSG_CNOTE_DESC_CORE_CONTENT_T), &fdesc); content = extract_as_lword(&state, &fdesc); print_str(&state, MSG_ORIG(MSG_STR_EMPTY), conv_cnote_cc_content(content, 0, &conv_buf)); indent_exit(&state); } return (CORENOTE_R_OK); case NT_ZONENAME: /* string from getzonenamebyid(3C) */ dbg_print(0, MSG_ORIG(MSG_NOTE_DESC)); dbg_print(0, MSG_ORIG(MSG_FMT_INDENT), safe_str(desc, descsz)); return (CORENOTE_R_OK); case NT_FDINFO: state.ns_vcol = 22; state.ns_t2col = 41; state.ns_v2col = 54; dump_prfdinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_PRFDINFO_T)); return (CORENOTE_R_OK); case NT_SPYMASTER: state.ns_vcol = 25; state.ns_t2col = 45; state.ns_v2col = 58; dump_psinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_PSINFO_T)); return (CORENOTE_R_OK); case NT_SECFLAGS: state.ns_vcol = 23; state.ns_t2col = 41; state.ns_v2col = 54; dump_secflags(&state, MSG_ORIG(MSG_CNOTE_DESC_PRSECFLAGS_T)); return (CORENOTE_R_OK); case NT_LWPNAME: state.ns_vcol = 20; dump_lwpname(&state, MSG_ORIG(MSG_CNOTE_DESC_PRLWPNAME_T)); return (CORENOTE_R_OK); case NT_UPANIC: state.ns_vcol = 23; dump_upanic(&state, MSG_ORIG(MSG_CNOTE_DESC_PRUPANIC_T)); return (CORENOTE_R_OK); case NT_CWD: state.ns_vcol = 23; dump_cwd(&state, MSG_ORIG(MSG_CNOTE_DESC_PRCWD_T)); return (CORENOTE_R_OK); } return (CORENOTE_R_BADTYPE); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include <_libelf.h> #include #include #include #include #include #include #include #include #include <_elfdump.h> /* * Data from eh_frame section used by dump_cfi() */ typedef struct { const char *file; const char *sh_name; Half e_machine; /* ehdr->e_machine */ uchar_t *e_ident; /* ehdr->e_ident */ uint64_t sh_addr; /* Address of eh_frame section */ int do_swap; /* True if object and system byte */ /* order differs */ int cieRflag; /* R flag from current CIE */ uint64_t ciecalign; /* CIE code align factor */ int64_t ciedalign; /* CIE data align factor */ uint64_t fdeinitloc; /* FDE initial location */ uint64_t gotaddr; /* Address of the GOT */ } dump_cfi_state_t; /* * Extract an unsigned integer value from an .eh_frame section, converting it * from its native byte order to that of the running machine if necessary. * * entry: * data - Base address from which to extract datum * ndx - Address of variable giving index to start byte in data. * size - # of bytes in datum. Must be one of: 1, 2, 4, 8 * do_swap - True if the data is in a different byte order than that * of the host system. * * exit: * *ndx is incremented by the size of the extracted datum. * * The requested datum is extracted, byte swapped if necessary, * and returned. */ static dwarf_error_t dwarf_extract_uint(uchar_t *data, size_t len, uint64_t *ndx, int size, int do_swap, uint64_t *ret) { if (((*ndx + size) > len) || ((*ndx + size) < *ndx)) return (DW_OVERFLOW); switch (size) { case 1: *ret = (data[(*ndx)++]); return (DW_SUCCESS); case 2: { Half r; uchar_t *p = (uchar_t *)&r; data += *ndx; if (do_swap) UL_ASSIGN_BSWAP_HALF(p, data); else UL_ASSIGN_HALF(p, data); (*ndx) += 2; *ret = r; return (DW_SUCCESS); } case 4: { Word r; uchar_t *p = (uchar_t *)&r; data += *ndx; if (do_swap) UL_ASSIGN_BSWAP_WORD(p, data); else UL_ASSIGN_WORD(p, data); (*ndx) += 4; *ret = r; return (DW_SUCCESS); } case 8: { uint64_t r; uchar_t *p = (uchar_t *)&r; data += *ndx; if (do_swap) UL_ASSIGN_BSWAP_LWORD(p, data); else UL_ASSIGN_LWORD(p, data); (*ndx) += 8; *ret = r; return (DW_SUCCESS); } default: return (DW_BAD_ENCODING); } /* NOTREACHED */ } /* * Map a DWARF register constant to the machine register name it * corresponds to, formatting the result into buf. * * The assignment of DWARF register numbers is part of the system * specific ABI for each platform. * * entry: * regno - DWARF register number * mach - ELF machine code for platform * buf, bufsize - Buffer to receive the formatted result string * * exit: * The results are formatted into buf, and buf is returned. * If the generated output would exceed the size of the buffer * provided, it will be clipped to fit. */ static const char * dwarf_regname(Half mach, int regno, char *buf, size_t bufsize) { Conv_inv_buf_t inv_buf; const char *name; int good_name; name = conv_dwarf_regname(mach, regno, 0, &good_name, &inv_buf); /* * If there is a good mnemonic machine name for the register, * format the result as 'r# (mnemonic)'. If there is no good * name for it, then simply format the dwarf name as 'r#'. */ if (good_name) (void) snprintf(buf, bufsize, MSG_ORIG(MSG_REG_FMT_NAME), regno, name); else (void) snprintf(buf, bufsize, MSG_ORIG(MSG_REG_FMT_BASIC), regno); return (buf); } /* * Decode eh_frame Call Frame Instructions, printing each one on a * separate line. * * entry: * data - Address of base of eh_frame section being processed * off - Offset of current FDE within eh_frame * ndx - Index of current position within current FDE * len - Length of FDE * state - Object, CIE, and FDE state for current request * msg - Header message to issue before producing output. * indent - # of indentation characters issued for each line of output. * * exit: * The Call Frame Instructions have been decoded and printed. * * *ndx has been incremented to contain the index of the next * byte of data to be processed in eh_frame. * * note: * The format of Call Frame Instructions in .eh_frame sections is based * on the DWARF specification. */ static void dump_cfi(uchar_t *data, uint64_t off, uint64_t *ndx, uint_t len, dump_cfi_state_t *state, const char *msg, int indent) { /* * We use %*s%s to insert leading whitespace and the op name. * PREFIX supplies these arguments. */ #define PREFIX indent, MSG_ORIG(MSG_STR_EMPTY), opname /* Hide boilerplate clutter in calls to dwarf_regname() */ #define REGNAME(_rnum, _buf) \ dwarf_regname(state->e_machine, _rnum, _buf, sizeof (_buf)) /* Extract the lower 6 bits from an op code */ #define LOW_OP(_op) (_op & 0x3f) char rbuf1[32], rbuf2[32]; Conv_inv_buf_t inv_buf; uchar_t op; const char *opname; uint64_t oper1, oper2, cur_pc; int64_t soper; const char *loc_str; int i; dbg_print(0, msg); /* * In a CIE/FDE, the length field does not include it's own * size. Hence, the value passed in is 4 less than the index * of the actual final location. */ len += 4; /* * There is a concept of the 'current location', which is the PC * to which the current item applies. It starts out set to the * FDE initial location, and can be set or incremented by * various OP codes. cur_pc is used to track this. * * We want to use 'initloc' in the output the first time the location * is referenced, and then switch to 'loc' for subsequent references. * loc_str is used to manage that. */ cur_pc = state->fdeinitloc; loc_str = MSG_ORIG(MSG_STR_INITLOC); while (*ndx < len) { /* * The first byte contains the primary op code in the top * 2 bits, so there are 4 of them. Primary OP code * 0 uses the lower 6 bits to specify a sub-opcode, allowing * for 64 of them. The other 3 primary op codes use the * lower 6 bits to hold an operand (a register #, or value). * * Check the primary OP code. If it's 1-3, handle it * and move to the next loop iteration. For OP code 0, * fall through to decode the sub-code. */ op = data[off + (*ndx)++]; opname = conv_dwarf_cfa(op, 0, &inv_buf); switch (op >> 6) { case 0x1: /* v2: DW_CFA_advance_loc, delta */ oper1 = state->ciecalign * LOW_OP(op); cur_pc += oper1; dbg_print(0, MSG_ORIG(MSG_CFA_ADV_LOC), PREFIX, loc_str, EC_XWORD(oper1), EC_XWORD(cur_pc)); loc_str = MSG_ORIG(MSG_STR_LOC); continue; case 0x2: /* v2: DW_CFA_offset, reg, offset */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } oper1 *= state->ciedalign; dbg_print(0, MSG_ORIG(MSG_CFA_CFAOFF), PREFIX, REGNAME(LOW_OP(op), rbuf1), EC_XWORD(oper1)); continue; case 0x3: /* v2: DW_CFA_restore, reg */ dbg_print(0, MSG_ORIG(MSG_CFA_REG), PREFIX, REGNAME(LOW_OP(op), rbuf1)); continue; } /* * If we're here, the high order 2 bits are 0. The low 6 bits * specify a sub-opcode defining the operation. */ switch (op) { case 0x00: /* v2: DW_CFA_nop */ /* * No-ops are used to fill unused space required * for alignment. It is common for there to be * multiple adjacent nops. It saves space to report * them all with a single line of output. */ for (i = 1; (*ndx < len) && (data[off + *ndx] == 0); i++, (*ndx)++) ; dbg_print(0, MSG_ORIG(MSG_CFA_SIMPLEREP), PREFIX, i); break; case 0x0a: /* v2: DW_CFA_remember_state */ case 0x0b: /* v2: DW_CFA_restore_state */ case 0x2d: /* GNU: DW_CFA_GNU_window_save */ dbg_print(0, MSG_ORIG(MSG_CFA_SIMPLE), PREFIX); break; case 0x01: /* v2: DW_CFA_set_loc, address */ switch (dwarf_ehe_extract(&data[off], len, ndx, &cur_pc, state->cieRflag, state->e_ident, B_FALSE, state->sh_addr, off + *ndx, state->gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), state->file, state->sh_name, state->cieRflag); return; case DW_SUCCESS: break; } dbg_print(0, MSG_ORIG(MSG_CFA_CFASET), PREFIX, EC_XWORD(cur_pc)); break; case 0x02: /* v2: DW_CFA_advance_loc_1, 1-byte delta */ case 0x03: /* v2: DW_CFA_advance_loc_2, 2-byte delta */ case 0x04: /* v2: DW_CFA_advance_loc_4, 4-byte delta */ /* * Since the codes are contiguous, and the sizes are * powers of 2, we can compute the word width from * the code. */ i = 1 << (op - 0x02); switch (dwarf_extract_uint(data + off, len, ndx, i, state->do_swap, &oper1)) { case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), state->file, state->sh_name, i); return; case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; case DW_SUCCESS: break; } oper1 *= state->ciecalign; cur_pc += oper1; dbg_print(0, MSG_ORIG(MSG_CFA_ADV_LOC), PREFIX, loc_str, EC_XWORD(oper1), EC_XWORD(cur_pc)); loc_str = MSG_ORIG(MSG_STR_LOC); break; case 0x05: /* v2: DW_CFA_offset_extended,reg,off */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (sleb_extract(&data[off], ndx, len, &soper) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } soper *= state->ciedalign; dbg_print(0, MSG_ORIG(MSG_CFA_CFAOFF), PREFIX, REGNAME(oper1, rbuf1), EC_SXWORD(soper)); break; case 0x06: /* v2: DW_CFA_restore_extended, reg */ case 0x0d: /* v2: DW_CFA_def_cfa_register, reg */ case 0x08: /* v2: DW_CFA_same_value, reg */ case 0x07: /* v2: DW_CFA_undefined, reg */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } dbg_print(0, MSG_ORIG(MSG_CFA_REG), PREFIX, REGNAME(oper1, rbuf1)); break; case 0x09: /* v2: DW_CFA_register, reg, reg */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (uleb_extract(&data[off], ndx, len, &oper2) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } dbg_print(0, MSG_ORIG(MSG_CFA_REG_REG), PREFIX, REGNAME(oper1, rbuf1), REGNAME(oper2, rbuf2)); break; case 0x0c: /* v2: DW_CFA_def_cfa, reg, offset */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (uleb_extract(&data[off], ndx, len, &oper2) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } dbg_print(0, MSG_ORIG(MSG_CFA_REG_OFFLLU), PREFIX, REGNAME(oper1, rbuf1), EC_XWORD(oper2)); break; case 0x0e: /* v2: DW_CFA_def_cfa_offset, offset */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } dbg_print(0, MSG_ORIG(MSG_CFA_LLU), PREFIX, EC_XWORD(oper1)); break; case 0x0f: /* v3: DW_CFA_def_cfa_expression, blk */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } dbg_print(0, MSG_ORIG(MSG_CFA_EBLK), PREFIX, EC_XWORD(oper1)); /* We currently do not decode the expression block */ *ndx += oper1; break; case 0x10: /* v3: DW_CFA_expression, reg, blk */ case 0x16: /* v3: DW_CFA_val_expression,reg,blk */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (uleb_extract(&data[off], ndx, len, &oper2) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } dbg_print(0, MSG_ORIG(MSG_CFA_REG_EBLK), PREFIX, REGNAME(oper1, rbuf1), EC_XWORD(oper2)); /* We currently do not decode the expression block */ *ndx += oper2; break; case 0x11: /* v3: DW_CFA_offset_extended_sf, reg, off */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (sleb_extract(&data[off], ndx, len, &soper) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } soper *= state->ciedalign; dbg_print(0, MSG_ORIG(MSG_CFA_CFAOFF), PREFIX, REGNAME(oper1, rbuf1), EC_SXWORD(soper)); break; case 0x12: /* v3: DW_CFA_def_cfa_sf, reg, offset */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (sleb_extract(&data[off], ndx, len, &soper) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } soper *= state->ciedalign; dbg_print(0, MSG_ORIG(MSG_CFA_REG_OFFLLD), PREFIX, REGNAME(oper1, rbuf1), EC_SXWORD(soper)); break; case 0x13: /* DW_CFA_def_cfa_offset_sf, offset */ if (sleb_extract(&data[off], ndx, len, &soper) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } soper *= state->ciedalign; dbg_print(0, MSG_ORIG(MSG_CFA_LLD), PREFIX, EC_SXWORD(soper)); break; case 0x14: /* v3: DW_CFA_val_offset, reg, offset */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (sleb_extract(&data[off], ndx, len, &soper) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } soper *= state->ciedalign; dbg_print(0, MSG_ORIG(MSG_CFA_REG_OFFLLD), PREFIX, REGNAME(oper1, rbuf1), EC_SXWORD(soper)); break; case 0x15: /* v3: DW_CFA_val_offset_sf, reg, offset */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (sleb_extract(&data[off], ndx, len, &soper) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } soper *= state->ciedalign; dbg_print(0, MSG_ORIG(MSG_CFA_REG_OFFLLD), PREFIX, REGNAME(oper1, rbuf1), EC_SXWORD(soper)); break; case 0x1d: /* GNU: DW_CFA_MIPS_advance_loc8, delta */ switch (dwarf_extract_uint(data + off, len, ndx, 8, state->do_swap, &oper1)) { case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), state->file, state->sh_name, 8); return; case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; case DW_SUCCESS: break; } oper1 *= state->ciecalign; cur_pc += oper1; dbg_print(0, MSG_ORIG(MSG_CFA_ADV_LOC), PREFIX, loc_str, EC_XWORD(oper1), EC_XWORD(cur_pc)); loc_str = MSG_ORIG(MSG_STR_LOC); break; case 0x2e: /* GNU: DW_CFA_GNU_args_size, size */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } dbg_print(0, MSG_ORIG(MSG_CFA_LLU), PREFIX, EC_XWORD(oper1)); break; case 0x2f: /* GNU:DW_CFA_GNU_negative_offset_extended,reg,off */ if (uleb_extract(&data[off], ndx, len, &oper1) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } if (sleb_extract(&data[off], ndx, len, &soper) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), state->file, state->sh_name); return; } soper = -soper * state->ciedalign; soper *= state->ciedalign; dbg_print(0, MSG_ORIG(MSG_CFA_CFAOFF), PREFIX, REGNAME(oper1, rbuf1), EC_SXWORD(soper)); break; default: /* * Unrecognized OP code: DWARF data is variable length, * so we don't know how many bytes to skip in order to * advance to the next item. We cannot decode beyond * this point, so dump the remainder in hex. */ (*ndx)--; /* Back up to unrecognized opcode */ dump_hex_bytes(data + off + *ndx, len - *ndx, indent, 8, 1); (*ndx) = len; break; } } #undef PREFIX #undef REGNAME #undef LOW_OP } void dump_eh_frame(const char *file, char *sh_name, uchar_t *data, size_t datasize, uint64_t sh_addr, Half e_machine, uchar_t *e_ident, uint64_t gotaddr) { Conv_dwarf_ehe_buf_t dwarf_ehe_buf; dump_cfi_state_t cfi_state; uint64_t off, ndx, length, id; uint_t cieid, cielength, cieversion, cieretaddr; int ciePflag = 0, cieZflag = 0, cieLflag = 0; int cieLflag_present = 0; uint_t cieaugndx; char *cieaugstr = NULL; boolean_t have_cie = B_FALSE; cfi_state.file = file; cfi_state.sh_name = sh_name; cfi_state.e_machine = e_machine; cfi_state.e_ident = e_ident; cfi_state.sh_addr = sh_addr; cfi_state.do_swap = _elf_sys_encoding() != e_ident[EI_DATA]; cfi_state.gotaddr = gotaddr; off = 0; while (off < datasize) { ndx = 0; /* * Extract length in native format. A zero length indicates * that this CIE is a terminator and that processing for this * unwind information should end. However, skip this entry and * keep processing, just in case there is any other information * remaining in this section. Note, ld(1) will terminate the * processing of the .eh_frame contents for this file after a * zero length CIE, thus any information that does follow is * ignored by ld(1), and is therefore questionable. */ if (dwarf_extract_uint(data + off, datasize - off, &ndx, 4, cfi_state.do_swap, &length) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; } if (length == 0) { dbg_print(0, MSG_ORIG(MSG_UNW_ZEROTERM)); off += 4; continue; } if (length > (datasize - off)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADCIEFDELEN), file, sh_name, EC_XWORD(length), EC_XWORD(sh_addr + off)); /* * If length is wrong, we have no means to find the * next entry, just give up */ return; } /* * extract CIE id in native format */ if (dwarf_extract_uint(data + off, datasize - off, &ndx, 4, cfi_state.do_swap, &id) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; } /* * A CIE record has an id of '0', otherwise this is a * FDE entry and the 'id' is the CIE pointer. */ if (id == 0) { uint64_t persVal, ndx_save = 0; uint64_t axsize; have_cie = B_TRUE; cielength = length; cieid = id; ciePflag = cfi_state.cieRflag = cieZflag = 0; cieLflag = cieLflag_present = 0; dbg_print(0, MSG_ORIG(MSG_UNW_CIE), EC_XWORD(sh_addr + off)); dbg_print(0, MSG_ORIG(MSG_UNW_CIELNGTH), cielength, cieid); cieversion = data[off + ndx]; ndx += 1; cieaugstr = (char *)(&data[off + ndx]); ndx += strlen(cieaugstr) + 1; dbg_print(0, MSG_ORIG(MSG_UNW_CIEVERS), cieversion, cieaugstr); if (uleb_extract(&data[off], &ndx, datasize - off, &cfi_state.ciecalign) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; } if (sleb_extract(&data[off], &ndx, datasize - off, &cfi_state.ciedalign) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; } cieretaddr = data[off + ndx]; ndx += 1; dbg_print(0, MSG_ORIG(MSG_UNW_CIECALGN), EC_XWORD(cfi_state.ciecalign), EC_XWORD(cfi_state.ciedalign), cieretaddr); if (cieaugstr[0]) dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXVAL)); for (cieaugndx = 0; cieaugstr[cieaugndx]; cieaugndx++) { switch (cieaugstr[cieaugndx]) { case 'z': if (uleb_extract(&data[off], &ndx, datasize - off, &axsize) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; } dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXSIZ), EC_XWORD(axsize)); cieZflag = 1; /* * The auxiliary section can contain * unused padding bytes at the end, so * save the current index. Along with * axsize, we will use it to set ndx to * the proper continuation index after * the aux data has been processed. */ ndx_save = ndx; break; case 'P': ciePflag = data[off + ndx]; ndx += 1; switch (dwarf_ehe_extract(&data[off], datasize - off, &ndx, &persVal, ciePflag, e_ident, B_FALSE, sh_addr, off + ndx, gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), file, sh_name, ciePflag); return; case DW_SUCCESS: break; } dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXPERS)); dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXPERSENC), ciePflag, conv_dwarf_ehe(ciePflag, &dwarf_ehe_buf)); dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXPERSRTN), EC_XWORD(persVal)); break; case 'R': cfi_state.cieRflag = data[off + ndx]; ndx += 1; dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXCENC), cfi_state.cieRflag, conv_dwarf_ehe(cfi_state.cieRflag, &dwarf_ehe_buf)); break; case 'L': cieLflag_present = 1; cieLflag = data[off + ndx]; ndx += 1; dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXLSDA), cieLflag, conv_dwarf_ehe( cieLflag, &dwarf_ehe_buf)); break; default: dbg_print(0, MSG_ORIG(MSG_UNW_CIEAXUNEC), cieaugstr[cieaugndx]); break; } } /* * If the z flag was present, reposition ndx using the * length given. This will safely move us past any * unaccessed padding bytes in the auxiliary section. */ if (cieZflag) ndx = ndx_save + axsize; /* * Any remaining data are Call Frame Instructions */ if ((cielength + 4) > ndx) dump_cfi(data, off, &ndx, cielength, &cfi_state, MSG_ORIG(MSG_UNW_CIECFI), 3); off += cielength + 4; } else { uint_t fdelength = length; int fdecieptr = id; uint64_t fdeaddrrange; if (!have_cie) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWNOCIE), file, sh_name); return; } dbg_print(0, MSG_ORIG(MSG_UNW_FDE), EC_XWORD(sh_addr + off)); dbg_print(0, MSG_ORIG(MSG_UNW_FDELNGTH), fdelength, fdecieptr); switch (dwarf_ehe_extract(&data[off], datasize - off, &ndx, &cfi_state.fdeinitloc, cfi_state.cieRflag, e_ident, B_FALSE, sh_addr, off + ndx, gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), file, sh_name, cfi_state.cieRflag); return; case DW_SUCCESS: break; } switch (dwarf_ehe_extract(&data[off], datasize - off, &ndx, &fdeaddrrange, (cfi_state.cieRflag & ~DW_EH_PE_pcrel), e_ident, B_FALSE, sh_addr, off + ndx, gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), file, sh_name, (cfi_state.cieRflag & ~DW_EH_PE_pcrel)); return; case DW_SUCCESS: break; } dbg_print(0, MSG_ORIG(MSG_UNW_FDEINITLOC), EC_XWORD(cfi_state.fdeinitloc), EC_XWORD(fdeaddrrange), EC_XWORD(cfi_state.fdeinitloc + fdeaddrrange - 1)); if ((cieaugstr != NULL) && (cieaugstr[0] != '\0')) dbg_print(0, MSG_ORIG(MSG_UNW_FDEAXVAL)); if (cieZflag) { uint64_t val; uint64_t lndx; if (uleb_extract(&data[off], &ndx, datasize - off, &val) == DW_OVERFLOW) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; } lndx = ndx; ndx += val; dbg_print(0, MSG_ORIG(MSG_UNW_FDEAXSIZE), EC_XWORD(val)); if (val && cieLflag_present) { uint64_t lsda; switch (dwarf_ehe_extract(&data[off], datasize - off, &lndx, &lsda, cieLflag, e_ident, B_FALSE, sh_addr, off + lndx, gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, sh_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), file, sh_name, cieLflag); return; case DW_SUCCESS: break; } dbg_print(0, MSG_ORIG(MSG_UNW_FDEAXLSDA), EC_XWORD(lsda)); } } if ((fdelength + 4) > ndx) dump_cfi(data, off, &ndx, fdelength, &cfi_state, MSG_ORIG(MSG_UNW_FDECFI), 6); off += fdelength + 4; } } } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2010 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright (c) 2015, Joyent, Inc. All rights reserved. */ /* * Dump an elf file. */ #include #include #include #include #include <_libelf.h> #include #include #include #include #include #include #include #include #include <_elfdump.h> /* * VERSYM_STATE is used to maintain information about the VERSYM section * in the object being analyzed. It is filled in by versions(), and used * by init_symtbl_state() when displaying symbol information. * * There are three forms of symbol versioning known to us: * * 1) The original form, introduced with Solaris 2.5, in which * the Versym contains indexes to Verdef records, and the * Versym values for UNDEF symbols resolved by other objects * are all set to 0. * 2) The GNU form, which is backward compatible with the original * Solaris form, but which adds several extensions: * - The Versym also contains indexes to Verneed records, recording * which object/version contributed the external symbol at * link time. These indexes start with the next value following * the final Verdef index. The index is written to the previously * reserved vna_other field of the ELF Vernaux structure. * - The top bit of the Versym value is no longer part of the index, * but is used as a "hidden bit" to prevent binding to the symbol. * - Multiple implementations of a given symbol, contained in varying * versions are allowed, using special assembler pseudo ops, * and encoded in the symbol name using '@' characters. * 3) Modified Solaris form, in which we adopt the first GNU extension * (Versym indexes to Verneed records), but not the others. * * elfdump can handle any of these cases. The presence of a DT_VERSYM * dynamic element indicates a full GNU object. An object that lacks * a DT_VERSYM entry, but which has non-zero vna_other fields in the Vernaux * structures is a modified Solaris object. An object that has neither of * these uses the original form. * * max_verndx contains the largest version index that can appear * in a Versym entry. This can never be less than 1: In the case where * there is no verdef/verneed sections, the [0] index is reserved * for local symbols, and the [1] index for globals. If the original * Solaris versioning rules are in effect and there is a verdef section, * then max_verndex is the number of defined versions. If one of the * other versioning forms is in effect, then: * 1) If there is no verneed section, it is the same as for * original Solaris versioning. * 2) If there is a verneed section, the vna_other field of the * Vernaux structs contain versions, and max_verndx is the * largest such index. * * If gnu_full is True, the object uses the full GNU form of versioning. * The value of the gnu_full field is based on the presence of * a DT_VERSYM entry in the dynamic section: GNU ld produces these, and * Solaris ld does not. * * The gnu_needed field is True if the Versym contains indexes to * Verneed records, as indicated by non-zero vna_other fields in the Verneed * section. If gnu_full is True, then gnu_needed will always be true. * However, gnu_needed can be true without gnu_full. This is the modified * Solaris form. */ typedef struct { Cache *cache; /* Pointer to cache entry for VERSYM */ Versym *data; /* Pointer to versym array */ int gnu_full; /* True if object uses GNU versioning rules */ int gnu_needed; /* True if object uses VERSYM indexes for */ /* VERNEED (subset of gnu_full) */ int max_verndx; /* largest versym index value */ } VERSYM_STATE; /* * SYMTBL_STATE is used to maintain information about a single symbol * table section, for use by the routines that display symbol information. */ typedef struct { const char *file; /* Name of file */ Ehdr *ehdr; /* ELF header for file */ Cache *cache; /* Cache of all section headers */ uchar_t osabi; /* OSABI to use */ Word shnum; /* # of sections in cache */ Cache *seccache; /* Cache of symbol table section hdr */ Word secndx; /* Index of symbol table section hdr */ const char *secname; /* Name of section */ uint_t flags; /* Command line option flags */ struct { /* Extended section index data */ int checked; /* TRUE if already checked for shxndx */ Word *data; /* NULL, or extended section index */ /* used for symbol table entries */ uint_t n; /* # items in shxndx.data */ } shxndx; VERSYM_STATE *versym; /* NULL, or associated VERSYM section */ Sym *sym; /* Array of symbols */ Word symn; /* # of symbols */ } SYMTBL_STATE; /* * A variable of this type is used to track information related to * .eh_frame and .eh_frame_hdr sections across calls to unwind_eh_frame(). */ typedef struct { Word frame_cnt; /* # .eh_frame sections seen */ Word frame_ndx; /* Section index of 1st .eh_frame */ Word hdr_cnt; /* # .eh_frame_hdr sections seen */ Word hdr_ndx; /* Section index of 1st .eh_frame_hdr */ uint64_t frame_ptr; /* Value of FramePtr field from first */ /* .eh_frame_hdr section */ uint64_t frame_base; /* Data addr of 1st .eh_frame */ } gnu_eh_state_t; /* * C++ .exception_ranges entries make use of the signed ptrdiff_t * type to record self-relative pointer values. We need a type * for this that is matched to the ELFCLASS being processed. */ #if defined(_ELF64) typedef int64_t PTRDIFF_T; #else typedef int32_t PTRDIFF_T; #endif /* * The Sun C++ ABI uses this struct to define each .exception_ranges * entry. From the ABI: * * The field ret_addr is a self relative pointer to the start of the address * range. The name was chosen because in the current implementation the range * typically starts at the return address for a call site. * * The field length is the difference, in bytes, between the pc of the last * instruction covered by the exception range and the first. When only a * single call site is represented without optimization, this will equal zero. * * The field handler_addr is a relative pointer which stores the difference * between the start of the exception range and the address of all code to * catch exceptions and perform the cleanup for stack unwinding. * * The field type_block is a relative pointer which stores the difference * between the start of the exception range and the address of an array used * for storing a list of the types of exceptions which can be caught within * the exception range. */ typedef struct { PTRDIFF_T ret_addr; Xword length; PTRDIFF_T handler_addr; PTRDIFF_T type_block; Xword reserved; } exception_range_entry; /* * Focal point for verifying symbol names. */ static const char * string(Cache *refsec, Word ndx, Cache *strsec, const char *file, Word name) { /* * If an error in this routine is due to a property of the string * section, as opposed to a bad offset into the section (a property of * the referencing section), then we will detect the same error on * every call involving those sections. We use these static variables * to retain the information needed to only issue each such error once. */ static Cache *last_refsec; /* Last referencing section seen */ static int strsec_err; /* True if error issued */ const char *strs; Word strn; if ((strsec->c_data == NULL) || (strsec->c_data->d_buf == NULL)) return (NULL); strs = (char *)strsec->c_data->d_buf; strn = strsec->c_data->d_size; /* * We only print a diagnostic regarding a bad string table once per * input section being processed. If the refsec has changed, reset * our retained error state. */ if (last_refsec != refsec) { last_refsec = refsec; strsec_err = 0; } /* Verify that strsec really is a string table */ if (strsec->c_shdr->sh_type != SHT_STRTAB) { if (!strsec_err) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_NOTSTRTAB), file, strsec->c_ndx, refsec->c_ndx); strsec_err = 1; } return (MSG_INTL(MSG_STR_UNKNOWN)); } /* * Is the string table offset within range of the available strings? */ if (name >= strn) { /* * Do we have a empty string table? */ if (strs == NULL) { if (!strsec_err) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, strsec->c_name); strsec_err = 1; } } else { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSTOFF), file, refsec->c_name, EC_WORD(ndx), strsec->c_name, EC_WORD(name), EC_WORD(strn - 1)); } /* * Return the empty string so that the calling function can * continue it's output diagnostics. */ return (MSG_INTL(MSG_STR_UNKNOWN)); } return (strs + name); } /* * Relocations can reference section symbols and standard symbols. If the * former, establish the section name. */ static const char * relsymname(Cache *cache, Cache *csec, Cache *strsec, Word symndx, Word symnum, Word relndx, Sym *syms, char *secstr, size_t secsz, const char *file) { Sym *sym; const char *name; if (symndx >= symnum) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_RELBADSYMNDX), file, EC_WORD(symndx), EC_WORD(relndx)); return (MSG_INTL(MSG_STR_UNKNOWN)); } sym = (Sym *)(syms + symndx); name = string(csec, symndx, strsec, file, sym->st_name); /* * If the symbol represents a section offset construct an appropriate * string. Note, although section symbol table entries typically have * a NULL name pointer, entries do exist that point into the string * table to their own NULL strings. */ if ((ELF_ST_TYPE(sym->st_info) == STT_SECTION) && ((sym->st_name == 0) || (*name == '\0'))) { (void) snprintf(secstr, secsz, MSG_INTL(MSG_STR_SECTION), cache[sym->st_shndx].c_name); return ((const char *)secstr); } return (name); } /* * Focal point for establishing a string table section. Data such as the * dynamic information simply points to a string table. Data such as * relocations, reference a symbol table, which in turn is associated with a * string table. */ static int stringtbl(Cache *cache, int symtab, Word ndx, Word shnum, const char *file, Word *symnum, Cache **symsec, Cache **strsec) { Shdr *shdr = cache[ndx].c_shdr; /* * If symtab is non-zero, the ndx we are called with represents a * shdr which links to a symbol table (which then links to a string * table) */ if (symtab != 0) { /* * Validate the symbol table linkage. */ if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, cache[ndx].c_name, EC_WORD(shdr->sh_link)); return (0); } /* * Establish the symbol table index. */ ndx = shdr->sh_link; shdr = cache[ndx].c_shdr; if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, cache[ndx].c_name); return (0); } /* * Obtain, and verify the symbol table data. */ if ((cache[ndx].c_data == NULL) || (cache[ndx].c_data->d_buf == NULL)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, cache[ndx].c_name); return (0); } /* * Return symbol table information. */ if (symnum) *symnum = (shdr->sh_size / shdr->sh_entsize); if (symsec) *symsec = &cache[ndx]; } /* * Validate the string table linkage. */ if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, cache[ndx].c_name, EC_WORD(shdr->sh_link)); return (0); } if (strsec) *strsec = &cache[shdr->sh_link]; return (1); } /* * Lookup a symbol and set Sym accordingly. * * entry: * name - Name of symbol to lookup * cache - Cache of all section headers * shnum - # of sections in cache * sym - Address of pointer to receive symbol * target - NULL, or section to which the symbol must be associated. * symtab - Symbol table to search for symbol * file - Name of file * * exit: * If the symbol is found, *sym is set to reference it, and True is * returned. If target is non-NULL, the symbol must reference the given * section --- otherwise the section is not checked. * * If no symbol is found, False is returned. */ static int symlookup(const char *name, Cache *cache, Word shnum, Sym **sym, Cache *target, Cache *symtab, const char *file) { Shdr *shdr; Word symn, cnt; Sym *syms; if (symtab == 0) return (0); shdr = symtab->c_shdr; /* * Determine the symbol data and number. */ if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, symtab->c_name); return (0); } if ((symtab->c_data == NULL) || (symtab->c_data->d_buf == NULL)) return (0); /* LINTED */ symn = (Word)(shdr->sh_size / shdr->sh_entsize); syms = (Sym *)symtab->c_data->d_buf; /* * Get the associated string table section. */ if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, symtab->c_name, EC_WORD(shdr->sh_link)); return (0); } /* * Loop through the symbol table to find a match. */ *sym = NULL; for (cnt = 0; cnt < symn; syms++, cnt++) { const char *symname; symname = string(symtab, cnt, &cache[shdr->sh_link], file, syms->st_name); if (symname && (strcmp(name, symname) == 0) && ((target == NULL) || (target->c_ndx == syms->st_shndx))) { /* * It is possible, though rare, for a local and * global symbol of the same name to exist, each * contributed by a different input object. If the * symbol just found is local, remember it, but * continue looking. */ *sym = syms; if (ELF_ST_BIND(syms->st_info) != STB_LOCAL) break; } } return (*sym != NULL); } /* * Print section headers. */ static void sections(const char *file, Cache *cache, Word shnum, Ehdr *ehdr, uchar_t osabi) { size_t seccnt; for (seccnt = 1; seccnt < shnum; seccnt++) { Cache *_cache = &cache[seccnt]; Shdr *shdr = _cache->c_shdr; const char *secname = _cache->c_name; /* * Although numerous section header entries can be zero, it's * usually a sign of trouble if the type is zero. */ if (shdr->sh_type == 0) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHTYPE), file, secname, EC_WORD(shdr->sh_type)); } if (!match(MATCH_F_ALL, secname, seccnt, shdr->sh_type)) continue; /* * Identify any sections that are suspicious. A .got section * shouldn't exist in a relocatable object. */ if (ehdr->e_type == ET_REL) { if (strncmp(secname, MSG_ORIG(MSG_ELF_GOT), MSG_ELF_GOT_SIZE) == 0) { (void) fprintf(stderr, MSG_INTL(MSG_GOT_UNEXPECTED), file, secname); } } dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SHDR), EC_WORD(seccnt), secname); Elf_shdr(0, osabi, ehdr->e_machine, shdr); } } /* * Obtain a specified Phdr entry. */ static Phdr * getphdr(Word phnum, Word *type_arr, Word type_cnt, const char *file, Elf *elf, size_t *phndx) { Word cnt, tcnt; Phdr *phdr; if (phndx != NULL) *phndx = 0; if ((phdr = elf_getphdr(elf)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETPHDR)); return (NULL); } for (cnt = 0; cnt < phnum; phdr++, cnt++) { for (tcnt = 0; tcnt < type_cnt; tcnt++) { if (phdr->p_type == type_arr[tcnt]) { if (phndx != NULL) { *phndx = cnt; } return (phdr); } } } return (NULL); } /* * Display the contents of GNU/amd64 .eh_frame and .eh_frame_hdr * sections. * * entry: * cache - Cache of all section headers * shndx - Index of .eh_frame or .eh_frame_hdr section to be displayed * shnum - Total number of sections which exist * uphdr - NULL, or unwind program header associated with * the .eh_frame_hdr section. * ehdr - ELF header for file * eh_state - Data used across calls to this routine. The * caller should zero it before the first call, and * pass it on every call. * osabi - OSABI to use in displaying information * file - Name of file * flags - Command line option flags */ static void unwind_eh_frame(Cache *cache, Word shndx, Word shnum, Phdr *uphdr, Ehdr *ehdr, gnu_eh_state_t *eh_state, uchar_t osabi, const char *file, uint_t flags) { #if defined(_ELF64) #define MSG_UNW_BINSRTAB2 MSG_UNW_BINSRTAB2_64 #define MSG_UNW_BINSRTABENT MSG_UNW_BINSRTABENT_64 #else #define MSG_UNW_BINSRTAB2 MSG_UNW_BINSRTAB2_32 #define MSG_UNW_BINSRTABENT MSG_UNW_BINSRTABENT_32 #endif Cache *_cache = &cache[shndx]; Shdr *shdr = _cache->c_shdr; uchar_t *data = (uchar_t *)(_cache->c_data->d_buf); size_t datasize = _cache->c_data->d_size; Conv_dwarf_ehe_buf_t dwarf_ehe_buf; uint64_t ndx, frame_ptr, fde_cnt, tabndx; uint_t vers, frame_ptr_enc, fde_cnt_enc, table_enc; uint64_t initloc, initloc0 = 0; uint64_t gotaddr = 0; int cnt; for (cnt = 1; cnt < shnum; cnt++) { if (strncmp(cache[cnt].c_name, MSG_ORIG(MSG_ELF_GOT), MSG_ELF_GOT_SIZE) == 0) { gotaddr = cache[cnt].c_shdr->sh_addr; break; } } if ((data == NULL) || (datasize == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, _cache ->c_name); return; } /* * Is this a .eh_frame_hdr? */ if ((uphdr && (shdr->sh_addr == uphdr->p_vaddr)) || (strncmp(_cache->c_name, MSG_ORIG(MSG_SCN_FRMHDR), MSG_SCN_FRMHDR_SIZE) == 0)) { /* * There can only be a single .eh_frame_hdr. * Flag duplicates. */ if (++eh_state->hdr_cnt > 1) (void) fprintf(stderr, MSG_INTL(MSG_ERR_MULTEHFRMHDR), file, EC_WORD(shndx), _cache->c_name); dbg_print(0, MSG_ORIG(MSG_UNW_FRMHDR)); ndx = 0; vers = data[ndx++]; frame_ptr_enc = data[ndx++]; fde_cnt_enc = data[ndx++]; table_enc = data[ndx++]; dbg_print(0, MSG_ORIG(MSG_UNW_FRMVERS), vers); switch (dwarf_ehe_extract(data, datasize, &ndx, &frame_ptr, frame_ptr_enc, ehdr->e_ident, B_TRUE, shdr->sh_addr, ndx, gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, _cache->c_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), file, _cache->c_name, frame_ptr_enc); return; case DW_SUCCESS: break; } if (eh_state->hdr_cnt == 1) { eh_state->hdr_ndx = shndx; eh_state->frame_ptr = frame_ptr; } dbg_print(0, MSG_ORIG(MSG_UNW_FRPTRENC), conv_dwarf_ehe(frame_ptr_enc, &dwarf_ehe_buf), EC_XWORD(frame_ptr)); switch (dwarf_ehe_extract(data, datasize, &ndx, &fde_cnt, fde_cnt_enc, ehdr->e_ident, B_TRUE, shdr->sh_addr, ndx, gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, _cache->c_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), file, _cache->c_name, fde_cnt_enc); return; case DW_SUCCESS: break; } dbg_print(0, MSG_ORIG(MSG_UNW_FDCNENC), conv_dwarf_ehe(fde_cnt_enc, &dwarf_ehe_buf), EC_XWORD(fde_cnt)); dbg_print(0, MSG_ORIG(MSG_UNW_TABENC), conv_dwarf_ehe(table_enc, &dwarf_ehe_buf)); dbg_print(0, MSG_ORIG(MSG_UNW_BINSRTAB1)); dbg_print(0, MSG_ORIG(MSG_UNW_BINSRTAB2)); for (tabndx = 0; tabndx < fde_cnt; tabndx++) { uint64_t table; switch (dwarf_ehe_extract(data, datasize, &ndx, &initloc, table_enc, ehdr->e_ident, B_TRUE, shdr->sh_addr, ndx, gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, _cache->c_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), file, _cache->c_name, table_enc); return; case DW_SUCCESS: break; } if ((tabndx != 0) && (initloc0 > initloc)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSORT), file, _cache->c_name, EC_WORD(tabndx)); switch (dwarf_ehe_extract(data, datasize, &ndx, &table, table_enc, ehdr->e_ident, B_TRUE, shdr->sh_addr, ndx, gotaddr)) { case DW_OVERFLOW: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWOVRFLW), file, _cache->c_name); return; case DW_BAD_ENCODING: (void) fprintf(stderr, MSG_INTL(MSG_ERR_DWBADENC), file, _cache->c_name, table_enc); return; case DW_SUCCESS: break; } dbg_print(0, MSG_ORIG(MSG_UNW_BINSRTABENT), EC_XWORD(initloc), EC_XWORD(table)); initloc0 = initloc; } } else { /* Display the .eh_frame section */ eh_state->frame_cnt++; if (eh_state->frame_cnt == 1) { eh_state->frame_ndx = shndx; eh_state->frame_base = shdr->sh_addr; } else if ((eh_state->frame_cnt > 1) && (ehdr->e_type != ET_REL)) { Conv_inv_buf_t inv_buf; (void) fprintf(stderr, MSG_INTL(MSG_WARN_MULTEHFRM), file, EC_WORD(shndx), _cache->c_name, conv_ehdr_type(osabi, ehdr->e_type, 0, &inv_buf)); } dump_eh_frame(file, _cache->c_name, data, datasize, shdr->sh_addr, ehdr->e_machine, ehdr->e_ident, gotaddr); } /* * If we've seen the .eh_frame_hdr and the first .eh_frame section, * compare the header frame_ptr to the address of the actual frame * section to ensure the link-editor got this right. Note, this * diagnostic is only produced when unwind information is explicitly * asked for, as shared objects built with an older ld(1) may reveal * this inconsistency. Although an inconsistency, it doesn't seem to * have any adverse effect on existing tools. */ if (((flags & FLG_MASK_SHOW) != FLG_MASK_SHOW) && (eh_state->hdr_cnt > 0) && (eh_state->frame_cnt > 0) && (eh_state->frame_ptr != eh_state->frame_base)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADEHFRMPTR), file, EC_WORD(eh_state->hdr_ndx), cache[eh_state->hdr_ndx].c_name, EC_XWORD(eh_state->frame_ptr), EC_WORD(eh_state->frame_ndx), cache[eh_state->frame_ndx].c_name, EC_XWORD(eh_state->frame_base)); #undef MSG_UNW_BINSRTAB2 #undef MSG_UNW_BINSRTABENT } /* * Convert a self relative pointer into an address. A self relative * pointer adds the address where the pointer resides to the offset * contained in the pointer. The benefit is that the value of the * pointer does not require relocation. * * entry: * base_addr - Address of the pointer. * delta - Offset relative to base_addr giving desired address * * exit: * The computed address is returned. * * note: * base_addr is an unsigned value, while ret_addr is signed. This routine * used explicit testing and casting to explicitly control type * conversion, and ensure that we handle the maximum possible range. */ static Addr srelptr(Addr base_addr, PTRDIFF_T delta) { if (delta < 0) return (base_addr - (Addr) (-delta)); return (base_addr + (Addr) delta); } /* * Byte swap a PTRDIFF_T value. */ static PTRDIFF_T swap_ptrdiff(PTRDIFF_T value) { PTRDIFF_T r; uchar_t *dst = (uchar_t *)&r; uchar_t *src = (uchar_t *)&value; UL_ASSIGN_BSWAP_XWORD(dst, src); return (r); } /* * Display exception_range_entry items from the .exception_ranges section * of a Sun C++ object. */ static void unwind_exception_ranges(Cache *_cache, const char *file, int do_swap) { /* * Translate a PTRDIFF_T self-relative address field of * an exception_range_entry struct into an address. * * entry: * exc_addr - Address of base of exception_range_entry struct * cur_ent - Pointer to data in the struct to be translated * * _f - Field of struct to be translated */ #define SRELPTR(_f) \ srelptr(exc_addr + offsetof(exception_range_entry, _f), cur_ent->_f) #if defined(_ELF64) #define MSG_EXR_TITLE MSG_EXR_TITLE_64 #define MSG_EXR_ENTRY MSG_EXR_ENTRY_64 #else #define MSG_EXR_TITLE MSG_EXR_TITLE_32 #define MSG_EXR_ENTRY MSG_EXR_ENTRY_32 #endif exception_range_entry scratch, *ent, *cur_ent = &scratch; char index[MAXNDXSIZE]; Word i, nelts; Addr addr, addr0 = 0, offset = 0; Addr exc_addr = _cache->c_shdr->sh_addr; dbg_print(0, MSG_INTL(MSG_EXR_TITLE)); ent = (exception_range_entry *)(_cache->c_data->d_buf); nelts = _cache->c_data->d_size / sizeof (exception_range_entry); for (i = 0; i < nelts; i++, ent++) { if (do_swap) { /* * Copy byte swapped values into the scratch buffer. * The reserved field is not used, so we skip it. */ scratch.ret_addr = swap_ptrdiff(ent->ret_addr); scratch.length = BSWAP_XWORD(ent->length); scratch.handler_addr = swap_ptrdiff(ent->handler_addr); scratch.type_block = swap_ptrdiff(ent->type_block); } else { cur_ent = ent; } /* * The table is required to be sorted by the address * derived from ret_addr, to allow binary searching. Ensure * that addresses grow monotonically. */ addr = SRELPTR(ret_addr); if ((i != 0) && (addr0 > addr)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSORT), file, _cache->c_name, EC_WORD(i)); (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(i)); dbg_print(0, MSG_INTL(MSG_EXR_ENTRY), index, EC_ADDR(offset), EC_ADDR(addr), EC_ADDR(cur_ent->length), EC_ADDR(SRELPTR(handler_addr)), EC_ADDR(SRELPTR(type_block))); addr0 = addr; exc_addr += sizeof (exception_range_entry); offset += sizeof (exception_range_entry); } #undef SRELPTR #undef MSG_EXR_TITLE #undef MSG_EXR_ENTRY } /* * For program headers which reflect a single section, check that their values * and that of the section match. */ static void check_phdr_v_shdr(Phdr *phdr, size_t phndx, uchar_t osabi, Half mach, Cache *cache, const char *file) { Conv_inv_buf_t inv_buf; #define CHECK(str, pfield, sfield) \ if (phdr->pfield != cache->c_shdr->sfield) { \ fprintf(stderr, MSG_INTL(MSG_SHDR_PHDR_MISMATCH), \ file, \ cache->c_ndx, \ cache->c_name, \ str, \ conv_phdr_type(osabi, mach, phdr->p_type, \ CONV_FMT_ALT_CF, &inv_buf), \ #sfield, \ cache->c_shdr->sfield, \ phndx, \ #pfield, \ phdr->pfield); \ } CHECK(MSG_INTL(MSG_STR_VADDR), p_vaddr, sh_addr); CHECK(MSG_INTL(MSG_STR_OFFSET), p_offset, sh_offset); CHECK(MSG_INTL(MSG_STR_FILESIZE), p_filesz, sh_size); CHECK(MSG_INTL(MSG_STR_MEMSIZE), p_memsz, sh_size); CHECK(MSG_INTL(MSG_STR_ALIGNMENT), p_align, sh_addralign); #undef CHECK } /* * Display information from unwind/exception sections: * * - GNU/amd64 .eh_frame and .eh_frame_hdr * - Sun C++ .exception_ranges * */ static void unwind(Cache *cache, Word shnum, Word phnum, Ehdr *ehdr, uchar_t osabi, const char *file, Elf *elf, uint_t flags) { static Word phdr_types[] = { PT_SUNW_UNWIND, PT_SUNW_EH_FRAME }; Word cnt; Phdr *uphdr = NULL; size_t phndx; gnu_eh_state_t eh_state; /* * Historical background: .eh_frame and .eh_frame_hdr sections * come from the GNU compilers (particularly C++), and are used * under all architectures. Their format is based on DWARF. When * the amd64 ABI was defined, these sections were adopted wholesale * from the existing practice. * * When amd64 support was added to Solaris, support for these * sections was added, using the SHT_AMD64_UNWIND section type * to identify them. At first, we ignored them in objects for * non-amd64 targets, but later broadened our support to include * other architectures in order to better support gcc-generated * objects. * * .exception_ranges implement the same basic concepts, but * were invented at Sun for the Sun C++ compiler. * * We match these sections by name, rather than section type, * because they can come in as either SHT_AMD64_UNWIND, or as * SHT_PROGBITS, and because the type isn't enough to determine * how they should be interpreted. */ /* Find the program header for .eh_frame_hdr if present */ if (phnum) { uphdr = getphdr(phnum, phdr_types, sizeof (phdr_types) / sizeof (*phdr_types), file, elf, &phndx); } /* * eh_state is used to retain data used by unwind_eh_frame() * across calls. */ bzero(&eh_state, sizeof (eh_state)); for (cnt = 1; cnt < shnum; cnt++) { Cache *_cache = &cache[cnt]; Shdr *shdr = _cache->c_shdr; int is_exrange; /* * Skip sections of the wrong type. On amd64, they * can be SHT_AMD64_UNWIND. On all platforms, they * can be SHT_PROGBITS (including amd64, if using * the GNU compilers). * * Skip anything other than these two types. The name * test below will thin out the SHT_PROGBITS that don't apply. */ if ((shdr->sh_type != SHT_PROGBITS) && (shdr->sh_type != SHT_AMD64_UNWIND)) continue; /* * Only sections with certain well known names are of interest. * These are: * * .eh_frame - amd64/GNU-compiler unwind sections * .eh_frame_hdr - Sorted table referencing .eh_frame * .exception_ranges - Sun C++ unwind sections * * We do a prefix comparison, allowing for naming conventions * like .eh_frame.foo, hence the use of strncmp() rather than * strcmp(). This means that we only really need to test for * .eh_frame, as it's a prefix of .eh_frame_hdr. */ is_exrange = strncmp(_cache->c_name, MSG_ORIG(MSG_SCN_EXRANGE), MSG_SCN_EXRANGE_SIZE) == 0; if ((strncmp(_cache->c_name, MSG_ORIG(MSG_SCN_FRM), MSG_SCN_FRM_SIZE) != 0) && !is_exrange) continue; if (!match(MATCH_F_ALL, _cache->c_name, cnt, shdr->sh_type)) continue; if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_UNWIND), _cache->c_name); if (is_exrange) { unwind_exception_ranges(_cache, file, _elf_sys_encoding() != ehdr->e_ident[EI_DATA]); } else { if ((uphdr != NULL) && (strcmp(_cache->c_name, MSG_ORIG(MSG_SCN_FRMHDR)) == 0)) { check_phdr_v_shdr(uphdr, phndx, osabi, ehdr->e_machine, _cache, file); } unwind_eh_frame(cache, cnt, shnum, uphdr, ehdr, &eh_state, osabi, file, flags); } } } /* * Initialize a symbol table state structure * * entry: * state - State structure to be initialized * cache - Cache of all section headers * shnum - # of sections in cache * secndx - Index of symbol table section * ehdr - ELF header for file * versym - Information about versym section * file - Name of file * flags - Command line option flags */ static int init_symtbl_state(SYMTBL_STATE *state, Cache *cache, Word shnum, Word secndx, Ehdr *ehdr, uchar_t osabi, VERSYM_STATE *versym, const char *file, uint_t flags) { Shdr *shdr; state->file = file; state->ehdr = ehdr; state->cache = cache; state->osabi = osabi; state->shnum = shnum; state->seccache = &cache[secndx]; state->secndx = secndx; state->secname = state->seccache->c_name; state->flags = flags; state->shxndx.checked = 0; state->shxndx.data = NULL; state->shxndx.n = 0; shdr = state->seccache->c_shdr; /* * Check the symbol data and per-item size. */ if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, state->secname); return (0); } if ((state->seccache->c_data == NULL) || (state->seccache->c_data->d_buf == NULL)) return (0); /* LINTED */ state->symn = (Word)(shdr->sh_size / shdr->sh_entsize); state->sym = (Sym *)state->seccache->c_data->d_buf; /* * Check associated string table section. */ if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, state->secname, EC_WORD(shdr->sh_link)); return (0); } /* * Determine if there is a associated Versym section * with this Symbol Table. */ if (versym && versym->cache && (versym->cache->c_shdr->sh_link == state->secndx)) state->versym = versym; else state->versym = NULL; return (1); } /* * Determine the extended section index used for symbol tables entries. */ static void symbols_getxindex(SYMTBL_STATE *state) { uint_t symn; Word symcnt; state->shxndx.checked = 1; /* Note that we've been called */ for (symcnt = 1; symcnt < state->shnum; symcnt++) { Cache *_cache = &state->cache[symcnt]; Shdr *shdr = _cache->c_shdr; if ((shdr->sh_type != SHT_SYMTAB_SHNDX) || (shdr->sh_link != state->secndx)) continue; if (shdr->sh_entsize == 0) symn = 0; else symn = (uint_t)(shdr->sh_size / shdr->sh_entsize); if (symn == 0) continue; if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; state->shxndx.data = _cache->c_data->d_buf; state->shxndx.n = symn; return; } } /* * Produce a line of output for the given symbol * * entry: * state - Symbol table state * symndx - Index of symbol within the table * info - Value of st_info (indicates local/global range) * symndx_disp - Index to display. This may not be the same * as symndx if the display is relative to the logical * combination of the SUNW_ldynsym/dynsym tables. * sym - Symbol to display */ static void output_symbol(SYMTBL_STATE *state, Word symndx, Word info, Word disp_symndx, Sym *sym) { /* * Symbol types for which we check that the specified * address/size land inside the target section. */ static const int addr_symtype[] = { 0, /* STT_NOTYPE */ 1, /* STT_OBJECT */ 1, /* STT_FUNC */ 0, /* STT_SECTION */ 0, /* STT_FILE */ 1, /* STT_COMMON */ 0, /* STT_TLS */ 0, /* 7 */ 0, /* 8 */ 0, /* 9 */ 0, /* 10 */ 0, /* 11 */ 0, /* 12 */ 0, /* STT_SPARC_REGISTER */ 0, /* 14 */ 0, /* 15 */ }; #if STT_NUM != (STT_TLS + 1) #error "STT_NUM has grown. Update addr_symtype[]" #endif char index[MAXNDXSIZE]; const char *symname, *sec; Versym verndx; int gnuver; uchar_t type; Shdr *tshdr; Word shndx = 0; Conv_inv_buf_t inv_buf; /* Ensure symbol index is in range */ if (symndx >= state->symn) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYMNDX), state->file, state->secname, EC_WORD(symndx)); return; } /* * If we are using extended symbol indexes, find the * corresponding SHN_SYMTAB_SHNDX table. */ if ((sym->st_shndx == SHN_XINDEX) && (state->shxndx.checked == 0)) symbols_getxindex(state); /* LINTED */ symname = string(state->seccache, symndx, &state->cache[state->seccache->c_shdr->sh_link], state->file, sym->st_name); tshdr = NULL; sec = NULL; if (state->ehdr->e_type == ET_CORE) { sec = (char *)MSG_INTL(MSG_STR_UNKNOWN); } else if (state->flags & FLG_CTL_FAKESHDR) { /* * If we are using fake section headers derived from * the program headers, then the section indexes * in the symbols do not correspond to these headers. * The section names are not available, so all we can * do is to display them in numeric form. */ sec = conv_sym_shndx(state->osabi, state->ehdr->e_machine, sym->st_shndx, CONV_FMT_DECIMAL, &inv_buf); } else if ((sym->st_shndx < SHN_LORESERVE) && (sym->st_shndx < state->shnum)) { shndx = sym->st_shndx; tshdr = state->cache[shndx].c_shdr; sec = state->cache[shndx].c_name; } else if (sym->st_shndx == SHN_XINDEX) { if (state->shxndx.data) { Word _shxndx; if (symndx > state->shxndx.n) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYMXINDEX1), state->file, state->secname, EC_WORD(symndx)); } else if ((_shxndx = state->shxndx.data[symndx]) > state->shnum) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYMXINDEX2), state->file, state->secname, EC_WORD(symndx), EC_WORD(_shxndx)); } else { shndx = _shxndx; tshdr = state->cache[shndx].c_shdr; sec = state->cache[shndx].c_name; } } else { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYMXINDEX3), state->file, state->secname, EC_WORD(symndx)); } } else if ((sym->st_shndx < SHN_LORESERVE) && (sym->st_shndx >= state->shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYM5), state->file, state->secname, EC_WORD(symndx), demangle(symname, state->flags), sym->st_shndx); } /* * If versioning is available display the * version index. If not, then use 0. */ if (state->versym) { Versym test_verndx; verndx = test_verndx = state->versym->data[symndx]; gnuver = state->versym->gnu_full; /* * Check to see if this is a defined symbol with a * version index that is outside the valid range for * the file. The interpretation of this depends on * the style of versioning used by the object. * * Versions >= VER_NDX_LORESERVE have special meanings, * and are exempt from this checking. * * GNU style version indexes use the top bit of the * 16-bit index value (0x8000) as the "hidden bit". * We must mask off this bit in order to compare * the version against the maximum value. */ if (gnuver) test_verndx &= ~0x8000; if ((test_verndx > state->versym->max_verndx) && (verndx < VER_NDX_LORESERVE)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADVER), state->file, state->secname, EC_WORD(symndx), EC_HALF(test_verndx), state->versym->max_verndx); } else { verndx = 0; gnuver = 0; } /* * Error checking for TLS. */ type = ELF_ST_TYPE(sym->st_info); if (type == STT_TLS) { if (tshdr && (sym->st_shndx != SHN_UNDEF) && ((tshdr->sh_flags & SHF_TLS) == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYM3), state->file, state->secname, EC_WORD(symndx), demangle(symname, state->flags)); } } else if ((type != STT_SECTION) && sym->st_size && tshdr && (tshdr->sh_flags & SHF_TLS)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYM4), state->file, state->secname, EC_WORD(symndx), demangle(symname, state->flags)); } /* * If a symbol with non-zero size has a type that * specifies an address, then make sure the location * it references is actually contained within the * section. UNDEF symbols don't count in this case, * so we ignore them. * * The meaning of the st_value field in a symbol * depends on the type of object. For a relocatable * object, it is the offset within the section. * For sharable objects, it is the offset relative to * the base of the object, and for other types, it is * the virtual address. To get an offset within the * section for non-ET_REL files, we subtract the * base address of the section. */ if (addr_symtype[type] && (sym->st_size > 0) && (sym->st_shndx != SHN_UNDEF) && ((sym->st_shndx < SHN_LORESERVE) || (sym->st_shndx == SHN_XINDEX)) && (tshdr != NULL)) { Word v = sym->st_value; if (state->ehdr->e_type != ET_REL) v -= tshdr->sh_addr; if (((v + sym->st_size) > tshdr->sh_size)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYM6), state->file, state->secname, EC_WORD(symndx), demangle(symname, state->flags), EC_WORD(shndx), EC_XWORD(tshdr->sh_size), EC_XWORD(sym->st_value), EC_XWORD(sym->st_size)); } } /* * A typical symbol table uses the sh_info field to indicate one greater * than the symbol table index of the last local symbol, STB_LOCAL. * Therefore, symbol indexes less than sh_info should have local * binding. Symbol indexes greater than, or equal to sh_info, should * have global binding. Note, we exclude UNDEF/NOTY symbols with zero * value and size, as these symbols may be the result of an mcs(1) * section deletion. */ if (info) { uchar_t bind = ELF_ST_BIND(sym->st_info); if ((symndx < info) && (bind != STB_LOCAL)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYM7), state->file, state->secname, EC_WORD(symndx), demangle(symname, state->flags), EC_XWORD(info)); } else if ((symndx >= info) && (bind == STB_LOCAL) && ((sym->st_shndx != SHN_UNDEF) || (ELF_ST_TYPE(sym->st_info) != STT_NOTYPE) || (sym->st_size != 0) || (sym->st_value != 0))) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYM8), state->file, state->secname, EC_WORD(symndx), demangle(symname, state->flags), EC_XWORD(info)); } } (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(disp_symndx)); Elf_syms_table_entry(0, ELF_DBG_ELFDUMP, index, state->osabi, state->ehdr->e_machine, sym, verndx, gnuver, sec, symname); } /* * Process a SHT_SUNW_cap capabilities section. */ static int cap_section(const char *file, Cache *cache, Word shnum, Cache *ccache, uchar_t osabi, Ehdr *ehdr, uint_t flags) { SYMTBL_STATE state; Word cnum, capnum, nulls, symcaps; int descapndx, objcap, title; Cap *cap = (Cap *)ccache->c_data->d_buf; Shdr *cishdr = NULL, *cshdr = ccache->c_shdr; Cache *cicache = NULL, *strcache = NULL; Capinfo *capinfo = NULL; Word capinfonum = 0; const char *strs = NULL; size_t strs_size = 0; if ((cshdr->sh_entsize == 0) || (cshdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, ccache->c_name); return (0); } /* * If this capabilities section is associated with symbols, then the * sh_link field points to the associated capabilities information * section. The sh_link field of the capabilities information section * points to the associated symbol table. */ if (cshdr->sh_link) { Cache *scache; Shdr *sshdr; /* * Validate that the sh_link field points to a capabilities * information section. */ if (cshdr->sh_link >= shnum) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, ccache->c_name, EC_WORD(cshdr->sh_link)); return (0); } cicache = &cache[cshdr->sh_link]; cishdr = cicache->c_shdr; if (cishdr->sh_type != SHT_SUNW_capinfo) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_INVCAP), file, ccache->c_name, EC_WORD(cshdr->sh_link)); return (0); } capinfo = cicache->c_data->d_buf; capinfonum = (Word)(cishdr->sh_size / cishdr->sh_entsize); /* * Validate that the sh_link field of the capabilities * information section points to a valid symbol table. */ if ((cishdr->sh_link == 0) || (cishdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, cicache->c_name, EC_WORD(cishdr->sh_link)); return (0); } scache = &cache[cishdr->sh_link]; sshdr = scache->c_shdr; if ((sshdr->sh_type != SHT_SYMTAB) && (sshdr->sh_type != SHT_DYNSYM)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_INVCAPINFO1), file, cicache->c_name, EC_WORD(cishdr->sh_link)); return (0); } if (!init_symtbl_state(&state, cache, shnum, cishdr->sh_link, ehdr, osabi, NULL, file, flags)) return (0); } /* * If this capabilities section contains capability string entries, * then determine the associated string table. Capabilities entries * that define names require that the capability section indicate * which string table to use via sh_info. */ if (cshdr->sh_info) { Shdr *strshdr; /* * Validate that the sh_info field points to a string table. */ if (cshdr->sh_info >= shnum) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, ccache->c_name, EC_WORD(cshdr->sh_info)); return (0); } strcache = &cache[cshdr->sh_info]; strshdr = strcache->c_shdr; if (strshdr->sh_type != SHT_STRTAB) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_INVCAP), file, ccache->c_name, EC_WORD(cshdr->sh_info)); return (0); } strs = (const char *)strcache->c_data->d_buf; strs_size = strcache->c_data->d_size; } dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_CAP), ccache->c_name); capnum = (Word)(cshdr->sh_size / cshdr->sh_entsize); nulls = symcaps = 0; objcap = title = 1; descapndx = -1; /* * Traverse the capabilities section printing each capability group. * The first capabilities group defines any object capabilities. Any * following groups define symbol capabilities. In the case where no * object capabilities exist, but symbol capabilities do, a single * CA_SUNW_NULL terminator for the object capabilities exists. */ for (cnum = 0; cnum < capnum; cap++, cnum++) { if (cap->c_tag == CA_SUNW_NULL) { /* * A CA_SUNW_NULL tag terminates a capabilities group. * If the first capabilities tag is CA_SUNW_NULL, then * no object capabilities exist. */ if ((nulls++ == 0) && (cnum == 0)) objcap = 0; title = 1; } else { if (title) { if (nulls == 0) { /* * If this capabilities group represents * the object capabilities (i.e., no * CA_SUNW_NULL tag has been processed * yet), then display an object * capabilities title. */ dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_OBJ_CAP_TITLE)); } else { /* * If this is a symbols capabilities * group (i.e., a CA_SUNW_NULL tag has * already be found that terminates * the object capabilities group), then * display a symbol capabilities title, * and retain this capabilities index * for later processing. */ dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_SYM_CAP_TITLE)); descapndx = cnum; } Elf_cap_title(0); title = 0; } /* * Print the capabilities data. * * Note that CA_SUNW_PLAT, CA_SUNW_MACH and CA_SUNW_ID * entries require a string table, which should have * already been established. */ if ((strs == NULL) && ((cap->c_tag == CA_SUNW_PLAT) || (cap->c_tag == CA_SUNW_MACH) || (cap->c_tag == CA_SUNW_ID))) { (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVCAP3), file, EC_WORD(elf_ndxscn(ccache->c_scn)), ccache->c_name, EC_WORD(cshdr->sh_info)); } Elf_cap_entry(0, cap, cnum, strs, strs_size, ehdr->e_machine); } /* * If this CA_SUNW_NULL tag terminates a symbol capabilities * group, determine the associated symbols. */ if ((cap->c_tag == CA_SUNW_NULL) && (nulls > 1) && (descapndx != -1)) { Capinfo *cip; Word inum; symcaps++; /* * Make sure we've discovered a SHT_SUNW_capinfo table. */ if ((cip = capinfo) == NULL) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_INVCAP), file, ccache->c_name, EC_WORD(cshdr->sh_link)); return (0); } /* * Determine what symbols reference this capabilities * group. */ dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_CAPINFO_ENTRIES)); Elf_syms_table_title(0, ELF_DBG_ELFDUMP); for (inum = 1, cip++; inum < capinfonum; inum++, cip++) { Word gndx = (Word)ELF_C_GROUP(*cip); if (gndx && (gndx == descapndx)) { output_symbol(&state, inum, 0, inum, state.sym + inum); } } descapndx = -1; continue; } /* * An SF1_SUNW_ADDR32 software capability tag in a 32-bit * object is suspicious as it has no effect. */ if ((cap->c_tag == CA_SUNW_SF_1) && (ehdr->e_ident[EI_CLASS] == ELFCLASS32) && (cap->c_un.c_val & SF1_SUNW_ADDR32)) { (void) fprintf(stderr, MSG_INTL(MSG_WARN_INADDR32SF1), file, ccache->c_name); } } /* * If this is a dynamic object, with symbol capabilities, then a * .SUNW_capchain section should exist. This section contains a chain * of symbol indexes for each capabilities family. This is the list * that is searched by ld.so.1 to determine the best capabilities * candidate. * * Note, more than one capabilities lead symbol can point to the same * family chain. For example, a weak/global pair of symbols can both * represent the same family of capabilities symbols. Therefore, to * display all possible families we traverse the capabilities * information section looking for CAPINFO_SUNW_GLOB lead symbols. * From these we determine the associated capabilities chain to inspect. */ if (symcaps && ((ehdr->e_type == ET_EXEC) || (ehdr->e_type == ET_DYN))) { Capinfo *cip; Capchain *chain; Cache *chcache; Shdr *chshdr; Word chainnum, inum; /* * Validate that the sh_info field of the capabilities * information section points to a capabilities chain section. */ if (cishdr->sh_info >= shnum) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, cicache->c_name, EC_WORD(cishdr->sh_info)); return (0); } chcache = &cache[cishdr->sh_info]; chshdr = chcache->c_shdr; if (chshdr->sh_type != SHT_SUNW_capchain) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_INVCAPINFO2), file, cicache->c_name, EC_WORD(cishdr->sh_info)); return (0); } chainnum = (Word)(chshdr->sh_size / chshdr->sh_entsize); chain = (Capchain *)chcache->c_data->d_buf; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_CAPCHAIN), chcache->c_name); /* * Traverse the capabilities information section looking for * CAPINFO_SUNW_GLOB lead capabilities symbols. */ cip = capinfo; for (inum = 1, cip++; inum < capinfonum; inum++, cip++) { const char *name; Sym *sym; Word sndx, cndx; Word gndx = (Word)ELF_C_GROUP(*cip); if ((gndx == 0) || (gndx != CAPINFO_SUNW_GLOB)) continue; /* * Determine the symbol that is associated with this * capability information entry, and use this to * identify this capability family. */ sym = (Sym *)(state.sym + inum); name = string(cicache, inum, strcache, file, sym->st_name); dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_CAPCHAIN_TITLE), name); dbg_print(0, MSG_INTL(MSG_CAPCHAIN_ENTRY)); cndx = (Word)ELF_C_SYM(*cip); /* * Traverse this families chain and identify each * family member. */ for (;;) { char _chain[MAXNDXSIZE], _symndx[MAXNDXSIZE]; if (cndx >= chainnum) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_INVCAPINFO3), file, cicache->c_name, EC_WORD(inum), EC_WORD(cndx)); break; } if ((sndx = chain[cndx]) == 0) break; /* * Determine this entries symbol reference. */ if (sndx > state.symn) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_CHBADSYMNDX), file, EC_WORD(sndx), chcache->c_name, EC_WORD(cndx)); name = MSG_INTL(MSG_STR_UNKNOWN); } else { sym = (Sym *)(state.sym + sndx); name = string(chcache, sndx, strcache, file, sym->st_name); } /* * Display the family member. */ (void) snprintf(_chain, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INTEGER), cndx); (void) snprintf(_symndx, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(sndx)); dbg_print(0, MSG_ORIG(MSG_FMT_CHAIN_INFO), _chain, _symndx, demangle(name, flags)); cndx++; } } } return (objcap); } /* * Print the capabilities. * * A .SUNW_cap section can contain one or more, CA_SUNW_NULL terminated, * capabilities groups. The first group defines the object capabilities. * This group defines the minimum capability requirements of the entire * object file. If this is a dynamic object, this group should be associated * with a PT_SUNWCAP program header. * * Additional capabilities groups define the association of individual symbols * to specific capabilities. */ static void cap(const char *file, Cache *cache, Word shnum, Word phnum, Ehdr *ehdr, uchar_t osabi, Elf *elf, uint_t flags) { Word cnt; Shdr *cshdr = NULL; Cache *ccache = NULL; Phdr *uphdr = NULL; size_t phndx; /* * Determine if a global capabilities header exists. */ if (phnum) { Phdr *phdr; if ((phdr = elf_getphdr(elf)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETPHDR)); return; } for (cnt = 0; cnt < phnum; phdr++, cnt++) { if (phdr->p_type == PT_SUNWCAP) { uphdr = phdr; phndx = cnt; break; } } } /* * Determine if a capabilities section exists. */ for (cnt = 1; cnt < shnum; cnt++) { Cache *_cache = &cache[cnt]; Shdr *shdr = _cache->c_shdr; /* * Process any capabilities information. */ if (shdr->sh_type == SHT_SUNW_cap) { if (cap_section(file, cache, shnum, _cache, osabi, ehdr, flags)) { /* * If this section defined an object capability * group, retain the section information for * program header validation. */ ccache = _cache; cshdr = shdr; } continue; } } if ((cshdr == NULL) && (uphdr == NULL)) return; if ((uphdr != NULL) && (cshdr == NULL)) (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVCAP1), file); /* * If this object is an executable or shared object, and it provided * an object capabilities group, then the group should have an * accompanying PT_SUNWCAP program header. */ if (cshdr && ((ehdr->e_type == ET_EXEC) || (ehdr->e_type == ET_DYN))) { if (uphdr == NULL) { (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVCAP2), file, EC_WORD(elf_ndxscn(ccache->c_scn)), ccache->c_name); } else { check_phdr_v_shdr(uphdr, phndx, osabi, ehdr->e_machine, ccache, file); } } } /* * Print the interpreter. */ static void interp(const char *file, Cache *cache, Word shnum, Word phnum, Elf *elf, Ehdr *ehdr) { static Word phdr_types[] = { PT_INTERP }; Word cnt; Shdr *ishdr = NULL; Cache *icache = NULL; Phdr *iphdr = NULL; size_t phndx; /* * Determine if an interp header exists. */ if (phnum) { iphdr = getphdr(phnum, phdr_types, sizeof (phdr_types) / sizeof (*phdr_types), file, elf, &phndx); } if (iphdr == NULL) return; /* * Determine if an interp section exists. */ for (cnt = 1; cnt < shnum; cnt++) { Cache *_cache = &cache[cnt]; Shdr *shdr = _cache->c_shdr; /* * Scan sections to find a section which contains the PT_INTERP * string. The target section can't be in a NOBITS section. */ if ((shdr->sh_type == SHT_NOBITS) || (iphdr->p_offset < shdr->sh_offset) || (iphdr->p_offset + iphdr->p_filesz) > (shdr->sh_offset + shdr->sh_size)) continue; icache = _cache; ishdr = shdr; break; } /* * Print the interpreter string based on the offset defined in the * program header, as this is the offset used by the kernel. */ if ((ishdr != NULL) && (icache != NULL) && (icache->c_data != NULL) && (icache->c_data->d_buf != NULL) && (icache->c_data->d_size > 0)) { dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_INTERP), icache->c_name); dbg_print(0, MSG_ORIG(MSG_FMT_INDENT), (char *)icache->c_data->d_buf + (iphdr->p_offset - ishdr->sh_offset)); } else { (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVINTERP1), file); } /* * If there are any inconsistences between the program header and * section information, flag them. */ if (icache != NULL) { check_phdr_v_shdr(iphdr, phndx, ELFOSABI_SOLARIS, ehdr->e_machine, icache, file); } } /* * Print the syminfo section. */ static void syminfo(Cache *cache, Word shnum, Ehdr *ehdr, uchar_t osabi, const char *file) { Shdr *infoshdr; Syminfo *info; Sym *syms; Dyn *dyns; Word infonum, cnt, ndx, symnum, dynnum; Cache *infocache = NULL, *dyncache = NULL, *symsec, *strsec; Boolean *dynerr = NULL; for (cnt = 1; cnt < shnum; cnt++) { if (cache[cnt].c_shdr->sh_type == SHT_SUNW_syminfo) { infocache = &cache[cnt]; break; } } if (infocache == NULL) return; infoshdr = infocache->c_shdr; if ((infoshdr->sh_entsize == 0) || (infoshdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, infocache->c_name); return; } if ((infocache->c_data == NULL) || (infocache->c_data->d_buf == NULL)) return; infonum = (Word)(infoshdr->sh_size / infoshdr->sh_entsize); info = (Syminfo *)infocache->c_data->d_buf; /* * If there is no associated dynamic section, determine if one * is needed, and if so issue a warning. If there is an * associated dynamic section, validate it and get the data buffer * for it. */ dyns = NULL; dynnum = 0; if (infoshdr->sh_info == 0) { Syminfo *_info = info + 1; for (ndx = 1; ndx < infonum; ndx++, _info++) { if ((_info->si_flags == 0) && (_info->si_boundto == 0)) continue; if (_info->si_boundto < SYMINFO_BT_LOWRESERVE) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHINFO), file, infocache->c_name, EC_WORD(infoshdr->sh_info)); } } else if ((infoshdr->sh_info >= shnum) || (cache[infoshdr->sh_info].c_shdr->sh_type != SHT_DYNAMIC)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHINFO), file, infocache->c_name, EC_WORD(infoshdr->sh_info)); } else { dyncache = &cache[infoshdr->sh_info]; if ((dyncache->c_data == NULL) || ((dyns = dyncache->c_data->d_buf) == NULL)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, dyncache->c_name); } if (dyns != NULL) { if ((dyncache->c_shdr->sh_entsize == 0) || (dyncache->c_shdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, dyncache->c_name); return; } dynnum = dyncache->c_shdr->sh_size / dyncache->c_shdr->sh_entsize; /* * We validate the type of dynamic elements referenced * from the syminfo. This array is used report any * bad dynamic entries. */ if ((dynerr = calloc(dynnum, sizeof (*dynerr))) == NULL) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), file, strerror(err)); return; } } } /* * Get the data buffer for the associated symbol table and string table. */ if (stringtbl(cache, 1, cnt, shnum, file, &symnum, &symsec, &strsec) == 0) return; syms = symsec->c_data->d_buf; /* * Loop through the syminfo entries. */ dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_SYMINFO), infocache->c_name); Elf_syminfo_title(0); for (ndx = 1, info++; ndx < infonum; ndx++, info++) { Sym *sym; const char *needed, *name; Word expect_dt; Word boundto = info->si_boundto; if ((info->si_flags == 0) && (boundto == 0)) continue; sym = &syms[ndx]; name = string(infocache, ndx, strsec, file, sym->st_name); /* Is si_boundto set to one of the reserved values? */ if (boundto >= SYMINFO_BT_LOWRESERVE) { Elf_syminfo_entry(0, ndx, info, name, NULL); continue; } /* * si_boundto is referencing a dynamic section. If we don't * have one, an error was already issued above, so it suffices * to display an empty string. If we are out of bounds, then * report that and then display an empty string. */ if ((dyns == NULL) || (boundto >= dynnum)) { if (dyns != NULL) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSIDYNNDX), file, infocache->c_ndx, infocache->c_name, EC_WORD(ndx), EC_WORD(dynnum - 1), EC_WORD(boundto)); Elf_syminfo_entry(0, ndx, info, name, MSG_ORIG(MSG_STR_EMPTY)); continue; } /* * The si_boundto reference expects a specific dynamic element * type at the given index. The dynamic element is always a * string that gives an object name. The specific type depends * on the si_flags present. Ensure that we've got the right * type. */ if (info->si_flags & SYMINFO_FLG_FILTER) expect_dt = DT_SUNW_FILTER; else if (info->si_flags & SYMINFO_FLG_AUXILIARY) expect_dt = DT_SUNW_AUXILIARY; else if (info->si_flags & (SYMINFO_FLG_DIRECT | SYMINFO_FLG_LAZYLOAD | SYMINFO_FLG_DIRECTBIND)) expect_dt = DT_NEEDED; else expect_dt = DT_NULL; /* means we ignore the type */ if ((dyns[boundto].d_tag != expect_dt) && (expect_dt != DT_NULL)) { Conv_inv_buf_t buf1, buf2; /* Only complain about each dynamic element once */ if (!dynerr[boundto]) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSIDYNTAG), file, infocache->c_ndx, infocache->c_name, EC_WORD(ndx), dyncache->c_ndx, dyncache->c_name, EC_WORD(boundto), conv_dyn_tag(expect_dt, osabi, ehdr->e_machine, CONV_FMT_ALT_CF, &buf1), conv_dyn_tag(dyns[boundto].d_tag, osabi, ehdr->e_machine, CONV_FMT_ALT_CF, &buf2)); dynerr[boundto] = TRUE; } } /* * Whether or not the DT item we're pointing at is * of the right type, if it's a type we recognize as * providing a string, go ahead and show it. Otherwise * an empty string. */ switch (dyns[boundto].d_tag) { case DT_NEEDED: case DT_SONAME: case DT_RPATH: case DT_RUNPATH: case DT_CONFIG: case DT_DEPAUDIT: case DT_USED: case DT_AUDIT: case DT_SUNW_AUXILIARY: case DT_SUNW_FILTER: case DT_FILTER: case DT_AUXILIARY: needed = string(infocache, boundto, strsec, file, dyns[boundto].d_un.d_val); break; default: needed = MSG_ORIG(MSG_STR_EMPTY); } Elf_syminfo_entry(0, ndx, info, name, needed); } if (dyns != NULL) free(dynerr); } /* * Print version definition section entries. */ static void version_def(Verdef *vdf, Word vdf_num, Cache *vcache, Cache *scache, const char *file) { Word cnt; char index[MAXNDXSIZE]; Elf_ver_def_title(0); for (cnt = 1; cnt <= vdf_num; cnt++, vdf = (Verdef *)((uintptr_t)vdf + vdf->vd_next)) { Conv_ver_flags_buf_t ver_flags_buf; const char *name, *dep; Half vcnt = vdf->vd_cnt - 1; Half ndx = vdf->vd_ndx; Verdaux *vdap = (Verdaux *)((uintptr_t)vdf + vdf->vd_aux); /* * Obtain the name and first dependency (if any). */ name = string(vcache, cnt, scache, file, vdap->vda_name); vdap = (Verdaux *)((uintptr_t)vdap + vdap->vda_next); if (vcnt) dep = string(vcache, cnt, scache, file, vdap->vda_name); else dep = MSG_ORIG(MSG_STR_EMPTY); (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(ndx)); Elf_ver_line_1(0, index, name, dep, conv_ver_flags(vdf->vd_flags, 0, &ver_flags_buf)); /* * Print any additional dependencies. */ if (vcnt) { vdap = (Verdaux *)((uintptr_t)vdap + vdap->vda_next); for (vcnt--; vcnt; vcnt--, vdap = (Verdaux *)((uintptr_t)vdap + vdap->vda_next)) { dep = string(vcache, cnt, scache, file, vdap->vda_name); Elf_ver_line_2(0, MSG_ORIG(MSG_STR_EMPTY), dep); } } } } /* * Print version needed section entries. * * entry: * vnd - Address of verneed data * vnd_num - # of Verneed entries * vcache - Cache of verneed section being processed * scache - Cache of associated string table section * file - Name of object being processed. * versym - Information about versym section * * exit: * The versions have been printed. If GNU style versioning * is in effect, versym->max_verndx has been updated to * contain the largest version index seen. * * note: * The versym section of an object that follows the original * Solaris versioning rules only contains indexes into the verdef * section. Symbols defined in other objects (UNDEF) are given * a version of 0, indicating that they are not defined by * this file, and the Verneed entries do not have associated version * indexes. For these reasons, we do not display a version index * for original-style Verneed sections. * * The GNU versioning extensions alter this: Symbols defined in other * objects receive a version index in the range above those defined * by the Verdef section, and the vna_other field of the Vernaux * structs inside the Verneed section contain the version index for * that item. We therefore display the index when showing the * contents of a GNU style Verneed section. You should not * necessarily expect these indexes to appear in sorted * order --- it seems that the GNU ld assigns the versions as * symbols are encountered during linking, and then the results * are assembled into the Verneed section afterwards. */ static void version_need(Verneed *vnd, Word vnd_num, Cache *vcache, Cache *scache, const char *file, VERSYM_STATE *versym) { Word cnt; char index[MAXNDXSIZE]; const char *index_str; Elf_ver_need_title(0, versym->gnu_needed); for (cnt = 1; cnt <= vnd_num; cnt++, vnd = (Verneed *)((uintptr_t)vnd + vnd->vn_next)) { Conv_ver_flags_buf_t ver_flags_buf; const char *name, *dep; Half vcnt = vnd->vn_cnt; Vernaux *vnap = (Vernaux *)((uintptr_t)vnd + vnd->vn_aux); /* * Obtain the name of the needed file and the version name * within it that we're dependent on. Note that the count * should be at least one, otherwise this is a pretty bogus * entry. */ name = string(vcache, cnt, scache, file, vnd->vn_file); if (vcnt) dep = string(vcache, cnt, scache, file, vnap->vna_name); else dep = MSG_INTL(MSG_STR_NULL); if (vnap->vna_other == 0) { /* Traditional form */ index_str = MSG_ORIG(MSG_STR_EMPTY); } else { /* GNU form */ index_str = index; /* Format the version index value */ (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(vnap->vna_other)); if (vnap->vna_other > versym->max_verndx) versym->max_verndx = vnap->vna_other; } Elf_ver_line_1(0, index_str, name, dep, conv_ver_flags(vnap->vna_flags, 0, &ver_flags_buf)); /* * Print any additional version dependencies. */ if (vcnt) { vnap = (Vernaux *)((uintptr_t)vnap + vnap->vna_next); for (vcnt--; vcnt; vcnt--, vnap = (Vernaux *)((uintptr_t)vnap + vnap->vna_next)) { dep = string(vcache, cnt, scache, file, vnap->vna_name); if (vnap->vna_other > 0) { /* Format the next index value */ (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(vnap->vna_other)); Elf_ver_line_1(0, index, MSG_ORIG(MSG_STR_EMPTY), dep, conv_ver_flags(vnap->vna_flags, 0, &ver_flags_buf)); if (vnap->vna_other > versym->max_verndx) versym->max_verndx = vnap->vna_other; } else { Elf_ver_line_3(0, MSG_ORIG(MSG_STR_EMPTY), dep, conv_ver_flags(vnap->vna_flags, 0, &ver_flags_buf)); } } } } } /* * Examine the Verneed section for information related to GNU * style Versym indexing: * - A non-zero vna_other field indicates that Versym indexes can * reference Verneed records. * - If the object uses GNU style Versym indexing, the * maximum index value is needed to detect bad Versym entries. * * entry: * vnd - Address of verneed data * vnd_num - # of Verneed entries * versym - Information about versym section * * exit: * If a non-zero vna_other field is seen, versym->gnu_needed is set. * * versym->max_verndx has been updated to contain the largest * version index seen. */ static void update_gnu_verndx(Verneed *vnd, Word vnd_num, VERSYM_STATE *versym) { Word cnt; for (cnt = 1; cnt <= vnd_num; cnt++, vnd = (Verneed *)((uintptr_t)vnd + vnd->vn_next)) { Half vcnt = vnd->vn_cnt; Vernaux *vnap = (Vernaux *)((uintptr_t)vnd + vnd->vn_aux); /* * A non-zero value of vna_other indicates that this * object references VERNEED items from the VERSYM * array. */ if (vnap->vna_other != 0) { versym->gnu_needed = 1; if (vnap->vna_other > versym->max_verndx) versym->max_verndx = vnap->vna_other; } /* * Check any additional version dependencies. */ if (vcnt) { vnap = (Vernaux *)((uintptr_t)vnap + vnap->vna_next); for (vcnt--; vcnt; vcnt--, vnap = (Vernaux *)((uintptr_t)vnap + vnap->vna_next)) { if (vnap->vna_other == 0) continue; versym->gnu_needed = 1; if (vnap->vna_other > versym->max_verndx) versym->max_verndx = vnap->vna_other; } } } } /* * Display version section information if the flags require it. * Return version information needed by other output. * * entry: * cache - Cache of all section headers * shnum - # of sections in cache * file - Name of file * flags - Command line option flags * versym - VERSYM_STATE block to be filled in. */ static void versions(Cache *cache, Word shnum, const char *file, uint_t flags, VERSYM_STATE *versym) { GElf_Word cnt; Cache *verdef_cache = NULL, *verneed_cache = NULL; /* Gather information about the version sections */ versym->max_verndx = 1; for (cnt = 1; cnt < shnum; cnt++) { Cache *_cache = &cache[cnt]; Shdr *shdr = _cache->c_shdr; Dyn *dyn; ulong_t numdyn; switch (shdr->sh_type) { case SHT_DYNAMIC: /* * The GNU ld puts a DT_VERSYM entry in the dynamic * section so that the runtime linker can use it to * implement their versioning rules. They allow multiple * incompatible functions with the same name to exist * in different versions. The Solaris ld does not * support this mechanism, and as such, does not * produce DT_VERSYM. We use this fact to determine * which ld produced this object, and how to interpret * the version values. */ if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0) || (_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; numdyn = shdr->sh_size / shdr->sh_entsize; dyn = (Dyn *)_cache->c_data->d_buf; for (; numdyn-- > 0; dyn++) if (dyn->d_tag == DT_VERSYM) { versym->gnu_full = versym->gnu_needed = 1; break; } break; case SHT_SUNW_versym: /* Record data address for later symbol processing */ if (_cache->c_data != NULL) { versym->cache = _cache; versym->data = _cache->c_data->d_buf; continue; } break; case SHT_SUNW_verdef: case SHT_SUNW_verneed: /* * Ensure the data is non-NULL and the number * of items is non-zero. Otherwise, we don't * understand the section, and will not use it. */ if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, _cache->c_name); continue; } if (shdr->sh_info == 0) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHINFO), file, _cache->c_name, EC_WORD(shdr->sh_info)); continue; } /* Make sure the string table index is in range */ if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, _cache->c_name, EC_WORD(shdr->sh_link)); continue; } /* * The section is usable. Save the cache entry. */ if (shdr->sh_type == SHT_SUNW_verdef) { verdef_cache = _cache; /* * Under Solaris rules, if there is a verdef * section, the max versym index is number * of version definitions it supplies. */ versym->max_verndx = shdr->sh_info; } else { verneed_cache = _cache; } break; } } /* * If there is a Verneed section, examine it for information * related to GNU style versioning. */ if (verneed_cache != NULL) update_gnu_verndx((Verneed *)verneed_cache->c_data->d_buf, verneed_cache->c_shdr->sh_info, versym); /* * Now that all the information is available, display the * Verdef and Verneed section contents, if requested. */ if ((flags & FLG_SHOW_VERSIONS) == 0) return; if (verdef_cache != NULL) { dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_VERDEF), verdef_cache->c_name); version_def((Verdef *)verdef_cache->c_data->d_buf, verdef_cache->c_shdr->sh_info, verdef_cache, &cache[verdef_cache->c_shdr->sh_link], file); } if (verneed_cache != NULL) { dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_VERNEED), verneed_cache->c_name); /* * If GNU versioning applies to this object, version_need() * will update versym->max_verndx, and it is not * necessary to call update_gnu_verndx(). */ version_need((Verneed *)verneed_cache->c_data->d_buf, verneed_cache->c_shdr->sh_info, verneed_cache, &cache[verneed_cache->c_shdr->sh_link], file, versym); } } /* * Search for and process any symbol tables. */ void symbols(Cache *cache, Word shnum, Ehdr *ehdr, uchar_t osabi, VERSYM_STATE *versym, const char *file, uint_t flags) { SYMTBL_STATE state; Cache *_cache; Word secndx; for (secndx = 1; secndx < shnum; secndx++) { Word symcnt; Shdr *shdr; _cache = &cache[secndx]; shdr = _cache->c_shdr; if ((shdr->sh_type != SHT_SYMTAB) && (shdr->sh_type != SHT_DYNSYM) && ((shdr->sh_type != SHT_SUNW_LDYNSYM) || (osabi != ELFOSABI_SOLARIS))) continue; if (!match(MATCH_F_ALL, _cache->c_name, secndx, shdr->sh_type)) continue; if (!init_symtbl_state(&state, cache, shnum, secndx, ehdr, osabi, versym, file, flags)) continue; /* * Loop through the symbol tables entries. */ dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_SYMTAB), state.secname); Elf_syms_table_title(0, ELF_DBG_ELFDUMP); for (symcnt = 0; symcnt < state.symn; symcnt++) output_symbol(&state, symcnt, shdr->sh_info, symcnt, state.sym + symcnt); } } /* * Search for and process any SHT_SUNW_symsort or SHT_SUNW_tlssort sections. * These sections are always associated with the .SUNW_ldynsym./.dynsym pair. */ static void sunw_sort(Cache *cache, Word shnum, Ehdr *ehdr, uchar_t osabi, VERSYM_STATE *versym, const char *file, uint_t flags) { SYMTBL_STATE ldynsym_state, dynsym_state; Cache *sortcache, *symcache; Shdr *sortshdr, *symshdr; Word sortsecndx, symsecndx; Word ldynsym_cnt; Word *ndx; Word ndxn; int output_cnt = 0; Conv_inv_buf_t inv_buf; for (sortsecndx = 1; sortsecndx < shnum; sortsecndx++) { sortcache = &cache[sortsecndx]; sortshdr = sortcache->c_shdr; if ((sortshdr->sh_type != SHT_SUNW_symsort) && (sortshdr->sh_type != SHT_SUNW_tlssort)) continue; if (!match(MATCH_F_ALL, sortcache->c_name, sortsecndx, sortshdr->sh_type)) continue; /* * If the section references a SUNW_ldynsym, then we * expect to see the associated .dynsym immediately * following. If it references a .dynsym, there is no * SUNW_ldynsym. If it is any other type, then we don't * know what to do with it. */ if ((sortshdr->sh_link == 0) || (sortshdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, sortcache->c_name, EC_WORD(sortshdr->sh_link)); continue; } symcache = &cache[sortshdr->sh_link]; symshdr = symcache->c_shdr; symsecndx = sortshdr->sh_link; ldynsym_cnt = 0; switch (symshdr->sh_type) { case SHT_SUNW_LDYNSYM: if (!init_symtbl_state(&ldynsym_state, cache, shnum, symsecndx, ehdr, osabi, versym, file, flags)) continue; ldynsym_cnt = ldynsym_state.symn; /* * We know that the dynsym follows immediately * after the SUNW_ldynsym, and so, should be at * (sortshdr->sh_link + 1). However, elfdump is a * diagnostic tool, so we do the full paranoid * search instead. */ for (symsecndx = 1; symsecndx < shnum; symsecndx++) { symcache = &cache[symsecndx]; symshdr = symcache->c_shdr; if (symshdr->sh_type == SHT_DYNSYM) break; } if (symsecndx >= shnum) { /* Dynsym not found! */ (void) fprintf(stderr, MSG_INTL(MSG_ERR_NODYNSYM), file, sortcache->c_name); continue; } /* Fallthrough to process associated dynsym */ /* FALLTHROUGH */ case SHT_DYNSYM: if (!init_symtbl_state(&dynsym_state, cache, shnum, symsecndx, ehdr, osabi, versym, file, flags)) continue; break; default: (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADNDXSEC), file, sortcache->c_name, conv_sec_type(osabi, ehdr->e_machine, symshdr->sh_type, 0, &inv_buf)); continue; } /* * Output header */ dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); if (ldynsym_cnt > 0) { dbg_print(0, MSG_INTL(MSG_ELF_SCN_SYMSORT2), sortcache->c_name, ldynsym_state.secname, dynsym_state.secname); /* * The data for .SUNW_ldynsym and dynsym sections * is supposed to be adjacent with SUNW_ldynsym coming * first. Check, and issue a warning if it isn't so. */ if (((ldynsym_state.sym + ldynsym_state.symn) != dynsym_state.sym) && ((flags & FLG_CTL_FAKESHDR) == 0)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_LDYNNOTADJ), file, ldynsym_state.secname, dynsym_state.secname); } else { dbg_print(0, MSG_INTL(MSG_ELF_SCN_SYMSORT1), sortcache->c_name, dynsym_state.secname); } Elf_syms_table_title(0, ELF_DBG_ELFDUMP); /* If not first one, insert a line of white space */ if (output_cnt++ > 0) dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); /* * SUNW_dynsymsort and SUNW_dyntlssort are arrays of * symbol indices. Iterate over the array entries, * dispaying the referenced symbols. */ ndxn = sortshdr->sh_size / sortshdr->sh_entsize; ndx = (Word *)sortcache->c_data->d_buf; for (; ndxn-- > 0; ndx++) { if (*ndx >= ldynsym_cnt) { Word sec_ndx = *ndx - ldynsym_cnt; output_symbol(&dynsym_state, sec_ndx, 0, *ndx, dynsym_state.sym + sec_ndx); } else { output_symbol(&ldynsym_state, *ndx, 0, *ndx, ldynsym_state.sym + *ndx); } } } } /* * Search for and process any relocation sections. */ static void reloc(Cache *cache, Word shnum, Ehdr *ehdr, const char *file) { Word cnt; for (cnt = 1; cnt < shnum; cnt++) { Word type, symnum; Xword relndx, relnum, relsize; void *rels; Sym *syms; Cache *symsec, *strsec; Cache *_cache = &cache[cnt]; Shdr *shdr = _cache->c_shdr; char *relname = _cache->c_name; Conv_inv_buf_t inv_buf; if (((type = shdr->sh_type) != SHT_RELA) && (type != SHT_REL)) continue; if (!match(MATCH_F_ALL, relname, cnt, type)) continue; /* * Decide entry size. */ if (((relsize = shdr->sh_entsize) == 0) || (relsize > shdr->sh_size)) { if (type == SHT_RELA) relsize = sizeof (Rela); else relsize = sizeof (Rel); } /* * Determine the number of relocations available. */ if (shdr->sh_size == 0) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, relname); continue; } if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; rels = _cache->c_data->d_buf; relnum = shdr->sh_size / relsize; /* * Get the data buffer for the associated symbol table and * string table. */ if (stringtbl(cache, 1, cnt, shnum, file, &symnum, &symsec, &strsec) == 0) continue; syms = symsec->c_data->d_buf; /* * Loop through the relocation entries. */ dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_RELOC), _cache->c_name); Elf_reloc_title(0, ELF_DBG_ELFDUMP, type); for (relndx = 0; relndx < relnum; relndx++, rels = (void *)((char *)rels + relsize)) { Half mach = ehdr->e_machine; char section[BUFSIZ]; const char *symname; Word symndx, reltype; Rela *rela; Rel *rel; /* * Unravel the relocation and determine the symbol with * which this relocation is associated. */ if (type == SHT_RELA) { rela = (Rela *)rels; symndx = ELF_R_SYM(rela->r_info); reltype = ELF_R_TYPE(rela->r_info, mach); } else { rel = (Rel *)rels; symndx = ELF_R_SYM(rel->r_info); reltype = ELF_R_TYPE(rel->r_info, mach); } symname = relsymname(cache, _cache, strsec, symndx, symnum, relndx, syms, section, BUFSIZ, file); /* * A zero symbol index is only valid for a few * relocations. */ if (symndx == 0) { int badrel = 0; if ((mach == EM_SPARC) || (mach == EM_SPARC32PLUS) || (mach == EM_SPARCV9)) { if ((reltype != R_SPARC_NONE) && (reltype != R_SPARC_REGISTER) && (reltype != R_SPARC_RELATIVE)) badrel++; } else if (mach == EM_386) { if ((reltype != R_386_NONE) && (reltype != R_386_RELATIVE)) badrel++; } else if (mach == EM_AMD64) { if ((reltype != R_AMD64_NONE) && (reltype != R_AMD64_RELATIVE)) badrel++; } if (badrel) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADREL1), file, conv_reloc_type(mach, reltype, 0, &inv_buf)); } } Elf_reloc_entry_1(0, ELF_DBG_ELFDUMP, MSG_ORIG(MSG_STR_EMPTY), ehdr->e_machine, type, rels, relname, symname, 0); } } } /* * This value controls which test dyn_test() performs. */ typedef enum { DYN_TEST_ADDR, DYN_TEST_SIZE, DYN_TEST_ENTSIZE } dyn_test_t; /* * Used by dynamic() to compare the value of a dynamic element against * the starting address of the section it references. * * entry: * test_type - Specify which dyn item is being tested. * sh_type - SHT_* type value for required section. * sec_cache - Cache entry for section, or NULL if the object lacks * a section of this type. * dyn - Dyn entry to be tested * dynsec_cnt - # of dynamic section being examined. The first * dynamic section is 1, the next is 2, and so on... * ehdr - ELF header for file * file - Name of file */ static void dyn_test(dyn_test_t test_type, Word sh_type, Cache *sec_cache, Dyn *dyn, Word dynsec_cnt, Ehdr *ehdr, uchar_t osabi, const char *file) { Conv_inv_buf_t buf1, buf2; /* * These tests are based around the implicit assumption that * there is only one dynamic section in an object, and also only * one of the sections it references. We have therefore gathered * all of the necessary information to test this in a single pass * over the section headers, which is very efficient. We are not * aware of any case where more than one dynamic section would * be meaningful in an ELF object, so this is a reasonable solution. * * To test multiple dynamic sections correctly would be more * expensive in code and time. We would have to build a data structure * containing all the dynamic elements. Then, we would use the address * to locate the section it references and ensure the section is of * the right type and that the address in the dynamic element is * to the start of the section. Then, we could check the size and * entsize values against those same sections. This is O(n^2), and * also complicated. * * In the highly unlikely case that there is more than one dynamic * section, we only test the first one, and simply allow the values * of the subsequent one to be displayed unchallenged. */ if (dynsec_cnt != 1) return; /* * A DT_ item that references a section address should always find * the section in the file. */ if (sec_cache == NULL) { const char *name; /* * Supply section names instead of section types for * things that reference progbits so that the error * message will make more sense. */ switch (dyn->d_tag) { case DT_INIT: name = MSG_ORIG(MSG_ELF_INIT); break; case DT_FINI: name = MSG_ORIG(MSG_ELF_FINI); break; default: name = conv_sec_type(osabi, ehdr->e_machine, sh_type, 0, &buf1); break; } (void) fprintf(stderr, MSG_INTL(MSG_ERR_DYNNOBCKSEC), file, name, conv_dyn_tag(dyn->d_tag, osabi, ehdr->e_machine, CONV_FMT_ALT_CF, &buf2)); return; } switch (test_type) { case DYN_TEST_ADDR: /* The section address should match the DT_ item value */ if (dyn->d_un.d_val != sec_cache->c_shdr->sh_addr) (void) fprintf(stderr, MSG_INTL(MSG_ERR_DYNBADADDR), file, conv_dyn_tag(dyn->d_tag, osabi, ehdr->e_machine, CONV_FMT_ALT_CF, &buf1), EC_ADDR(dyn->d_un.d_val), sec_cache->c_ndx, sec_cache->c_name, EC_ADDR(sec_cache->c_shdr->sh_addr)); break; case DYN_TEST_SIZE: /* The section size should match the DT_ item value */ if (dyn->d_un.d_val != sec_cache->c_shdr->sh_size) (void) fprintf(stderr, MSG_INTL(MSG_ERR_DYNBADSIZE), file, conv_dyn_tag(dyn->d_tag, osabi, ehdr->e_machine, CONV_FMT_ALT_CF, &buf1), EC_XWORD(dyn->d_un.d_val), sec_cache->c_ndx, sec_cache->c_name, EC_XWORD(sec_cache->c_shdr->sh_size)); break; case DYN_TEST_ENTSIZE: /* The sh_entsize value should match the DT_ item value */ if (dyn->d_un.d_val != sec_cache->c_shdr->sh_entsize) (void) fprintf(stderr, MSG_INTL(MSG_ERR_DYNBADENTSIZE), file, conv_dyn_tag(dyn->d_tag, osabi, ehdr->e_machine, CONV_FMT_ALT_CF, &buf1), EC_XWORD(dyn->d_un.d_val), sec_cache->c_ndx, sec_cache->c_name, EC_XWORD(sec_cache->c_shdr->sh_entsize)); break; } } /* * There are some DT_ entries that have corresponding symbols * (e.g. DT_INIT and _init). It is expected that these items will * both have the same value if both are present. This routine * examines the well known symbol tables for such symbols and * issues warnings for any that don't match. * * entry: * dyn - Dyn entry to be tested * symname - Name of symbol that corresponds to dyn * symtab_cache, dynsym_cache, ldynsym_cache - Symbol tables to check * target_cache - Section the symname section is expected to be * associated with. * cache - Cache of all section headers * shnum - # of sections in cache * ehdr - ELF header for file * osabi - OSABI to apply when interpreting object * file - Name of file */ static void dyn_symtest(Dyn *dyn, const char *symname, Cache *symtab_cache, Cache *dynsym_cache, Cache *ldynsym_cache, Cache *target_cache, Cache *cache, Word shnum, Ehdr *ehdr, uchar_t osabi, const char *file) { Conv_inv_buf_t buf; int i; Sym *sym; Cache *_cache = NULL; for (i = 0; i < 3; i++) { switch (i) { case 0: _cache = symtab_cache; break; case 1: _cache = dynsym_cache; break; case 2: _cache = ldynsym_cache; break; } if ((_cache != NULL) && symlookup(symname, cache, shnum, &sym, target_cache, _cache, file) && (sym->st_value != dyn->d_un.d_val)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_DYNSYMVAL), file, _cache->c_name, conv_dyn_tag(dyn->d_tag, osabi, ehdr->e_machine, CONV_FMT_ALT_CF, &buf), symname, EC_ADDR(sym->st_value)); } } /* * Search for and process a .dynamic section. */ static void dynamic(Cache *cache, Word shnum, Ehdr *ehdr, uchar_t osabi, const char *file, Word phnum, Elf *elf) { struct { Cache *symtab; Cache *dynstr; Cache *dynsym; Cache *hash; Cache *fini; Cache *fini_array; Cache *init; Cache *init_array; Cache *preinit_array; Cache *rel; Cache *rela; Cache *sunw_cap; Cache *sunw_capinfo; Cache *sunw_capchain; Cache *sunw_ldynsym; Cache *sunw_move; Cache *sunw_syminfo; Cache *sunw_symsort; Cache *sunw_tlssort; Cache *sunw_verdef; Cache *sunw_verneed; Cache *sunw_versym; } sec; Word dynsec_ndx; Word dynsec_num; int dynsec_cnt; Word cnt; int osabi_solaris = osabi == ELFOSABI_SOLARIS; Phdr *pt_dynamic = NULL; size_t phndx; static Word phdr_type[] = { PT_DYNAMIC }; /* * Make a pass over all the sections, gathering section information * we'll need below. */ dynsec_num = 0; bzero(&sec, sizeof (sec)); for (cnt = 1; cnt < shnum; cnt++) { Cache *_cache = &cache[cnt]; switch (_cache->c_shdr->sh_type) { case SHT_DYNAMIC: if (dynsec_num == 0) { dynsec_ndx = cnt; /* Does it have a valid string table? */ (void) stringtbl(cache, 0, cnt, shnum, file, 0, 0, &sec.dynstr); } dynsec_num++; break; case SHT_PROGBITS: /* * We want to detect the .init and .fini sections, * if present. These are SHT_PROGBITS, so all we * have to go on is the section name. Normally comparing * names is a bad idea, but there are some special * names (i.e. .init/.fini/.interp) that are very * difficult to use in any other context, and for * these symbols, we do the heuristic match. */ if (strcmp(_cache->c_name, MSG_ORIG(MSG_ELF_INIT)) == 0) { if (sec.init == NULL) sec.init = _cache; } else if (strcmp(_cache->c_name, MSG_ORIG(MSG_ELF_FINI)) == 0) { if (sec.fini == NULL) sec.fini = _cache; } break; case SHT_REL: /* * We want the SHT_REL section with the lowest * offset. The linker gathers them together, * and puts the address of the first one * into the DT_REL dynamic element. */ if ((sec.rel == NULL) || (_cache->c_shdr->sh_offset < sec.rel->c_shdr->sh_offset)) sec.rel = _cache; break; case SHT_RELA: /* RELA is handled just like RELA above */ if ((sec.rela == NULL) || (_cache->c_shdr->sh_offset < sec.rela->c_shdr->sh_offset)) sec.rela = _cache; break; /* * The GRAB macro is used for the simple case in which * we simply grab the first section of the desired type. */ #define GRAB(_sec_type, _sec_field) \ case _sec_type: \ if (sec._sec_field == NULL) \ sec._sec_field = _cache; \ break GRAB(SHT_SYMTAB, symtab); GRAB(SHT_DYNSYM, dynsym); GRAB(SHT_FINI_ARRAY, fini_array); GRAB(SHT_HASH, hash); GRAB(SHT_INIT_ARRAY, init_array); GRAB(SHT_SUNW_move, sunw_move); GRAB(SHT_PREINIT_ARRAY, preinit_array); GRAB(SHT_SUNW_cap, sunw_cap); GRAB(SHT_SUNW_capinfo, sunw_capinfo); GRAB(SHT_SUNW_capchain, sunw_capchain); GRAB(SHT_SUNW_LDYNSYM, sunw_ldynsym); GRAB(SHT_SUNW_syminfo, sunw_syminfo); GRAB(SHT_SUNW_symsort, sunw_symsort); GRAB(SHT_SUNW_tlssort, sunw_tlssort); GRAB(SHT_SUNW_verdef, sunw_verdef); GRAB(SHT_SUNW_verneed, sunw_verneed); GRAB(SHT_SUNW_versym, sunw_versym); #undef GRAB } } if (phnum) { pt_dynamic = getphdr(phnum, phdr_type, 1, file, elf, &phndx); } /* * If no dynamic section, return immediately. If more than one * dynamic section, then something odd is going on and an error * is in order, but then continue on and display them all. */ if (dynsec_num == 0) { return; } if (dynsec_num > 1) (void) fprintf(stderr, MSG_INTL(MSG_ERR_MULTDYN), file, EC_WORD(dynsec_num)); dynsec_cnt = 0; for (cnt = dynsec_ndx; (cnt < shnum) && (dynsec_cnt < dynsec_num); cnt++) { Dyn *dyn; ulong_t numdyn; int ndx, end_ndx; Cache *_cache = &cache[cnt], *strsec; Shdr *shdr = _cache->c_shdr; int dumped = 0; if (shdr->sh_type != SHT_DYNAMIC) continue; dynsec_cnt++; /* * Verify the associated string table section. */ if (stringtbl(cache, 0, cnt, shnum, file, 0, 0, &strsec) == 0) continue; if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, _cache->c_name); continue; } if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; /* The first time through, check v. PT_DYNAMIC */ if (dynsec_cnt == 1) { Conv_inv_buf_t inv_buf; if ((pt_dynamic == NULL) && (ehdr->e_type != ET_REL)) { fprintf(stderr, MSG_INTL(MSG_SHDR_NO_PHDR), file, _cache->c_ndx, _cache->c_name, conv_phdr_type(osabi, ehdr->e_machine, PT_DYNAMIC, CONV_FMT_ALT_CF, &inv_buf)); } if (pt_dynamic != NULL) { check_phdr_v_shdr(pt_dynamic, phndx, osabi, ehdr->e_machine, _cache, file); } } numdyn = shdr->sh_size / shdr->sh_entsize; dyn = (Dyn *)_cache->c_data->d_buf; /* * We expect the REL/RELA entries to reference the reloc * section with the lowest address. However, this is * not true for dumped objects. Detect if this object has * been dumped so that we can skip the reloc address test * in that case. */ for (ndx = 0; ndx < numdyn; dyn++, ndx++) { if (dyn->d_tag == DT_FLAGS_1) { dumped = (dyn->d_un.d_val & DF_1_CONFALT) != 0; break; } } dyn = (Dyn *)_cache->c_data->d_buf; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_DYNAMIC), _cache->c_name); Elf_dyn_title(0); for (ndx = 0; ndx < numdyn; dyn++, ndx++) { union { Conv_inv_buf_t inv; Conv_dyn_flag_buf_t flag; Conv_dyn_flag1_buf_t flag1; Conv_dyn_posflag1_buf_t posflag1; Conv_dyn_feature1_buf_t feature1; } c_buf; const char *name = NULL; /* * Print the information numerically, and if possible * as a string. If a string is available, name is * set to reference it. * * Also, take this opportunity to sanity check * the values of DT elements. In the code above, * we gathered information on sections that are * referenced by the dynamic section. Here, we * compare the attributes of those sections to * the DT_ items that reference them and report * on inconsistencies. * * Things not currently tested that could be improved * in later revisions include: * - We don't check PLT or GOT related items * - We don't handle computing the lengths of * relocation arrays. To handle this * requires examining data that spans * across sections, in a contiguous span * within a single segment. * - DT_VERDEFNUM and DT_VERNEEDNUM can't be * verified without parsing the sections. * - We don't handle DT_SUNW_SYMSZ, which would * be the sum of the lengths of .dynsym and * .SUNW_ldynsym * - DT_SUNW_STRPAD can't be verified other than * to check that it's not larger than * the string table. * - Some items come in "all or none" clusters * that give an address, element size, * and data length in bytes. We don't * verify that there are no missing items * in such groups. */ switch (dyn->d_tag) { case DT_NULL: /* * Special case: DT_NULLs can come in groups * that we prefer to reduce to a single line. */ end_ndx = ndx; while ((end_ndx < (numdyn - 1)) && ((dyn + 1)->d_tag == DT_NULL)) { dyn++; end_ndx++; } Elf_dyn_null_entry(0, dyn, ndx, end_ndx); ndx = end_ndx; continue; /* * String items all reference the dynstr. The string() * function does the necessary sanity checking. */ case DT_NEEDED: case DT_SONAME: case DT_FILTER: case DT_AUXILIARY: case DT_CONFIG: case DT_RPATH: case DT_RUNPATH: case DT_USED: case DT_DEPAUDIT: case DT_AUDIT: name = string(_cache, ndx, strsec, file, dyn->d_un.d_ptr); break; case DT_SUNW_AUXILIARY: case DT_SUNW_FILTER: if (osabi_solaris) name = string(_cache, ndx, strsec, file, dyn->d_un.d_ptr); break; case DT_FLAGS: name = conv_dyn_flag(dyn->d_un.d_val, 0, &c_buf.flag); break; case DT_FLAGS_1: name = conv_dyn_flag1(dyn->d_un.d_val, 0, &c_buf.flag1); break; case DT_POSFLAG_1: name = conv_dyn_posflag1(dyn->d_un.d_val, 0, &c_buf.posflag1); break; case DT_FEATURE_1: name = conv_dyn_feature1(dyn->d_un.d_val, 0, &c_buf.feature1); break; case DT_DEPRECATED_SPARC_REGISTER: name = MSG_INTL(MSG_STR_DEPRECATED); break; case DT_SUNW_LDMACH: if (!osabi_solaris) break; name = conv_ehdr_mach((Half)dyn->d_un.d_val, 0, &c_buf.inv); break; /* * Cases below this point are strictly sanity checking, * and do not generate a name string. The TEST_ macros * are used to hide the boiler plate arguments neeeded * by dyn_test(). */ #define TEST_ADDR(_sh_type, _sec_field) \ dyn_test(DYN_TEST_ADDR, _sh_type, \ sec._sec_field, dyn, dynsec_cnt, ehdr, \ osabi, file) #define TEST_SIZE(_sh_type, _sec_field) \ dyn_test(DYN_TEST_SIZE, _sh_type, \ sec._sec_field, dyn, dynsec_cnt, ehdr, \ osabi, file) #define TEST_ENTSIZE(_sh_type, _sec_field) \ dyn_test(DYN_TEST_ENTSIZE, _sh_type, \ sec._sec_field, dyn, dynsec_cnt, ehdr, \ osabi, file) case DT_FINI: dyn_symtest(dyn, MSG_ORIG(MSG_SYM_FINI), sec.symtab, sec.dynsym, sec.sunw_ldynsym, sec.fini, cache, shnum, ehdr, osabi, file); TEST_ADDR(SHT_PROGBITS, fini); break; case DT_FINI_ARRAY: TEST_ADDR(SHT_FINI_ARRAY, fini_array); break; case DT_FINI_ARRAYSZ: TEST_SIZE(SHT_FINI_ARRAY, fini_array); break; case DT_HASH: TEST_ADDR(SHT_HASH, hash); break; case DT_INIT: dyn_symtest(dyn, MSG_ORIG(MSG_SYM_INIT), sec.symtab, sec.dynsym, sec.sunw_ldynsym, sec.init, cache, shnum, ehdr, osabi, file); TEST_ADDR(SHT_PROGBITS, init); break; case DT_INIT_ARRAY: TEST_ADDR(SHT_INIT_ARRAY, init_array); break; case DT_INIT_ARRAYSZ: TEST_SIZE(SHT_INIT_ARRAY, init_array); break; case DT_MOVEENT: TEST_ENTSIZE(SHT_SUNW_move, sunw_move); break; case DT_MOVESZ: TEST_SIZE(SHT_SUNW_move, sunw_move); break; case DT_MOVETAB: TEST_ADDR(SHT_SUNW_move, sunw_move); break; case DT_PREINIT_ARRAY: TEST_ADDR(SHT_PREINIT_ARRAY, preinit_array); break; case DT_PREINIT_ARRAYSZ: TEST_SIZE(SHT_PREINIT_ARRAY, preinit_array); break; case DT_REL: if (!dumped) TEST_ADDR(SHT_REL, rel); break; case DT_RELENT: TEST_ENTSIZE(SHT_REL, rel); break; case DT_RELA: if (!dumped) TEST_ADDR(SHT_RELA, rela); break; case DT_RELAENT: TEST_ENTSIZE(SHT_RELA, rela); break; case DT_STRTAB: TEST_ADDR(SHT_STRTAB, dynstr); break; case DT_STRSZ: TEST_SIZE(SHT_STRTAB, dynstr); break; case DT_SUNW_CAP: if (osabi_solaris) TEST_ADDR(SHT_SUNW_cap, sunw_cap); break; case DT_SUNW_CAPINFO: if (osabi_solaris) TEST_ADDR(SHT_SUNW_capinfo, sunw_capinfo); break; case DT_SUNW_CAPCHAIN: if (osabi_solaris) TEST_ADDR(SHT_SUNW_capchain, sunw_capchain); break; case DT_SUNW_SYMTAB: TEST_ADDR(SHT_SUNW_LDYNSYM, sunw_ldynsym); break; case DT_SYMENT: TEST_ENTSIZE(SHT_DYNSYM, dynsym); break; case DT_SYMINENT: TEST_ENTSIZE(SHT_SUNW_syminfo, sunw_syminfo); break; case DT_SYMINFO: TEST_ADDR(SHT_SUNW_syminfo, sunw_syminfo); break; case DT_SYMINSZ: TEST_SIZE(SHT_SUNW_syminfo, sunw_syminfo); break; case DT_SYMTAB: TEST_ADDR(SHT_DYNSYM, dynsym); break; case DT_SUNW_SORTENT: /* * This entry is related to both the symsort and * tlssort sections. */ if (osabi_solaris) { int test_tls = (sec.sunw_tlssort != NULL); int test_sym = (sec.sunw_symsort != NULL) || !test_tls; if (test_sym) TEST_ENTSIZE(SHT_SUNW_symsort, sunw_symsort); if (test_tls) TEST_ENTSIZE(SHT_SUNW_tlssort, sunw_tlssort); } break; case DT_SUNW_SYMSORT: if (osabi_solaris) TEST_ADDR(SHT_SUNW_symsort, sunw_symsort); break; case DT_SUNW_SYMSORTSZ: if (osabi_solaris) TEST_SIZE(SHT_SUNW_symsort, sunw_symsort); break; case DT_SUNW_TLSSORT: if (osabi_solaris) TEST_ADDR(SHT_SUNW_tlssort, sunw_tlssort); break; case DT_SUNW_TLSSORTSZ: if (osabi_solaris) TEST_SIZE(SHT_SUNW_tlssort, sunw_tlssort); break; case DT_VERDEF: TEST_ADDR(SHT_SUNW_verdef, sunw_verdef); break; case DT_VERNEED: TEST_ADDR(SHT_SUNW_verneed, sunw_verneed); break; case DT_VERSYM: TEST_ADDR(SHT_SUNW_versym, sunw_versym); break; #undef TEST_ADDR #undef TEST_SIZE #undef TEST_ENTSIZE } if (name == NULL) name = MSG_ORIG(MSG_STR_EMPTY); Elf_dyn_entry(0, dyn, ndx, name, osabi, ehdr->e_machine); } } } /* * Search for and process a MOVE section. */ static void move(Cache *cache, Word shnum, const char *file, uint_t flags) { Word cnt; const char *fmt = NULL; for (cnt = 1; cnt < shnum; cnt++) { Word movenum, symnum, ndx; Sym *syms; Cache *_cache = &cache[cnt]; Shdr *shdr = _cache->c_shdr; Cache *symsec, *strsec; Move *move; if (shdr->sh_type != SHT_SUNW_move) continue; if (!match(MATCH_F_ALL, _cache->c_name, cnt, shdr->sh_type)) continue; /* * Determine the move data and number. */ if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, _cache->c_name); continue; } if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; move = (Move *)_cache->c_data->d_buf; movenum = shdr->sh_size / shdr->sh_entsize; /* * Get the data buffer for the associated symbol table and * string table. */ if (stringtbl(cache, 1, cnt, shnum, file, &symnum, &symsec, &strsec) == 0) return; syms = (Sym *)symsec->c_data->d_buf; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_MOVE), _cache->c_name); dbg_print(0, MSG_INTL(MSG_MOVE_TITLE)); if (fmt == NULL) fmt = MSG_INTL(MSG_MOVE_ENTRY); for (ndx = 0; ndx < movenum; move++, ndx++) { const char *symname; char index[MAXNDXSIZE], section[BUFSIZ]; Word symndx, shndx; Sym *sym; /* * Check for null entries */ if ((move->m_info == 0) && (move->m_value == 0) && (move->m_poffset == 0) && (move->m_repeat == 0) && (move->m_stride == 0)) { dbg_print(0, fmt, MSG_ORIG(MSG_STR_EMPTY), EC_XWORD(move->m_poffset), 0, 0, 0, EC_LWORD(0), MSG_ORIG(MSG_STR_EMPTY)); continue; } if (((symndx = ELF_M_SYM(move->m_info)) == 0) || (symndx >= symnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADMINFO), file, _cache->c_name, EC_XWORD(move->m_info)); (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(symndx)); dbg_print(0, fmt, index, EC_XWORD(move->m_poffset), ELF_M_SIZE(move->m_info), move->m_repeat, move->m_stride, move->m_value, MSG_INTL(MSG_STR_UNKNOWN)); continue; } symname = relsymname(cache, _cache, strsec, symndx, symnum, ndx, syms, section, BUFSIZ, file); sym = (Sym *)(syms + symndx); /* * Additional sanity check. */ shndx = sym->st_shndx; if (!((shndx == SHN_COMMON) || (((shndx >= 1) && (shndx <= shnum)) && (cache[shndx].c_shdr)->sh_type == SHT_NOBITS))) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSYM2), file, _cache->c_name, EC_WORD(symndx), demangle(symname, flags)); } (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(symndx)); dbg_print(0, fmt, index, EC_XWORD(move->m_poffset), ELF_M_SIZE(move->m_info), move->m_repeat, move->m_stride, move->m_value, demangle(symname, flags)); } } } /* * parse_note_t is used to track the state used by parse_note_entry() * between calls, and also to return the results of each call. */ typedef struct { /* pns_ fields track progress through the data */ const char *pns_file; /* File name */ Cache *pns_cache; /* Note section cache entry */ size_t pns_size; /* # unprocessed data bytes */ Word *pns_data; /* # to next unused data byte */ /* pn_ fields return the results for a single call */ Word pn_namesz; /* Value of note namesz field */ Word pn_descsz; /* Value of note descsz field */ Word pn_type; /* Value of note type field */ const char *pn_name; /* if (namesz > 0) ptr to name bytes */ const char *pn_desc; /* if (descsx > 0) ptr to data bytes */ } parse_note_t; /* * Extract the various sub-parts of a note entry, and advance the * data pointer past it. * * entry: * The state pns_ fields contain current values for the Note section * * exit: * On success, True (1) is returned, the state pns_ fields have been * advanced to point at the start of the next entry, and the information * for the recovered note entry is found in the state pn_ fields. * * On failure, False (0) is returned. The values contained in state * are undefined. */ static int parse_note_entry(parse_note_t *state) { size_t pad, noteoff; noteoff = (Word)state->pns_cache->c_data->d_size - state->pns_size; /* * Make sure we can at least reference the 3 initial entries * (4-byte words) of the note information block. */ if (state->pns_size >= (sizeof (Word) * 3)) { state->pns_size -= (sizeof (Word) * 3); } else { (void) fprintf(stderr, MSG_INTL(MSG_NOTE_BADDATASZ), state->pns_file, state->pns_cache->c_name, EC_WORD(noteoff)); return (0); } /* * Make sure any specified name string can be referenced. */ if ((state->pn_namesz = *state->pns_data++) != 0) { if (state->pns_size >= state->pn_namesz) { state->pns_size -= state->pn_namesz; } else { (void) fprintf(stderr, MSG_INTL(MSG_NOTE_BADNMSZ), state->pns_file, state->pns_cache->c_name, EC_WORD(noteoff), EC_WORD(state->pn_namesz)); return (0); } } /* * Make sure any specified descriptor can be referenced. */ if ((state->pn_descsz = *state->pns_data++) != 0) { /* * If namesz isn't a 4-byte multiple, account for any * padding that must exist before the descriptor. */ if ((pad = (state->pn_namesz & (sizeof (Word) - 1))) != 0) { pad = sizeof (Word) - pad; state->pns_size -= pad; } if (state->pns_size >= state->pn_descsz) { state->pns_size -= state->pn_descsz; } else { (void) fprintf(stderr, MSG_INTL(MSG_NOTE_BADDESZ), state->pns_file, state->pns_cache->c_name, EC_WORD(noteoff), EC_WORD(state->pn_namesz)); return (0); } } state->pn_type = *state->pns_data++; /* Name */ if (state->pn_namesz) { state->pn_name = (char *)state->pns_data; pad = (state->pn_namesz + (sizeof (Word) - 1)) & ~(sizeof (Word) - 1); /* LINTED */ state->pns_data = (Word *)(state->pn_name + pad); } /* * If multiple information blocks exist within a .note section * account for any padding that must exist before the next * information block. */ if ((pad = (state->pn_descsz & (sizeof (Word) - 1))) != 0) { pad = sizeof (Word) - pad; if (state->pns_size > pad) state->pns_size -= pad; } /* Data */ if (state->pn_descsz) { state->pn_desc = (const char *)state->pns_data; /* LINTED */ state->pns_data = (Word *)(state->pn_desc + state->pn_descsz + pad); } return (1); } /* * Callback function for use with conv_str_to_c_literal() below. */ /*ARGSUSED2*/ static void c_literal_cb(const void *ptr, size_t size, void *uvalue) { (void) fwrite(ptr, size, 1, stdout); } /* * Traverse a note section analyzing each note information block. * The data buffers size is used to validate references before they are made, * and is decremented as each element is processed. */ void note_entry(Cache *cache, Word *data, size_t size, Ehdr *ehdr, const char *file) { int cnt = 0; int is_corenote; int do_swap; Conv_inv_buf_t inv_buf; parse_note_t pnstate; pnstate.pns_file = file; pnstate.pns_cache = cache; pnstate.pns_size = size; pnstate.pns_data = data; do_swap = _elf_sys_encoding() != ehdr->e_ident[EI_DATA]; /* * Print out a single `note' information block. */ while (pnstate.pns_size > 0) { if (parse_note_entry(&pnstate) == 0) return; /* * Is this a Solaris core note? Such notes all have * the name "CORE". */ is_corenote = (ehdr->e_type == ET_CORE) && (pnstate.pn_namesz == (MSG_STR_CORE_SIZE + 1)) && (strncmp(MSG_ORIG(MSG_STR_CORE), pnstate.pn_name, MSG_STR_CORE_SIZE + 1) == 0); dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_FMT_NOTEENTNDX), EC_WORD(cnt)); cnt++; dbg_print(0, MSG_ORIG(MSG_NOTE_NAMESZ), EC_WORD(pnstate.pn_namesz)); dbg_print(0, MSG_ORIG(MSG_NOTE_DESCSZ), EC_WORD(pnstate.pn_descsz)); if (is_corenote) dbg_print(0, MSG_ORIG(MSG_NOTE_TYPE_STR), conv_cnote_type(pnstate.pn_type, 0, &inv_buf)); else dbg_print(0, MSG_ORIG(MSG_NOTE_TYPE), EC_WORD(pnstate.pn_type)); if (pnstate.pn_namesz) { dbg_print(0, MSG_ORIG(MSG_NOTE_NAME)); /* * The name string can contain embedded 'null' * bytes and/or unprintable characters. Also, * the final NULL is documented in the ELF ABI * as being included in the namesz. So, display * the name using C literal string notation, and * include the terminating NULL in the output. * We don't show surrounding double quotes, as * that implies the termination that we are showing * explicitly. */ (void) fwrite(MSG_ORIG(MSG_STR_8SP), MSG_STR_8SP_SIZE, 1, stdout); conv_str_to_c_literal(pnstate.pn_name, pnstate.pn_namesz, c_literal_cb, NULL); dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); } if (pnstate.pn_descsz) { int hexdump = 1; /* * If this is a core note, let the corenote() * function handle it. */ if (is_corenote) { /* We only issue the bad arch error once */ static int badnote_done = 0; corenote_ret_t corenote_ret; corenote_ret = corenote(ehdr->e_machine, do_swap, pnstate.pn_type, pnstate.pn_desc, pnstate.pn_descsz); switch (corenote_ret) { case CORENOTE_R_OK_DUMP: hexdump = 1; break; case CORENOTE_R_OK: hexdump = 0; break; case CORENOTE_R_BADDATA: (void) fprintf(stderr, MSG_INTL(MSG_NOTE_BADCOREDATA), file); break; case CORENOTE_R_BADARCH: if (badnote_done) break; (void) fprintf(stderr, MSG_INTL(MSG_NOTE_BADCOREARCH), file, conv_ehdr_mach(ehdr->e_machine, 0, &inv_buf)); break; case CORENOTE_R_BADTYPE: (void) fprintf(stderr, MSG_INTL(MSG_NOTE_BADCORETYPE), file, EC_WORD(pnstate.pn_type)); break; } } /* * The default thing when we don't understand * the note data is to display it as hex bytes. */ if (hexdump) { dbg_print(0, MSG_ORIG(MSG_NOTE_DESC)); dump_hex_bytes(pnstate.pn_desc, pnstate.pn_descsz, 8, 4, 4); } } } } /* * Search for and process .note sections. * * Returns the number of note sections seen. */ static Word note(Cache *cache, Word shnum, Ehdr *ehdr, const char *file) { Word cnt, note_cnt = 0; /* * Otherwise look for any .note sections. */ for (cnt = 1; cnt < shnum; cnt++) { Cache *_cache = &cache[cnt]; Shdr *shdr = _cache->c_shdr; if (shdr->sh_type != SHT_NOTE) continue; note_cnt++; if (!match(MATCH_F_ALL, _cache->c_name, cnt, shdr->sh_type)) continue; /* * As these sections are often hand rolled, make sure they're * properly aligned before proceeding, and issue an error * as necessary. * * Note that we will continue on to display the note even * if it has bad alignment. We can do this safely, because * libelf knows the alignment required for SHT_NOTE, and * takes steps to deliver a properly aligned buffer to us * even if the actual file is misaligned. */ if (shdr->sh_offset & (sizeof (Word) - 1)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADALIGN), file, _cache->c_name); if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_NOTE), _cache->c_name); note_entry(_cache, (Word *)_cache->c_data->d_buf, /* LINTED */ (Word)_cache->c_data->d_size, ehdr, file); } return (note_cnt); } /* * The Linux Standard Base defines a special note named .note.ABI-tag * that is used to maintain Linux ABI information. Presence of this section * is a strong indication that the object should be considered to be * ELFOSABI_LINUX. * * This function returns True (1) if such a note is seen, and False (0) * otherwise. */ static int has_linux_abi_note(Cache *cache, Word shnum, const char *file) { Word cnt; for (cnt = 1; cnt < shnum; cnt++) { parse_note_t pnstate; Cache *_cache = &cache[cnt]; Shdr *shdr = _cache->c_shdr; /* * Section must be SHT_NOTE, must have the name * .note.ABI-tag, and must have data. */ if ((shdr->sh_type != SHT_NOTE) || (strcmp(MSG_ORIG(MSG_STR_NOTEABITAG), _cache->c_name) != 0) || (_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; pnstate.pns_file = file; pnstate.pns_cache = _cache; pnstate.pns_size = _cache->c_data->d_size; pnstate.pns_data = (Word *)_cache->c_data->d_buf; while (pnstate.pns_size > 0) { Word *w; if (parse_note_entry(&pnstate) == 0) break; /* * The type must be 1, and the name must be "GNU". * The descsz must be at least 16 bytes. */ if ((pnstate.pn_type != 1) || (pnstate.pn_namesz != (MSG_STR_GNU_SIZE + 1)) || (strncmp(MSG_ORIG(MSG_STR_GNU), pnstate.pn_name, MSG_STR_CORE_SIZE + 1) != 0) || (pnstate.pn_descsz < 16)) continue; /* * desc contains 4 32-bit fields. Field 0 must be 0, * indicating Linux. The second, third, and fourth * fields represent the earliest Linux kernel * version compatible with this object. */ /*LINTED*/ w = (Word *) pnstate.pn_desc; if (*w == 0) return (1); } } return (0); } /* * Determine an individual hash entry. This may be the initial hash entry, * or an associated chain entry. */ static void hash_entry(Cache *refsec, Cache *strsec, const char *hsecname, Word hashndx, Word symndx, Word symn, Sym *syms, const char *file, ulong_t bkts, uint_t flags, int chain) { Sym *sym; const char *symname, *str; char _bucket[MAXNDXSIZE], _symndx[MAXNDXSIZE]; ulong_t nbkt, nhash; if (symndx > symn) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_HSBADSYMNDX), file, EC_WORD(symndx), EC_WORD(hashndx)); symname = MSG_INTL(MSG_STR_UNKNOWN); } else { sym = (Sym *)(syms + symndx); symname = string(refsec, symndx, strsec, file, sym->st_name); } if (chain == 0) { (void) snprintf(_bucket, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INTEGER), hashndx); str = (const char *)_bucket; } else str = MSG_ORIG(MSG_STR_EMPTY); (void) snprintf(_symndx, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(symndx)); dbg_print(0, MSG_ORIG(MSG_FMT_HASH_INFO), str, _symndx, demangle(symname, flags)); /* * Determine if this string is in the correct bucket. */ nhash = elf_hash(symname); nbkt = nhash % bkts; if (nbkt != hashndx) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADHASH), file, hsecname, symname, EC_WORD(hashndx), nbkt); } } #define MAXCOUNT 500 static void hash(Cache *cache, Word shnum, const char *file, uint_t flags) { static int count[MAXCOUNT]; Word cnt; Word ndx, bkts, nchain; char number[MAXNDXSIZE]; for (cnt = 1; cnt < shnum; cnt++) { Word *hash, *chain; Cache *_cache = &cache[cnt]; Shdr *sshdr, *hshdr = _cache->c_shdr; char *ssecname, *hsecname = _cache->c_name; Sym *syms; Word symn; if (hshdr->sh_type != SHT_HASH) continue; /* * Check the hash table data and size. */ if ((hshdr->sh_entsize == 0) || (hshdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, hsecname); continue; } if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, hsecname); continue; } hash = (Word *)_cache->c_data->d_buf; bkts = *hash++; nchain = *hash++; chain = hash + bkts; /* * The section holds the sizes in addition to the buckets and * chains. */ if (_cache->c_data->d_size < (bkts + nchain + 2) * sizeof (uint_t)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, hsecname); continue; } /* * Get the data buffer for the associated symbol table. */ if ((hshdr->sh_link == 0) || (hshdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, hsecname, EC_WORD(hshdr->sh_link)); continue; } _cache = &cache[hshdr->sh_link]; ssecname = _cache->c_name; if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; if ((syms = (Sym *)_cache->c_data->d_buf) == NULL) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, ssecname); continue; } sshdr = _cache->c_shdr; if ((sshdr->sh_entsize == 0) || (sshdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, ssecname); continue; } /* LINTED */ symn = (Word)(sshdr->sh_size / sshdr->sh_entsize); /* * Check that there is a chain for each symbol. */ if (symn > nchain) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, ssecname); continue; } /* * Get the associated string table section. */ if ((sshdr->sh_link == 0) || (sshdr->sh_link >= shnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), file, ssecname, EC_WORD(sshdr->sh_link)); continue; } dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_HASH), hsecname); dbg_print(0, MSG_INTL(MSG_ELF_HASH_INFO)); /* * Loop through the hash buckets, printing the appropriate * symbols. */ for (ndx = 0; ndx < bkts; ndx++, hash++) { Word _ndx, _cnt; if (*hash == 0) { count[0]++; continue; } /* * Each hash bucket must contain to a valid chain index. * Because the symbol table is checked to be the same * length as the chain array, this also implicitly * checks those bounds. */ if (*hash > nchain) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADCHAINIDX), file, ssecname, EC_WORD(*hash), EC_WORD(ndx), EC_WORD(nchain)); continue; } hash_entry(_cache, &cache[sshdr->sh_link], hsecname, ndx, *hash, symn, syms, file, bkts, flags, 0); /* * Determine if any other symbols are chained to this * bucket. */ _ndx = chain[*hash]; _cnt = 1; while (_ndx) { if (_ndx > nchain) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADCHAINIDX), file, ssecname, EC_WORD(_ndx), EC_WORD(ndx), EC_WORD(nchain)); break; } hash_entry(_cache, &cache[sshdr->sh_link], hsecname, ndx, _ndx, symn, syms, file, bkts, flags, 1); _ndx = chain[_ndx]; _cnt++; } if (_cnt >= MAXCOUNT) { (void) fprintf(stderr, MSG_INTL(MSG_HASH_OVERFLW), file, _cache->c_name, EC_WORD(ndx), EC_WORD(_cnt)); } else count[_cnt]++; } break; } /* * Print out the count information. */ bkts = cnt = 0; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); for (ndx = 0; ndx < MAXCOUNT; ndx++) { Word _cnt; if ((_cnt = count[ndx]) == 0) continue; (void) snprintf(number, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INTEGER), _cnt); dbg_print(0, MSG_INTL(MSG_ELF_HASH_BKTS1), number, EC_WORD(ndx)); bkts += _cnt; cnt += (Word)(ndx * _cnt); } if (cnt) { (void) snprintf(number, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INTEGER), bkts); dbg_print(0, MSG_INTL(MSG_ELF_HASH_BKTS2), number, EC_WORD(cnt)); } } static void group(Cache *cache, Word shnum, const char *file, uint_t flags) { Word scnt; for (scnt = 1; scnt < shnum; scnt++) { Cache *_cache = &cache[scnt]; Shdr *shdr = _cache->c_shdr; Word *grpdata, gcnt, grpcnt, symnum, unknown; Cache *symsec, *strsec; Sym *syms, *sym; char flgstrbuf[MSG_GRP_COMDAT_SIZE + 10]; const char *grpnam; if (shdr->sh_type != SHT_GROUP) continue; if (!match(MATCH_F_ALL, _cache->c_name, scnt, shdr->sh_type)) continue; if ((_cache->c_data == NULL) || ((grpdata = (Word *)_cache->c_data->d_buf) == NULL)) continue; grpcnt = shdr->sh_size / sizeof (Word); /* * Get the data buffer for the associated symbol table and * string table. */ if (stringtbl(cache, 1, scnt, shnum, file, &symnum, &symsec, &strsec) == 0) return; syms = symsec->c_data->d_buf; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_GRP), _cache->c_name); dbg_print(0, MSG_INTL(MSG_GRP_TITLE)); /* * The first element of the group defines the group. The * associated symbol is defined by the sh_link field. */ if ((shdr->sh_info == SHN_UNDEF) || (shdr->sh_info > symnum)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHINFO), file, _cache->c_name, EC_WORD(shdr->sh_info)); return; } (void) strcpy(flgstrbuf, MSG_ORIG(MSG_STR_OSQBRKT)); if (grpdata[0] & GRP_COMDAT) { (void) strcat(flgstrbuf, MSG_ORIG(MSG_GRP_COMDAT)); } if ((unknown = (grpdata[0] & ~GRP_COMDAT)) != 0) { size_t len = strlen(flgstrbuf); (void) snprintf(&flgstrbuf[len], (MSG_GRP_COMDAT_SIZE + 10 - len), MSG_ORIG(MSG_GRP_UNKNOWN), unknown); } (void) strcat(flgstrbuf, MSG_ORIG(MSG_STR_CSQBRKT)); sym = (Sym *)(syms + shdr->sh_info); /* * The GNU assembler can use section symbols as the signature * symbol as described by this comment in the gold linker * (found via google): * * It seems that some versions of gas will create a * section group associated with a section symbol, and * then fail to give a name to the section symbol. In * such a case, use the name of the section. * * In order to support such objects, we do the same. */ grpnam = string(_cache, 0, strsec, file, sym->st_name); if (((sym->st_name == 0) || (*grpnam == '\0')) && (ELF_ST_TYPE(sym->st_info) == STT_SECTION)) grpnam = cache[sym->st_shndx].c_name; dbg_print(0, MSG_INTL(MSG_GRP_SIGNATURE), flgstrbuf, demangle(grpnam, flags)); for (gcnt = 1; gcnt < grpcnt; gcnt++) { char index[MAXNDXSIZE]; const char *name; (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(gcnt)); if ((grpdata[gcnt] == 0) || (grpdata[gcnt] >= shnum)) name = MSG_INTL(MSG_GRP_INVALSCN); else name = cache[grpdata[gcnt]].c_name; (void) printf(MSG_ORIG(MSG_GRP_ENTRY), index, name, EC_XWORD(grpdata[gcnt])); } } } static void got(Cache *cache, Word shnum, Ehdr *ehdr, const char *file) { Cache *gotcache = NULL, *symtab = NULL; Addr gotbgn, gotend; Shdr *gotshdr; Word cnt, gotents, gotndx; size_t gentsize; Got_info *gottable; char *gotdata; Sym *gotsym; Xword gotsymaddr; uint_t sys_encoding; /* * First, find the got. */ for (cnt = 1; cnt < shnum; cnt++) { if (strncmp(cache[cnt].c_name, MSG_ORIG(MSG_ELF_GOT), MSG_ELF_GOT_SIZE) == 0) { gotcache = &cache[cnt]; break; } } if (gotcache == NULL) return; /* * A got section within a relocatable object is suspicious. */ if (ehdr->e_type == ET_REL) { (void) fprintf(stderr, MSG_INTL(MSG_GOT_UNEXPECTED), file, gotcache->c_name); } gotshdr = gotcache->c_shdr; if (gotshdr->sh_size == 0) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, gotcache->c_name); return; } gotbgn = gotshdr->sh_addr; gotend = gotbgn + gotshdr->sh_size; /* * Some architectures don't properly set the sh_entsize for the GOT * table. If it's not set, default to a size of a pointer. */ if ((gentsize = gotshdr->sh_entsize) == 0) gentsize = sizeof (Xword); if ((gotcache->c_data == NULL) || (gotcache->c_data->d_buf == NULL)) return; /* LINTED */ gotents = (Word)(gotshdr->sh_size / gentsize); gotdata = gotcache->c_data->d_buf; if ((gottable = calloc(gotents, sizeof (Got_info))) == 0) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), file, strerror(err)); return; } /* * Now we scan through all the sections looking for any relocations * that may be against the GOT. Since these may not be isolated to a * .rel[a].got section we check them all. * While scanning sections save the symbol table entry (a symtab * overriding a dynsym) so that we can lookup _GLOBAL_OFFSET_TABLE_. */ for (cnt = 1; cnt < shnum; cnt++) { Word type, symnum; Xword relndx, relnum, relsize; void *rels; Sym *syms; Cache *symsec, *strsec; Cache *_cache = &cache[cnt]; Shdr *shdr; shdr = _cache->c_shdr; type = shdr->sh_type; if ((symtab == 0) && (type == SHT_DYNSYM)) { symtab = _cache; continue; } if (type == SHT_SYMTAB) { symtab = _cache; continue; } if ((type != SHT_RELA) && (type != SHT_REL)) continue; /* * Decide entry size. */ if (((relsize = shdr->sh_entsize) == 0) || (relsize > shdr->sh_size)) { if (type == SHT_RELA) relsize = sizeof (Rela); else relsize = sizeof (Rel); } /* * Determine the number of relocations available. */ if (shdr->sh_size == 0) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, _cache->c_name); continue; } if ((_cache->c_data == NULL) || (_cache->c_data->d_buf == NULL)) continue; rels = _cache->c_data->d_buf; relnum = shdr->sh_size / relsize; /* * Get the data buffer for the associated symbol table and * string table. */ if (stringtbl(cache, 1, cnt, shnum, file, &symnum, &symsec, &strsec) == 0) continue; syms = symsec->c_data->d_buf; /* * Loop through the relocation entries. */ for (relndx = 0; relndx < relnum; relndx++, rels = (void *)((char *)rels + relsize)) { char section[BUFSIZ]; Addr offset; Got_info *gip; Word symndx, reltype; Rela *rela; Rel *rel; /* * Unravel the relocation. */ if (type == SHT_RELA) { rela = (Rela *)rels; symndx = ELF_R_SYM(rela->r_info); reltype = ELF_R_TYPE(rela->r_info, ehdr->e_machine); offset = rela->r_offset; } else { rel = (Rel *)rels; symndx = ELF_R_SYM(rel->r_info); reltype = ELF_R_TYPE(rel->r_info, ehdr->e_machine); offset = rel->r_offset; } /* * Only pay attention to relocations against the GOT. */ if ((offset < gotbgn) || (offset >= gotend)) continue; if ((gotshdr->sh_entsize == 0) || (gotshdr->sh_size == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), file, gotcache->c_name); continue; } /* LINTED */ gotndx = (Word)((offset - gotbgn) / gotshdr->sh_entsize); gip = &gottable[gotndx]; if (gip->g_reltype != 0) { (void) fprintf(stderr, MSG_INTL(MSG_GOT_MULTIPLE), file, EC_WORD(gotndx), EC_ADDR(offset)); continue; } if (symndx) gip->g_symname = relsymname(cache, _cache, strsec, symndx, symnum, relndx, syms, section, BUFSIZ, file); gip->g_reltype = reltype; gip->g_rel = rels; } } if (symlookup(MSG_ORIG(MSG_SYM_GOT), cache, shnum, &gotsym, NULL, symtab, file)) gotsymaddr = gotsym->st_value; else gotsymaddr = gotbgn; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_SCN_GOT), gotcache->c_name); Elf_got_title(0); sys_encoding = _elf_sys_encoding(); for (gotndx = 0; gotndx < gotents; gotndx++) { Got_info *gip; Sword gindex; Addr gaddr; Xword gotentry; gip = &gottable[gotndx]; gaddr = gotbgn + (gotndx * gentsize); gindex = (Sword)(gaddr - gotsymaddr) / (Sword)gentsize; if (gentsize == sizeof (Word)) /* LINTED */ gotentry = (Xword)(*((Word *)(gotdata) + gotndx)); else /* LINTED */ gotentry = *((Xword *)(gotdata) + gotndx); Elf_got_entry(0, gindex, gaddr, gotentry, ehdr->e_machine, ehdr->e_ident[EI_DATA], sys_encoding, gip->g_reltype, gip->g_rel, gip->g_symname); } free(gottable); } void checksum(Elf *elf) { dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_STR_CHECKSUM), elf_checksum(elf)); } /* * This variable is used by regular() to communicate the address of * the section header cache to sort_shdr_ndx_arr(). Unfortunately, * the qsort() interface does not include a userdata argument by which * such arbitrary data can be passed, so we are stuck using global data. */ static Cache *sort_shdr_ndx_arr_cache; /* * Used with qsort() to sort the section indices so that they can be * used to access the section headers in order of increasing data offset. * * entry: * sort_shdr_ndx_arr_cache - Contains address of * section header cache. * v1, v2 - Point at elements of sort_shdr_bits array to be compared. * * exit: * Returns -1 (less than), 0 (equal) or 1 (greater than). */ static int sort_shdr_ndx_arr(const void *v1, const void *v2) { Cache *cache1 = sort_shdr_ndx_arr_cache + *((size_t *)v1); Cache *cache2 = sort_shdr_ndx_arr_cache + *((size_t *)v2); if (cache1->c_shdr->sh_offset < cache2->c_shdr->sh_offset) return (-1); if (cache1->c_shdr->sh_offset > cache2->c_shdr->sh_offset) return (1); return (0); } static int shdr_cache(const char *file, Elf *elf, Ehdr *ehdr, size_t shstrndx, size_t shnum, Cache **cache_ret, Word flags) { Elf_Scn *scn; Elf_Data *data; size_t ndx; Shdr *nameshdr = NULL; char *names = NULL; Cache *cache, *_cache; size_t *shdr_ndx_arr, shdr_ndx_arr_cnt; /* * Obtain the .shstrtab data buffer to provide the required section * name strings. */ if (shstrndx == SHN_UNDEF) { /* * It is rare, but legal, for an object to lack a * header string table section. */ names = NULL; (void) fprintf(stderr, MSG_INTL(MSG_ERR_NOSHSTRSEC), file); } else if ((scn = elf_getscn(elf, shstrndx)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETSCN)); (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SHDR), EC_XWORD(shstrndx)); } else if ((data = elf_getdata(scn, NULL)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETDATA)); (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_DATA), EC_XWORD(shstrndx)); } else if ((nameshdr = elf_getshdr(scn)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETSHDR)); (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SCN), EC_WORD(elf_ndxscn(scn))); } else if ((names = data->d_buf) == NULL) (void) fprintf(stderr, MSG_INTL(MSG_ERR_SHSTRNULL), file); /* * Allocate a cache to maintain a descriptor for each section. */ if ((*cache_ret = cache = malloc(shnum * sizeof (Cache))) == NULL) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), file, strerror(err)); return (0); } *cache = cache_init; _cache = cache; _cache++; /* * Allocate an array that will hold the section index for * each section that has data in the ELF file: * * - Is not a NOBITS section * - Data has non-zero length * * Note that shnum is an upper bound on the size required. It * is likely that we won't use a few of these array elements. * Allocating a modest amount of extra memory in this case means * that we can avoid an extra loop to count the number of needed * items, and can fill this array immediately in the first loop * below. */ if ((shdr_ndx_arr = malloc(shnum * sizeof (*shdr_ndx_arr))) == NULL) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), file, strerror(err)); return (0); } shdr_ndx_arr_cnt = 0; /* * Traverse the sections of the file. This gathering of data is * carried out in two passes. First, the section headers are captured * and the section header names are evaluated. A verification pass is * then carried out over the section information. Files have been * known to exhibit overlapping (and hence erroneous) section header * information. * * Finally, the data for each section is obtained. This processing is * carried out after section verification because should any section * header overlap occur, and a file needs translating (ie. xlate'ing * information from a non-native architecture file), then the process * of translation can corrupt the section header information. Of * course, if there is any section overlap, the data related to the * sections is going to be compromised. However, it is the translation * of this data that has caused problems with elfdump()'s ability to * extract the data. */ for (ndx = 1, scn = NULL; (scn = elf_nextscn(elf, scn)) != NULL; ndx++, _cache++) { char scnndxnm[100]; _cache->c_ndx = ndx; _cache->c_scn = scn; if ((_cache->c_shdr = elf_getshdr(scn)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETSHDR)); (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SCN), EC_WORD(elf_ndxscn(scn))); } /* * If this section has data in the file, include it in * the array of sections to check for address overlap. */ if (_cache->c_shdr != NULL && (_cache->c_shdr->sh_size != 0) && (_cache->c_shdr->sh_type != SHT_NOBITS)) shdr_ndx_arr[shdr_ndx_arr_cnt++] = ndx; /* * If a shstrtab exists, assign the section name. */ if (names && _cache->c_shdr) { if (_cache->c_shdr->sh_name != 0 && (nameshdr != NULL && nameshdr->sh_size > _cache->c_shdr->sh_name)) { const char *symname; char *secname; secname = names + _cache->c_shdr->sh_name; /* * A SUN naming convention employs a "%" within * a section name to indicate a section/symbol * name. This originated from the compilers * -xF option, that places functions into their * own sections. This convention (which has no * formal standard) has also been followed for * COMDAT sections. To demangle the symbol * name, the name must be separated from the * section name. */ if (((flags & FLG_CTL_DEMANGLE) == 0) || ((symname = strchr(secname, '%')) == NULL)) _cache->c_name = secname; else { size_t secsz = ++symname - secname; size_t strsz; symname = demangle(symname, flags); strsz = secsz + strlen(symname) + 1; if ((_cache->c_name = malloc(strsz)) == NULL) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), file, strerror(err)); free(shdr_ndx_arr); return (0); } (void) snprintf(_cache->c_name, strsz, MSG_ORIG(MSG_FMT_SECSYM), EC_WORD(secsz), secname, symname); } continue; } /* * Generate an error if the section name index is zero * or exceeds the shstrtab data. Fall through to * fabricate a section name. */ if ((_cache->c_shdr->sh_name == 0) || /* LINTED */ (nameshdr->sh_size <= _cache->c_shdr->sh_name)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHNAME), file, EC_WORD(ndx), EC_XWORD(_cache->c_shdr->sh_name)); } } /* * If there exists no shstrtab data, or a section header has no * name (an invalid index of 0), then compose a name for the * section. */ (void) snprintf(scnndxnm, sizeof (scnndxnm), MSG_INTL(MSG_FMT_SCNNDX), ndx); if ((_cache->c_name = malloc(strlen(scnndxnm) + 1)) == NULL) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), file, strerror(err)); free(shdr_ndx_arr); return (0); } (void) strcpy(_cache->c_name, scnndxnm); } /* * Having collected all the sections, validate their address range. * Cases have existed where the section information has been invalid. * This can lead to all sorts of other, hard to diagnose errors, as * each section is processed individually (ie. with elf_getdata()). * Here, we carry out some address comparisons to catch a family of * overlapping memory issues we have observed (likely, there are others * that we have yet to discover). * * Note, should any memory overlap occur, obtaining any additional * data from the file is questionable. However, it might still be * possible to inspect the ELF header, Programs headers, or individual * sections, so rather than bailing on an error condition, continue * processing to see if any data can be salvaged. */ if (shdr_ndx_arr_cnt > 1) { sort_shdr_ndx_arr_cache = cache; qsort(shdr_ndx_arr, shdr_ndx_arr_cnt, sizeof (*shdr_ndx_arr), sort_shdr_ndx_arr); } for (ndx = 0; ndx < shdr_ndx_arr_cnt; ndx++) { Cache *_cache = cache + shdr_ndx_arr[ndx]; Shdr *shdr = _cache->c_shdr; Off bgn1, bgn = shdr->sh_offset; Off end1, end = shdr->sh_offset + shdr->sh_size; size_t ndx1; /* * Check the section against all following ones, reporting * any overlaps. Since we've sorted the sections by offset, * we can stop after the first comparison that fails. There * are no overlaps in a properly formed ELF file, in which * case this algorithm runs in O(n) time. This will degenerate * to O(n^2) for a completely broken file. Such a file is * (1) highly unlikely, and (2) unusable, so it is reasonable * for the analysis to take longer. */ for (ndx1 = ndx + 1; ndx1 < shdr_ndx_arr_cnt; ndx1++) { Cache *_cache1 = cache + shdr_ndx_arr[ndx1]; Shdr *shdr1 = _cache1->c_shdr; bgn1 = shdr1->sh_offset; end1 = shdr1->sh_offset + shdr1->sh_size; if (((bgn1 <= bgn) && (end1 > bgn)) || ((bgn1 < end) && (end1 >= end))) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_SECMEMOVER), file, EC_WORD(elf_ndxscn(_cache->c_scn)), _cache->c_name, EC_OFF(bgn), EC_OFF(end), EC_WORD(elf_ndxscn(_cache1->c_scn)), _cache1->c_name, EC_OFF(bgn1), EC_OFF(end1)); } else { /* No overlap, so can stop */ break; } } /* * In addition to checking for sections overlapping * each other (done above), we should also make sure * the section doesn't overlap the section header array. */ bgn1 = ehdr->e_shoff; end1 = ehdr->e_shoff + (ehdr->e_shentsize * ehdr->e_shnum); if (((bgn1 <= bgn) && (end1 > bgn)) || ((bgn1 < end) && (end1 >= end))) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_SHDRMEMOVER), file, EC_OFF(bgn1), EC_OFF(end1), EC_WORD(elf_ndxscn(_cache->c_scn)), _cache->c_name, EC_OFF(bgn), EC_OFF(end)); } } /* * Obtain the data for each section. */ for (ndx = 1; ndx < shnum; ndx++) { Cache *_cache = &cache[ndx]; Elf_Scn *scn = _cache->c_scn; if ((_cache->c_data = elf_getdata(scn, NULL)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETDATA)); (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SCNDATA), EC_WORD(elf_ndxscn(scn))); } /* * If a string table, verify that it has NULL first and * final bytes. */ if ((_cache->c_shdr->sh_type == SHT_STRTAB) && (_cache->c_data != NULL) && (_cache->c_data->d_buf != NULL) && (_cache->c_data->d_size > 0)) { const char *s = _cache->c_data->d_buf; if ((*s != '\0') || (*(s + _cache->c_data->d_size - 1) != '\0')) (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALSTR), file, _cache->c_name); } } free(shdr_ndx_arr); return (1); } /* * Generate a cache of section headers and related information * for use by the rest of elfdump. If requested (or the file * contains no section headers), we generate a fake set of * headers from the information accessible from the program headers. * Otherwise, we use the real section headers contained in the file. */ static int create_cache(const char *file, int fd, Elf *elf, Ehdr *ehdr, Cache **cache, size_t shstrndx, size_t *shnum, uint_t *flags) { /* * If there are no section headers, then resort to synthesizing * section headers from the program headers. This is normally * only done by explicit request, but in this case there's no * reason not to go ahead, since the alternative is simply to quit. */ if ((*shnum <= 1) && ((*flags & FLG_CTL_FAKESHDR) == 0)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_NOSHDR), file); *flags |= FLG_CTL_FAKESHDR; } if (*flags & FLG_CTL_FAKESHDR) { if (fake_shdr_cache(file, fd, elf, ehdr, cache, shnum) == 0) return (0); } else { if (shdr_cache(file, elf, ehdr, shstrndx, *shnum, cache, *flags) == 0) return (0); } return (1); } int regular(const char *file, int fd, Elf *elf, uint_t flags, const char *wname, int wfd, uchar_t osabi) { enum { CACHE_NEEDED, CACHE_OK, CACHE_FAIL} cache_state = CACHE_NEEDED; Elf_Scn *scn; Ehdr *ehdr; size_t ndx, shstrndx, shnum, phnum; Shdr *shdr; Cache *cache; VERSYM_STATE versym = { 0 }; int ret = 0; int addr_align; if ((ehdr = elf_getehdr(elf)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETEHDR)); return (ret); } if (elf_getshdrnum(elf, &shnum) == -1) { failure(file, MSG_ORIG(MSG_ELF_GETSHDRNUM)); return (ret); } if (elf_getshdrstrndx(elf, &shstrndx) == -1) { failure(file, MSG_ORIG(MSG_ELF_GETSHDRSTRNDX)); return (ret); } if (elf_getphdrnum(elf, &phnum) == -1) { failure(file, MSG_ORIG(MSG_ELF_GETPHDRNUM)); return (ret); } /* * If the user requested section headers derived from the * program headers (-P option) and this file doesn't have * any program headers (i.e. ET_REL), then we can't do it. */ if ((phnum == 0) && (flags & FLG_CTL_FAKESHDR)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_PNEEDSPH), file); return (ret); } if ((scn = elf_getscn(elf, 0)) != NULL) { if ((shdr = elf_getshdr(scn)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETSHDR)); (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SCN), 0); return (ret); } } else shdr = NULL; /* * Print the elf header. */ if (flags & FLG_SHOW_EHDR) Elf_ehdr(0, ehdr, shdr); /* * If the section headers or program headers have inadequate * alignment for the class of object, print a warning. libelf * can handle such files, but programs that use them can crash * when they dereference unaligned items. * * Note that the AMD64 ABI, although it is a 64-bit architecture, * allows access to data types smaller than 128-bits to be on * word alignment. */ if (ehdr->e_machine == EM_AMD64) addr_align = sizeof (Word); else addr_align = sizeof (Addr); if (ehdr->e_phoff & (addr_align - 1)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADPHDRALIGN), file); if (ehdr->e_shoff & (addr_align - 1)) (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHDRALIGN), file); /* * Determine the Operating System ABI (osabi) we will use to * interpret the object. */ if (flags & FLG_CTL_OSABI) { /* * If the user explicitly specifies '-O none', we need * to display a completely generic view of the file. * However, libconv is written to assume that ELFOSABI_NONE * is equivalent to ELFOSABI_SOLARIS. To get the desired * effect, we use an osabi that libconv has no knowledge of. */ if (osabi == ELFOSABI_NONE) osabi = ELFOSABI_UNKNOWN4; } else { /* Determine osabi from file */ osabi = ehdr->e_ident[EI_OSABI]; if (osabi == ELFOSABI_NONE) { /* * Chicken/Egg scenario: * * Ideally, we wait to create the section header cache * until after the program headers are printed. If we * only output program headers, we can skip building * the cache entirely. * * Proper interpretation of program headers requires * the osabi, which is supposed to be in the ELF header. * However, many systems (Solaris and Linux included) * have a history of setting the osabi to the generic * SysV ABI (ELFOSABI_NONE). We assume ELFOSABI_SOLARIS * in such cases, but would like to check the object * to see if it has a Linux .note.ABI-tag section, * which implies ELFOSABI_LINUX. This requires a * section header cache. * * To break the cycle, we create section headers now * if osabi is ELFOSABI_NONE, and later otherwise. * If it succeeds, we use them, if not, we defer * exiting until after the program headers are out. */ if (create_cache(file, fd, elf, ehdr, &cache, shstrndx, &shnum, &flags) == 0) { cache_state = CACHE_FAIL; } else { cache_state = CACHE_OK; if (has_linux_abi_note(cache, shnum, file)) { Conv_inv_buf_t ibuf1, ibuf2; (void) fprintf(stderr, MSG_INTL(MSG_INFO_LINUXOSABI), file, conv_ehdr_osabi(osabi, 0, &ibuf1), conv_ehdr_osabi(ELFOSABI_LINUX, 0, &ibuf2)); osabi = ELFOSABI_LINUX; } } } /* * We treat ELFOSABI_NONE identically to ELFOSABI_SOLARIS. * Mapping NONE to SOLARIS simplifies the required test. */ if (osabi == ELFOSABI_NONE) osabi = ELFOSABI_SOLARIS; } /* * Print the program headers. */ if ((flags & FLG_SHOW_PHDR) && (phnum != 0)) { Phdr *phdr; if ((phdr = elf_getphdr(elf)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETPHDR)); return (ret); } for (ndx = 0; ndx < phnum; phdr++, ndx++) { if (!match(MATCH_F_PHDR| MATCH_F_NDX | MATCH_F_TYPE, NULL, ndx, phdr->p_type)) continue; dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); dbg_print(0, MSG_INTL(MSG_ELF_PHDR), EC_WORD(ndx)); Elf_phdr(0, osabi, ehdr->e_machine, phdr); } } /* * If we have flag bits set that explicitly require a show or calc * operation, but none of them require the section headers, then * we are done and can return now. */ if (((flags & (FLG_MASK_SHOW | FLG_MASK_CALC)) != 0) && ((flags & (FLG_MASK_SHOW_SHDR | FLG_MASK_CALC_SHDR)) == 0)) return (ret); /* * Everything from this point on requires section headers. * If we have no section headers, there is no reason to continue. * * If we tried above to create the section header cache and failed, * it is time to exit. Otherwise, create it if needed. */ switch (cache_state) { case CACHE_NEEDED: if (create_cache(file, fd, elf, ehdr, &cache, shstrndx, &shnum, &flags) == 0) return (ret); break; case CACHE_OK: break; case CACHE_FAIL: return (ret); } if (shnum <= 1) goto done; /* * If -w was specified, find and write out the section(s) data. */ if (wfd) { for (ndx = 1; ndx < shnum; ndx++) { Cache *_cache = &cache[ndx]; if (match(MATCH_F_STRICT | MATCH_F_ALL, _cache->c_name, ndx, _cache->c_shdr->sh_type) && _cache->c_data && _cache->c_data->d_buf) { if (write(wfd, _cache->c_data->d_buf, _cache->c_data->d_size) != _cache->c_data->d_size) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_WRITE), wname, strerror(err)); /* * Return an exit status of 1, because * the failure is not related to the * ELF file, but by system resources. */ ret = 1; goto done; } } } } /* * If we have no flag bits set that explicitly require a show or calc * operation, but match options (-I, -N, -T) were used, then run * through the section headers and see if we can't deduce show flags * from the match options given. * * We don't do this if -w was specified, because (-I, -N, -T) used * with -w in lieu of some other option is supposed to be quiet. */ if ((wfd == 0) && (flags & FLG_CTL_MATCH) && ((flags & (FLG_MASK_SHOW | FLG_MASK_CALC)) == 0)) { for (ndx = 1; ndx < shnum; ndx++) { Cache *_cache = &cache[ndx]; if (!match(MATCH_F_STRICT | MATCH_F_ALL, _cache->c_name, ndx, _cache->c_shdr->sh_type)) continue; switch (_cache->c_shdr->sh_type) { case SHT_PROGBITS: /* * Heuristic time: It is usually bad form * to assume the meaning/format of a PROGBITS * section based on its name. However, there * are ABI mandated exceptions. Check for * these special names. */ /* The ELF ABI specifies .interp and .got */ if (strcmp(_cache->c_name, MSG_ORIG(MSG_ELF_INTERP)) == 0) { flags |= FLG_SHOW_INTERP; break; } if (strcmp(_cache->c_name, MSG_ORIG(MSG_ELF_GOT)) == 0) { flags |= FLG_SHOW_GOT; break; } /* * The GNU compilers, and amd64 ABI, define * .eh_frame and .eh_frame_hdr. The Sun * C++ ABI defines .exception_ranges. */ if ((strncmp(_cache->c_name, MSG_ORIG(MSG_SCN_FRM), MSG_SCN_FRM_SIZE) == 0) || (strncmp(_cache->c_name, MSG_ORIG(MSG_SCN_EXRANGE), MSG_SCN_EXRANGE_SIZE) == 0)) { flags |= FLG_SHOW_UNWIND; break; } break; case SHT_SYMTAB: case SHT_DYNSYM: case SHT_SUNW_LDYNSYM: case SHT_SUNW_versym: case SHT_SYMTAB_SHNDX: flags |= FLG_SHOW_SYMBOLS; break; case SHT_RELA: case SHT_REL: flags |= FLG_SHOW_RELOC; break; case SHT_HASH: flags |= FLG_SHOW_HASH; break; case SHT_DYNAMIC: flags |= FLG_SHOW_DYNAMIC; break; case SHT_NOTE: flags |= FLG_SHOW_NOTE; break; case SHT_GROUP: flags |= FLG_SHOW_GROUP; break; case SHT_SUNW_symsort: case SHT_SUNW_tlssort: flags |= FLG_SHOW_SORT; break; case SHT_SUNW_cap: flags |= FLG_SHOW_CAP; break; case SHT_SUNW_move: flags |= FLG_SHOW_MOVE; break; case SHT_SUNW_syminfo: flags |= FLG_SHOW_SYMINFO; break; case SHT_SUNW_verdef: case SHT_SUNW_verneed: flags |= FLG_SHOW_VERSIONS; break; case SHT_AMD64_UNWIND: flags |= FLG_SHOW_UNWIND; break; } } } if (flags & FLG_SHOW_SHDR) sections(file, cache, shnum, ehdr, osabi); if (flags & FLG_SHOW_INTERP) interp(file, cache, shnum, phnum, elf, ehdr); if ((osabi == ELFOSABI_SOLARIS) || (osabi == ELFOSABI_LINUX)) versions(cache, shnum, file, flags, &versym); if (flags & FLG_SHOW_SYMBOLS) symbols(cache, shnum, ehdr, osabi, &versym, file, flags); if ((flags & FLG_SHOW_SORT) && (osabi == ELFOSABI_SOLARIS)) sunw_sort(cache, shnum, ehdr, osabi, &versym, file, flags); if (flags & FLG_SHOW_HASH) hash(cache, shnum, file, flags); if (flags & FLG_SHOW_GOT) got(cache, shnum, ehdr, file); if (flags & FLG_SHOW_GROUP) group(cache, shnum, file, flags); if (flags & FLG_SHOW_SYMINFO) syminfo(cache, shnum, ehdr, osabi, file); if (flags & FLG_SHOW_RELOC) reloc(cache, shnum, ehdr, file); if (flags & FLG_SHOW_DYNAMIC) dynamic(cache, shnum, ehdr, osabi, file, phnum, elf); if (flags & FLG_SHOW_NOTE) { Word note_cnt; size_t note_shnum; Cache *note_cache; note_cnt = note(cache, shnum, ehdr, file); /* * Solaris core files have section headers, but these * headers do not include SHT_NOTE sections that reference * the core note sections. This means that note() won't * find the core notes. Fake section headers (-P option) * recover these sections, but it is inconvenient to require * users to specify -P in this situation. If the following * are all true: * * - No note sections were found * - This is a core file * - We are not already using fake section headers * * then we will automatically generate fake section headers * and then process them in a second call to note(). */ if ((note_cnt == 0) && (ehdr->e_type == ET_CORE) && !(flags & FLG_CTL_FAKESHDR) && (fake_shdr_cache(file, fd, elf, ehdr, ¬e_cache, ¬e_shnum) != 0)) { (void) note(note_cache, note_shnum, ehdr, file); fake_shdr_cache_free(note_cache, note_shnum); } } if ((flags & FLG_SHOW_MOVE) && (osabi == ELFOSABI_SOLARIS)) move(cache, shnum, file, flags); if (flags & FLG_CALC_CHECKSUM) checksum(elf); if ((flags & FLG_SHOW_CAP) && (osabi == ELFOSABI_SOLARIS)) cap(file, cache, shnum, phnum, ehdr, osabi, elf, flags); if ((flags & FLG_SHOW_UNWIND) && ((osabi == ELFOSABI_SOLARIS) || (osabi == ELFOSABI_LINUX))) unwind(cache, shnum, phnum, ehdr, osabi, file, elf, flags); /* Release the memory used to cache section headers */ done: if (flags & FLG_CTL_FAKESHDR) fake_shdr_cache_free(cache, shnum); else free(cache); return (ret); } # # CDDL HEADER START # # The contents of this file are subject to the terms of the # Common Development and Distribution License (the "License"). # You may not use this file except in compliance with the License. # # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE # or http://www.opensolaris.org/os/licensing. # See the License for the specific language governing permissions # and limitations under the License. # # When distributing Covered Code, include this CDDL HEADER in each # file and include the License file at usr/src/OPENSOLARIS.LICENSE. # If applicable, add the following below this CDDL HEADER, with the # fields enclosed by brackets "[]" replaced with your own identifying # information: Portions Copyright [yyyy] [name of copyright owner] # # CDDL HEADER END # # # Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. # Copyright 2012 DEY Storage Systems, Inc. All rights reserved. # Copyright 2018 Joyent, Inc. # Copyright 2020 OmniOS Community Edition (OmniOSce) Association. # Copyright 2024 Oxide Computer Company # @ _START_ # Message file for cmd/sgs/elfdump. @ MSG_ID_ELFDUMP # Usage Messages @ MSG_USAGE_BRIEF "usage: %s [-cCdegGhHiklmnrSsuvy] [-I index] \ [-N name] [-O osabi] [-T type] [-p | -w outfile] \ file...\n" @ MSG_USAGE_DETAIL1 "\t[-c]\t\tdump section header information\n" @ MSG_USAGE_DETAIL2 "\t[-C]\t\tdemangle symbol names\n" @ MSG_USAGE_DETAIL3 "\t[-d]\t\tdump the contents of the .dynamic section\n" @ MSG_USAGE_DETAIL4 "\t[-e]\t\tdump the elf header\n" @ MSG_USAGE_DETAIL5 "\t[-g]\t\tdump the contents of the .group sections\n" @ MSG_USAGE_DETAIL6 "\t[-G]\t\tdump the contents of the .got section\n" @ MSG_USAGE_DETAIL7 "\t[-h]\t\tdump the contents of the .hash section\n" @ MSG_USAGE_DETAIL8 "\t[-H]\t\tdump the contents of the .SUNW_cap section\n" @ MSG_USAGE_DETAIL9 "\t[-i]\t\tdump the contents of the .interp section\n" @ MSG_USAGE_DETAIL10 "\t[-I index]\tqualify an option with an index\n" @ MSG_USAGE_DETAIL11 "\t[-l]\t\tdump with no truncated section names\n" @ MSG_USAGE_DETAIL12 "\t[-k]\t\tcalculate elf checksum\n" @ MSG_USAGE_DETAIL13 "\t[-m]\t\tdump the contents of the .SUNW_move \ section\n" @ MSG_USAGE_DETAIL14 "\t[-n]\t\tdump the contents of the .note section\n" @ MSG_USAGE_DETAIL15 "\t[-N name]\tqualify an option with a `name'\n" @ MSG_USAGE_DETAIL16 "\t[-O osabi]\tuse given osabi to interpret object\n" @ MSG_USAGE_DETAIL17 "\t[-P]\t\tuse program headers to generate \ section headers\n" @ MSG_USAGE_DETAIL18 "\t[-p]\t\tdump the program headers\n" @ MSG_USAGE_DETAIL19 "\t[-r]\t\tdump the contents of the relocation \ sections\n" @ MSG_USAGE_DETAIL20 "\t[-S]\t\tdump the contents of the sort index \ sections\n" @ MSG_USAGE_DETAIL21 "\t[-s]\t\tdump the contents of the symbol table \ sections\n" @ MSG_USAGE_DETAIL22 "\t[-T type]\tqualify an option with a section or \ program header type\n" @ MSG_USAGE_DETAIL23 "\t[-u]\t\tdump the contents of a frame unwind \ section\n" @ MSG_USAGE_DETAIL24 "\t[-v]\t\tdump the contents of the version sections\n" @ MSG_USAGE_DETAIL25 "\t[-w file]\twrite the contents of specified section \ to `file'\n" @ MSG_USAGE_DETAIL26 "\t[-y]\t\tdump the contents of the .SUNW_syminfo \ section\n" # Errors @ MSG_ERR_BADFILE "%s: invalid file type\n" @ MSG_ERR_BADREL1 "%s: bad relocation entry: %s: relocation requires \ symbol\n" @ MSG_ERR_NOSHDR "%s: section headers are not present: synthesizing \ from program headers (-P option)\n" @ MSG_ERR_PNEEDSPH "%s: file without program headers is incompatible \ with -P option\n" @ MSG_ERR_NOSHSTRSEC "%s: no header string table section (shstrtab). \ header names are not available\n" @ MSG_ERR_SHSTRNULL "%s: zero size section header string table \ (shstrtab). header names are not available\n" @ MSG_ERR_FAILURE "%s: %s failed: %s\n" @ MSG_ERR_BADSHDRALIGN "%s: bad section header array alignment\n" @ MSG_ERR_BADPHDRALIGN "%s: bad program header array alignment\n" @ MSG_ERR_BADSHNAME "%s: section[%d]: invalid sh_name: %lld\n" @ MSG_ERR_BADSHLINK "%s: %s: invalid sh_link: %d\n" @ MSG_ERR_BADSHINFO "%s: %s: invalid sh_info: %d\n" @ MSG_ERR_BADSHTYPE "%s: %s: invalid sh_type: %d\n" @ MSG_ERR_BADALIGN "%s: %s: bad sh_offset alignment\n" @ MSG_ERR_BADSYM2 "%s: %s: index[%d]: bad symbol entry: %s: must be \ SHN_COMMON or defined in SHT_NOBITS section\n" @ MSG_ERR_BADSYM3 "%s: %s: index[%d]: bad symbol entry: %s: must be \ defined in a SHF_TLS section\n" @ MSG_ERR_BADSYM4 "%s: %s: index[%d]: bad symbol entry: %s: must be \ defined in a non-SHF_TLS section\n" @ MSG_ERR_BADSYM5 "%s: %s: index[%d]: bad symbol entry: %s: \ invalid shndx: %d\n" @ MSG_ERR_BADSYM6 "%s: %s: index[%d]: bad symbol entry: %s: section[%d] \ size: %#llx: symbol (address %#llx, size %#llx) \ lies outside of containing section\n" @ MSG_ERR_BADSYM7 "%s: %s: index[%d]: suspicious global symbol entry: \ %s: lies within local symbol range (index < %lld)\n" @ MSG_ERR_BADSYM8 "%s: %s: index[%d]: suspicious local symbol entry: \ %s: lies within global symbol range (index >= %lld)\n" @ MSG_ERR_RELBADSYMNDX "%s: bad symbol reference %d: from relocation \ entry: %d\n" @ MSG_ERR_HSBADSYMNDX "%s: bad symbol reference %d: from hash entry: %d\n" @ MSG_ERR_BADSYMXINDEX1 "%s: %s: index[%d]: invalid SHN_XINDEX reference: \ SHT_SYMTAB_SHNDX section truncated: no entry for this \ symbol\n" @ MSG_ERR_BADSYMXINDEX2 "%s: %s: index[%d]: invalid SHN_XINDEX reference: \ bad SHT_SYMTAB_SHNDX entry: invalid shndx: 0x%x\n" @ MSG_ERR_BADSYMXINDEX3 "%s: %s: index[%d]: invalid SHN_XINDEX reference: \ SHT_SYMTAB_SHNDX section not found\n" @ MSG_ERR_BADSTOFF "%s: %s: index[%d]: bad %s offset: 0x%x: max 0x%x\n" @ MSG_ERR_BADSZ "%s: %s: zero size or zero entry size information\n" @ MSG_ERR_BADMINFO "%s: %s: invalid m_info: 0x%llx\n" @ MSG_ERR_BADHASH "%s: %s: bad hash entry: symbol %s: exists in bucket \ %d, should be bucket %ld\n" @ MSG_ERR_NODYNSYM "%s: %s: associated SHT_DYNSYM section not found\n" @ MSG_ERR_BADNDXSEC "%s: %s: unexpected section type associated with \ index section: %s\n" @ MSG_ERR_BADSYMNDX "%s: %s: bad symbol index: %d\n" @ MSG_ERR_BADVER "%s: %s: index[%d]: version %d is out of range: \ version definitions available: 0-%d\n" @ MSG_ERR_NOTSTRTAB "%s: section[%d] is not a string table as expected \ by section[%d]\n"; @ MSG_ERR_BADCHAINIDX "%s: %s: invalid chain index %d for bucket %d (max %d)\n" @ MSG_ERR_LDYNNOTADJ "%s: bad dynamic symbol table layout: %s and %s \ sections are not adjacent\n" @ MSG_ERR_SECMEMOVER "%s: memory overlap between section[%d]: %s: %llx:%llx \ and section[%d]: %s: %llx:%llx\n" @ MSG_ERR_SHDRMEMOVER "%s: memory overlap between section header table: \ %llx:%llx and section[%d]: %s: %llx:%llx\n" @ MSG_ERR_MULTDYN "%s: %d dynamic sections seen (1 expected)\n" @ MSG_ERR_DYNNOBCKSEC "%s: object lacks %s section required by %s dynamic \ entry\n" @ MSG_ERR_DYNBADADDR "%s: %s (%#llx) does not match \ shdr[%d: %s].sh_addr (%#llx)\n" @ MSG_ERR_DYNBADSIZE "%s: %s (%#llx) does not match \ shdr[%d: %s].sh_size (%#llx)\n" @ MSG_ERR_DYNBADENTSIZE "%s: %s (%#llx) does not match \ shdr[%d: %s].sh_entsize (%#llx)\n" @ MSG_ERR_DYNSYMVAL "%s: %s: symbol value does not match \ %s entry: %s: value: %#llx\n" @ MSG_ERR_MALSTR "%s: %s: malformed string table, initial or final \ byte\n" @ MSG_ERR_MULTEHFRMHDR "%s: [%d: %s] multiple .eh_frame_hdr sections seen \ (1 expected)\n" @ MSG_ERR_BADEHFRMPTR "%s: section[%d: %s] FramePtr (%#llx) does not match \ shdr[%d: %s].sh_addr (%#llx)\n" @ MSG_ERR_BADSORT "%s: %s: index[%d]: invalid sort order\n" @ MSG_ERR_BADSIDYNNDX "%s: [%d: %s][%d]: dynamic section index out of \ range (0 - %d): %d\n"; @ MSG_ERR_BADSIDYNTAG "%s: [%d: %s][%d]: dynamic element \ [%d: %s][%d] should have type %s: %s\n"; @ MSG_ERR_BADCIEFDELEN "%s: %s: invalid CIE/FDE length: %#llx at %#llx\n" @ MSG_WARN_INVINTERP1 "%s: PT_INTERP header has no associated section\n" @ MSG_WARN_INVCAP1 "%s: PT_SUNWCAP header has no associated section\n" @ MSG_WARN_INVCAP2 "%s: capabilities section[%d]: %s: requires PT_CAP \ program header\n" @ MSG_WARN_INVCAP3 "%s: capabilities section[%d]: %s: requires string \ table: invalid sh_info: %d\n"; @ MSG_WARN_INADDR32SF1 "%s: capabilities section %s: software capability \ ADDR32: is ineffective within a 32-bit object\n" @ MSG_WARN_MULTEHFRM "%s: section[%d: %s]: %s object has multiple \ .eh_frame sections\n" @ MSG_INFO_LINUXOSABI "%s: %s object has Linux .note.ABI-tag section. \ Assuming %s\n" @ MSG_ERR_DWOVRFLW "%s: %s: encoded DWARF data exceeds section size\n" @ MSG_ERR_DWBADENC "%s: %s: bad DWARF encoding: %#x\n" @ MSG_ERR_DWNOCIE "%s: %s: no CIE prior to FDE\n" # exception_range_entry table entries. # TRANSLATION_NOTE - the following entries provide for a series of one or more # standard 32-bit and 64-bit .exception_ranges table entries that align with # the initial title. @ MSG_EXR_TITLE_32 " index offset ret_addr \ length handler type_blk" @ MSG_EXR_ENTRY_32 "%10.10s 0x%8.8llx 0x%8.8llx 0x%8.8llx 0x%8.8llx \ 0x%8.8llx" @ MSG_EXR_TITLE_64 " index offset ret_addr \ length handler type_blk" @ MSG_EXR_ENTRY_64 "%10.10s 0x%16.16llx 0x%16.16llx 0x%16.16llx \ 0x%16.16llx 0x%16.16llx" # Elf Output Messages @ MSG_ELF_SHDR "Section Header[%d]: sh_name: %s" @ MSG_ELF_PHDR "Program Header[%d]:" @ MSG_ELF_SCN_CAP "Capabilities Section: %s" @ MSG_ELF_SCN_CAPCHAIN "Capabilities Chain Section: %s" @ MSG_ELF_SCN_INTERP "Interpreter Section: %s" @ MSG_ELF_SCN_VERDEF "Version Definition Section: %s" @ MSG_ELF_SCN_VERNEED "Version Needed Section: %s" @ MSG_ELF_SCN_SYMTAB "Symbol Table Section: %s" @ MSG_ELF_SCN_RELOC "Relocation Section: %s" @ MSG_ELF_SCN_UNWIND "Unwind Section: %s" @ MSG_ELF_SCN_DYNAMIC "Dynamic Section: %s" @ MSG_ELF_SCN_NOTE "Note Section: %s" @ MSG_ELF_SCN_HASH "Hash Section: %s" @ MSG_ELF_SCN_SYMINFO "Syminfo Section: %s" @ MSG_ELF_SCN_GOT "Global Offset Table Section: %s" @ MSG_ELF_SCN_GRP "Group Section: %s" @ MSG_ELF_SCN_MOVE "Move Section: %s" @ MSG_ELF_SCN_SYMSORT1 "Symbol Sort Section: %s (%s)" @ MSG_ELF_SCN_SYMSORT2 "Symbol Sort Section: %s (%s / %s)" @ MSG_OBJ_CAP_TITLE " Object Capabilities:" @ MSG_SYM_CAP_TITLE " Symbol Capabilities:" @ MSG_CAPINFO_ENTRIES " Symbols:" @ MSG_CAPCHAIN_TITLE " Capabilities family: %s" @ MSG_CAPCHAIN_ENTRY " chainndx symndx name" @ MSG_ERR_INVCAP "%s: capabilities section: %s: contains symbol \ capabilities groups, but no capabilities information \ section is defined: invalid sh_link: %d\n" @ MSG_ERR_INVCAPINFO1 "%s: capabilities information section: %s: no symbol \ table is defined: invalid sh_link: %d\n" @ MSG_ERR_INVCAPINFO2 "%s: capabilities information section: %s: no \ capabilities chain is defined: invalid sh_info: %d\n" @ MSG_ERR_INVCAPINFO3 "%s: capabilities information section: %s: index %d: \ bad capabilities chain index defined: %d\n" @ MSG_ERR_CHBADSYMNDX "%s: bad symbol reference %d: from capability chain: \ %s entry: %d\n" @ MSG_ELF_HASH_BKTS1 "%10.10s buckets contain %8d symbols" @ MSG_ELF_HASH_BKTS2 "%10.10s buckets %8d symbols (globals)" @ MSG_ELF_HASH_INFO " bucket symndx name" @ MSG_HASH_OVERFLW "%s: warning: section %s: too many symbols to count, \ bucket=%d count=%d" @ MSG_ELF_ERR_SHDR "\tunable to obtain section header: shstrtab[%lld]\n" @ MSG_ELF_ERR_DATA "\tunable to obtain section data: shstrtab[%lld]\n" @ MSG_ELF_ERR_SCN "\tunable to obtain section header: section[%d]\n" @ MSG_ELF_ERR_SCNDATA "\tunable to obtain section data: section[%d]\n" @ MSG_ARCHIVE_SYMTAB_32 "\nSymbol Table: (archive, 32-bit offsets)" @ MSG_ARCHIVE_SYMTAB_64 "\nSymbol Table: (archive, 64-bit offsets)" @ MSG_ARCHIVE_FIELDS_32 " index offset member name and symbol" @ MSG_ARCHIVE_FIELDS_64 " index offset member name and symbol" @ MSG_GOT_MULTIPLE "%s: multiple relocations against \ the same GOT entry ndx: %d addr: 0x%llx\n" @ MSG_GOT_UNEXPECTED "%s: warning: section %s: section unexpected within \ relocatable object\n" # Miscellaneous clutter @ MSG_STR_NULL "(null)" @ MSG_STR_DEPRECATED "(deprecated value)" @ MSG_STR_UNKNOWN "" @ MSG_STR_SECTION "%s (section)" @ MSG_STR_CHECKSUM "elf checksum: 0x%lx" @ MSG_STR_VADDR "virtual address" @ MSG_STR_OFFSET "offset" @ MSG_STR_FILESIZE "file size" @ MSG_STR_MEMSIZE "memory size" @ MSG_STR_ALIGNMENT "alignment" @ MSG_FMT_SCNNDX "section[%d]" @ MSG_FMT_NOTEENTNDX " entry [%d]"; @ MSG_ERR_MALLOC "%s: malloc: %s\n" @ MSG_ERR_OPEN "%s: open: %s\n" @ MSG_ERR_READ "%s: read: %s\n" @ MSG_ERR_WRITE "%s: write: %s\n" @ MSG_ERR_BAD_T_SHT "%s: unrecognized section header type: %s\n" @ MSG_ERR_BAD_T_PT "%s: unrecognized program header type: %s\n" @ MSG_ERR_BAD_T_OSABI "%s: unrecognized operating system ABI: %s\n" @ MSG_ERR_AMBIG_MATCH "%s: ambiguous use of -I, -N, or -T. Remove \ -p option or section selection option(s)\n" # Program/section correspondence messages @ MSG_SHDR_PHDR_MISMATCH "%s: Section[%d: %s]: %s does not \ match %s segment: %s=%x: Program \ Header[%d].%s=%x\n" @ MSG_SHDR_NO_PHDR "%s: Section[%d: %s]: has no matching \ %s segment\n" # # SHT_MOVE messages # @ MSG_MOVE_TITLE " symndx offset size repeat stride \ value with respect to" @ MSG_MOVE_ENTRY "%10.10s %#10llx %6d %6d %6d %#16llx %s" # # SHT_GROUP messages # @ MSG_GRP_TITLE " index flags / section signature symbol" @ MSG_GRP_SIGNATURE " [0] %-24s %s" @ MSG_GRP_INVALSCN "" # # SHT_NOTE messages # @ MSG_NOTE_BADDATASZ "%s: %s: note header exceeds section size. \ offset: 0x%x\n" @ MSG_NOTE_BADNMSZ "%s: %s: note name value exceeds section size. \ offset: 0x%x namesize: 0x%x\n" @ MSG_NOTE_BADDESZ "%s: %s: note data size exceeds section size. \ offset: 0x%x datasize: 0x%x\n" @ MSG_NOTE_BADCOREARCH "%s: elfdump core file note support not available for \ architecture: %s\n" @ MSG_NOTE_BADCOREDATA "%s: elfdump core file note data truncated or \ otherwise malformed\n" @ MSG_NOTE_BADCORETYPE "%s: unknown note type %#x\n" @ MSG_NOTE_BAD_SECFLAGS_VER "unknown prsecflags_t version: " @ MSG_NOTE_BAD_UPANIC_VER "unknown prupanic_t version: " @ _END_ # The following strings represent reserved words, files, pathnames and symbols. # Reference to this strings is via the MSG_ORIG() macro, and thus no message # translation is required. @ MSG_STR_OSQBRKT "[" @ MSG_STR_CSQBRKT "]" @ MSG_GRP_COMDAT " COMDAT " @ MSG_GRP_ENTRY "%10.10s %s [%lld]\n" @ MSG_GRP_UNKNOWN " 0x%x " @ MSG_ELF_GOT ".got" @ MSG_ELF_INIT ".init" @ MSG_ELF_FINI ".fini" @ MSG_ELF_INTERP ".interp" @ MSG_ELF_GETEHDR "elf_getehdr" @ MSG_ELF_GETPHDR "elf_getphdr" @ MSG_ELF_GETSHDR "elf_getshdr" @ MSG_ELF_GETSCN "elf_getscn" @ MSG_ELF_GETDATA "elf_getdata" @ MSG_ELF_GETARHDR "elf_getarhdr" @ MSG_ELF_GETARSYM "elf_getarsym" @ MSG_ELF_RAND "elf_rand" @ MSG_ELF_BEGIN "elf_begin" @ MSG_ELF_GETPHDRNUM "elf_getphdrnum" @ MSG_ELF_GETSHDRNUM "elf_getshdrnum" @ MSG_ELF_GETSHDRSTRNDX "elf_getshdrstrndx" @ MSG_ELF_XLATETOM "elf_xlatetom" @ MSG_ELF_ARSYM "ARSYM" @ MSG_SYM_INIT "_init" @ MSG_SYM_FINI "_fini" @ MSG_SYM_GOT "_GLOBAL_OFFSET_TABLE_" @ MSG_STR_OPTIONS "CcdeGgHhiI:klmN:nO:PprSsT:uvw:y" @ MSG_STR_8SP " " @ MSG_STR_EMPTY "" @ MSG_STR_CORE "CORE" @ MSG_STR_NOTEABITAG ".note.ABI-tag" @ MSG_STR_GNU "GNU" @ MSG_STR_LOC "loc" @ MSG_STR_INITLOC "initloc" @ MSG_FMT_INDENT " %s" @ MSG_FMT_INDEX " [%lld]" @ MSG_FMT_INDEX2 "[%d]" @ MSG_FMT_ASRINDEX "[ asr%d ]" @ MSG_FMT_INDEXRNG "[%d-%d]" @ MSG_FMT_INTEGER " %d" @ MSG_FMT_HASH_INFO "%10.10s %-10s %s" @ MSG_FMT_CHAIN_INFO "%10.10s %-10s %s" @ MSG_FMT_ARSYM1_32 "%10.10s 0x%8.8llx (%s):%s" @ MSG_FMT_ARSYM2_32 "%10.10s 0x%8.8llx" @ MSG_FMT_ARSYM1_64 "%10.10s 0x%16.16llx (%s):%s" @ MSG_FMT_ARSYM2_64 "%10.10s 0x%16.16llx" @ MSG_FMT_ARNAME "%s(%s)" @ MSG_FMT_NLSTR "\n%s:" @ MSG_FMT_NLSTRNL "\n%s:\n" @ MSG_FMT_SECSYM "%.*s%s" @ MSG_HEXDUMP_ROW "%*s%-*s%s" @ MSG_SUNW_OST_SGS "SUNW_OST_SGS" # Unwind info @ MSG_SCN_FRM ".eh_frame" @ MSG_SCN_FRMHDR ".eh_frame_hdr" @ MSG_SCN_EXRANGE ".exception_ranges" @ MSG_UNW_FRMHDR "Frame Header:" @ MSG_UNW_FRMVERS " Version: %d" @ MSG_UNW_FRPTRENC " FramePtrEnc: %-20s FramePtr: %#llx" @ MSG_UNW_FDCNENC " FdeCntEnc: %-20s FdeCnt: %lld" @ MSG_UNW_TABENC " TableEnc: %-20s" @ MSG_UNW_BINSRTAB1 " Binary Search Table:" @ MSG_UNW_BINSRTAB2_32 " InitialLoc FdeLoc" @ MSG_UNW_BINSRTAB2_64 " InitialLoc FdeLoc" @ MSG_UNW_BINSRTABENT_32 " 0x%08llx 0x%08llx" @ MSG_UNW_BINSRTABENT_64 " 0x%016llx 0x%016llx" @ MSG_UNW_ZEROTERM "ZERO terminator: [0x00000000]" @ MSG_UNW_CIE "CIE: [%#llx]" @ MSG_UNW_CIELNGTH " length: 0x%02x cieid: %d" @ MSG_UNW_CIEVERS " version: %d augmentation: `%s'" @ MSG_UNW_CIECALGN " codealign: %#llx dataalign: %lld \ retaddr: %d" @ MSG_UNW_CIEAXVAL " Augmentation Data:" @ MSG_UNW_CIEAXSIZ " size: %lld" @ MSG_UNW_CIEAXPERS " personality:" @ MSG_UNW_CIEAXPERSENC " encoding: 0x%02x %s" @ MSG_UNW_CIEAXPERSRTN " routine: %#08llx" @ MSG_UNW_CIEAXCENC " code pointer encoding: 0x%02x %s" @ MSG_UNW_CIEAXLSDA " lsda encoding: 0x%02x %s" @ MSG_UNW_CIEAXUNEC " Unexpected aug val: %c" @ MSG_UNW_CIECFI " CallFrameInstructions:" @ MSG_UNW_FDE " FDE: [%#llx]" @ MSG_UNW_FDELNGTH " length: %#x cieptr: %#x" @ MSG_UNW_FDEINITLOC " initloc: %#llx addrrange: %#llx endloc: %#llx" @ MSG_UNW_FDEAXVAL " Augmentation Data:" @ MSG_UNW_FDEAXSIZE " size: %#llx" @ MSG_UNW_FDEAXLSDA " lsda: %#llx" @ MSG_UNW_FDECFI " CallFrameInstructions:" # Unwind section Call Frame Instructions. These all start with a leading # "%*s%s", used to insert leading white space and the opcode name. @ MSG_CFA_ADV_LOC "%*s%s: %s + %llu => %#llx" @ MSG_CFA_CFAOFF "%*s%s: %s, cfa%+lld" @ MSG_CFA_CFASET "%*s%s: cfa=%#llx" @ MSG_CFA_LLD "%*s%s: %lld" @ MSG_CFA_LLU "%*s%s: %llu" @ MSG_CFA_REG "%*s%s: %s" @ MSG_CFA_REG_OFFLLD "%*s%s: %s, offset=%lld" @ MSG_CFA_REG_OFFLLU "%*s%s: %s, offset=%llu" @ MSG_CFA_REG_REG "%*s%s: %s, %s" @ MSG_CFA_SIMPLE "%*s%s" @ MSG_CFA_SIMPLEREP "%*s%s [%d]" @ MSG_CFA_EBLK "%*s%s: expr(%llu bytes)" @ MSG_CFA_REG_EBLK "%*s%s: %s, expr(%llu bytes)" # Architecture specific register name formats @ MSG_REG_FMT_BASIC "r%d" @ MSG_REG_FMT_NAME "r%d (%s)" # Note messages @ MSG_NOTE_TYPE " type: %#x" @ MSG_NOTE_TYPE_STR " type: %s" @ MSG_NOTE_NAMESZ " namesz: %#x" @ MSG_NOTE_NAME " name:" @ MSG_NOTE_DESCSZ " descsz: %#x" @ MSG_NOTE_DESC " desc:" @ MSG_CNOTE_DESC_ASRSET_T "desc: (asrset_t)" @ MSG_CNOTE_DESC_AUXV_T "desc: (auxv_t)" @ MSG_CNOTE_DESC_CORE_CONTENT_T "desc: (core_content_t)" @ MSG_CNOTE_DESC_LWPSINFO_T "desc: (lwpsinfo_t)" @ MSG_CNOTE_DESC_LWPSTATUS_T "desc: (lwpstatus_t)" @ MSG_CNOTE_DESC_PRCRED_T "desc: (prcred_t)" @ MSG_CNOTE_DESC_PRIV_IMPL_INFO_T "desc: (priv_impl_info_t)" @ MSG_CNOTE_DESC_PRPRIV_T "desc: (prpriv_t)" @ MSG_CNOTE_DESC_PRPSINFO_T "desc: (prpsinfo_t)" @ MSG_CNOTE_DESC_PRSTATUS_T "desc: (prstatus_t)" @ MSG_CNOTE_DESC_PSINFO_T "desc: (psinfo_t)" @ MSG_CNOTE_DESC_PSTATUS_T "desc: (pstatus_t)" @ MSG_CNOTE_DESC_STRUCT_UTSNAME "desc: (struct utsname)" @ MSG_CNOTE_DESC_PRFDINFO_T "desc: (prfdinfo_core_t)" @ MSG_CNOTE_DESC_PRSECFLAGS_T "desc: (prsecflags_t)" @ MSG_CNOTE_DESC_PRLWPNAME_T "desc: (prlwpname_t)" @ MSG_CNOTE_DESC_PRUPANIC_T "desc: (prupanic_t)" @ MSG_CNOTE_DESC_PRCWD_T "desc: (prcwd_t)" @ MSG_CNOTE_FMT_LINE "%*s%-*s%s" @ MSG_CNOTE_FMT_LINE_2UP "%*s%-*s%-*s%-*s%s" @ MSG_CNOTE_FMT_D "%d" @ MSG_CNOTE_FMT_LLD "%lld" @ MSG_CNOTE_FMT_U "%u" @ MSG_CNOTE_FMT_LLU "%llu" @ MSG_CNOTE_FMT_X "%#x" @ MSG_CNOTE_FMT_LLX "%#llx" @ MSG_CNOTE_FMT_Z2X "0x%2.2x" @ MSG_CNOTE_FMT_Z4X "0x%4.4x" @ MSG_CNOTE_FMT_Z8X "0x%8.8x" @ MSG_CNOTE_FMT_Z16LLX "0x%16.16llx" @ MSG_CNOTE_FMT_TITLE "%*s%s" @ MSG_CNOTE_FMT_AUXVLINE "%*s%10.10s %-*s %s" @ MSG_CNOTE_FMT_PRTPCT "%u.%u%%" @ MSG_CNOTE_T_PRIV_FLAGS "priv_flags:" @ MSG_CNOTE_T_PRIV_GLOBALINFOSIZE "priv_globalinfosize:" @ MSG_CNOTE_T_PRIV_HEADERSIZE "priv_headersize:" @ MSG_CNOTE_T_PRIV_INFOSIZE "priv_infosize:" @ MSG_CNOTE_T_PRIV_MAX "priv_max:" @ MSG_CNOTE_T_PRIV_NSETS "priv_nsets:" @ MSG_CNOTE_T_PRIV_SETSIZE "priv_setsize:" @ MSG_CNOTE_T_PR_ACTION "pr_action:" @ MSG_CNOTE_T_PR_ADDR "pr_addr:" @ MSG_CNOTE_T_PR_AGENTID "pr_agentid:" @ MSG_CNOTE_T_PR_ALTSTACK "pr_altstack:" @ MSG_CNOTE_T_PR_ARGC "pr_argc:" @ MSG_CNOTE_T_PR_ARGV "pr_argv:" @ MSG_CNOTE_T_PR_ASLWPID "pr_aslwpid:" @ MSG_CNOTE_T_PR_BIND "pr_bind:" @ MSG_CNOTE_T_PR_BINDPRO "pr_bindpro:" @ MSG_CNOTE_T_PR_BINDPSET "pr_bindpset:" @ MSG_CNOTE_T_PR_BRKBASE "pr_brkbase:" @ MSG_CNOTE_T_PR_BRKSIZE "pr_brksize:" @ MSG_CNOTE_T_PR_BYRSSIZE "pr_byrssize:" @ MSG_CNOTE_T_PR_BYSIZE "pr_bysize:" @ MSG_CNOTE_T_PR_CLNAME "pr_clname:" @ MSG_CNOTE_T_PR_CONTRACT "pr_contract:" @ MSG_CNOTE_T_PR_CPU "pr_cpu:" @ MSG_CNOTE_T_PR_CSTIME "pr_cstime:" @ MSG_CNOTE_T_PR_CTIME "pr_ctime:" @ MSG_CNOTE_T_PR_CURSIG "pr_cursig:" @ MSG_CNOTE_T_PR_CUTIME "pr_cutime:" @ MSG_CNOTE_T_PR_DMODEL "pr_dmodel:" @ MSG_CNOTE_T_PR_EGID "pr_egid:" @ MSG_CNOTE_T_PR_ENVP "pr_envp:" @ MSG_CNOTE_T_PR_ERRNO "pr_errno:" @ MSG_CNOTE_T_PR_ERRPRIV "pr_errpriv:" @ MSG_CNOTE_T_PR_EUID "pr_euid:" @ MSG_CNOTE_T_PR_FLAG "pr_flag:" @ MSG_CNOTE_T_PR_FLAGS "pr_flags:" @ MSG_CNOTE_T_PR_FLTTRACE "pr_flttrace:" @ MSG_CNOTE_T_PR_FNAME "pr_fname:" @ MSG_CNOTE_T_PR_FPREG "pr_fpreg:" @ MSG_CNOTE_T_PR_GID "pr_gid:" @ MSG_CNOTE_T_PR_GROUPS "pr_groups:" @ MSG_CNOTE_T_PR_INFO "pr_info:" @ MSG_CNOTE_T_PR_INFOSIZE "pr_infosize:" @ MSG_CNOTE_T_PR_INSTR "pr_instr:" @ MSG_CNOTE_T_PR_LGRP "pr_lgrp:" @ MSG_CNOTE_T_PR_LTTYDEV "pr_lttydev:" @ MSG_CNOTE_T_PR_LWP "pr_lwp:" @ MSG_CNOTE_T_PR_LWPHOLD "pr_lwphold:" @ MSG_CNOTE_T_PR_LWPID "pr_lwpid:" @ MSG_CNOTE_T_PR_LWPNAME "pr_lwpname:" @ MSG_CNOTE_T_PR_LWPPEND "pr_lwppend:" @ MSG_CNOTE_T_PR_NAME "pr_name:" @ MSG_CNOTE_T_PR_NGROUPS "pr_ngroups:" @ MSG_CNOTE_T_PR_NICE "pr_nice:" @ MSG_CNOTE_T_PR_NLWP "pr_nlwp:" @ MSG_CNOTE_T_PR_NSETS "pr_nsets:" @ MSG_CNOTE_T_PR_NSYSARG "pr_nsysarg:" @ MSG_CNOTE_T_PR_NZOMB "pr_nzomb:" @ MSG_CNOTE_T_PR_OLDCONTEXT "pr_oldcontext:" @ MSG_CNOTE_T_PR_OLDPRI "pr_oldpri:" @ MSG_CNOTE_T_PR_ONPRO "pr_onpro:" @ MSG_CNOTE_T_PR_OTTYDEV "pr_ottydev:" @ MSG_CNOTE_T_PR_PCTCPU "pr_pctcpu:" @ MSG_CNOTE_T_PR_PCTMEM "pr_pctmem:" @ MSG_CNOTE_T_PR_PGID "pr_pgid:" @ MSG_CNOTE_T_PR_PGRP "pr_pgrp:" @ MSG_CNOTE_T_PR_PID "pr_pid:" @ MSG_CNOTE_T_PR_POOLID "pr_poolid:" @ MSG_CNOTE_T_PR_PPID "pr_ppid:" @ MSG_CNOTE_T_PR_PRI "pr_pri:" @ MSG_CNOTE_T_PR_PROCESSOR "pr_processor:" @ MSG_CNOTE_T_PR_PROJID "pr_projid:" @ MSG_CNOTE_T_PR_PSARGS "pr_psargs:" @ MSG_CNOTE_T_PR_REG "pr_reg:" @ MSG_CNOTE_T_PR_RGID "pr_rgid:" @ MSG_CNOTE_T_PR_RSSIZE "pr_rssize:" @ MSG_CNOTE_T_PR_RUID "pr_ruid:" @ MSG_CNOTE_T_PR_RVAL1 "pr_rval1:" @ MSG_CNOTE_T_PR_RVAL2 "pr_rval2:" @ MSG_CNOTE_T_PR_SETS "pr_sets:" @ MSG_CNOTE_T_PR_SETSIZE "pr_setsize:" @ MSG_CNOTE_T_PR_SGID "pr_sgid:" @ MSG_CNOTE_T_PR_SID "pr_sid:" @ MSG_CNOTE_T_PR_SIGHOLD "pr_sighold:" @ MSG_CNOTE_T_PR_SIGPEND "pr_sigpend:" @ MSG_CNOTE_T_PR_SIGTRACE "pr_sigtrace:" @ MSG_CNOTE_T_PR_SIZE "pr_size:" @ MSG_CNOTE_T_PR_SNAME "pr_sname:" @ MSG_CNOTE_T_PR_START "pr_start:" @ MSG_CNOTE_T_PR_STATE "pr_state:" @ MSG_CNOTE_T_PR_STIME "pr_stime:" @ MSG_CNOTE_T_PR_STKBASE "pr_stkbase:" @ MSG_CNOTE_T_PR_STKSIZE "pr_stksize:" @ MSG_CNOTE_T_PR_STYPE "pr_stype:" @ MSG_CNOTE_T_PR_SUID "pr_suid:" @ MSG_CNOTE_T_PR_SYSARG "pr_sysarg:" @ MSG_CNOTE_T_PR_SYSCALL "pr_syscall:" @ MSG_CNOTE_T_PR_SYSENTRY "pr_sysentry:" @ MSG_CNOTE_T_PR_SYSEXIT "pr_sysexit:" @ MSG_CNOTE_T_PR_TASKID "pr_taskid:" @ MSG_CNOTE_T_PR_TIME "pr_time:" @ MSG_CNOTE_T_PR_TSTAMP "pr_tstamp:" @ MSG_CNOTE_T_PR_TTYDEV "pr_ttydev:" @ MSG_CNOTE_T_PR_UID "pr_uid:" @ MSG_CNOTE_T_PR_USTACK "pr_ustack:" @ MSG_CNOTE_T_PR_UTIME "pr_utime:" @ MSG_CNOTE_T_PR_WCHAN "pr_wchan:" @ MSG_CNOTE_T_PR_WHAT "pr_what:" @ MSG_CNOTE_T_PR_WHO "pr_who:" @ MSG_CNOTE_T_PR_WHY "pr_why:" @ MSG_CNOTE_T_PR_WSTAT "pr_wstat:" @ MSG_CNOTE_T_PR_ZOMB "pr_zomb:" @ MSG_CNOTE_T_PR_ZONEID "pr_zoneid:" @ MSG_CNOTE_T_PR_EFFECTIVE "pr_effective:" @ MSG_CNOTE_T_PR_INHERIT "pr_inherit:" @ MSG_CNOTE_T_PR_LOWER "pr_lower:" @ MSG_CNOTE_T_PR_UPPER "pr_upper:" @ MSG_CNOTE_T_PR_VERSION "pr_version:" @ MSG_CNOTE_T_SA_FLAGS "sa_flags:" @ MSG_CNOTE_T_SA_HANDLER "sa_handler:" @ MSG_CNOTE_T_SA_MASK "sa_mask:" @ MSG_CNOTE_T_SA_SIGACTION "sa_sigaction:" @ MSG_CNOTE_T_SIVAL_INT "sival_int:" @ MSG_CNOTE_T_SIVAL_PTR "sival_ptr:" @ MSG_CNOTE_T_SI_ADDR "si_addr:" @ MSG_CNOTE_T_SI_BAND "si_band:" @ MSG_CNOTE_T_SI_CODE "si_code:" @ MSG_CNOTE_T_SI_CTID "si_ctid:" @ MSG_CNOTE_T_SI_ENTITY "si_entity" @ MSG_CNOTE_T_SI_ERRNO "si_errno:" @ MSG_CNOTE_T_SI_PID "si_pid:" @ MSG_CNOTE_T_SI_SIGNO "si_signo:" @ MSG_CNOTE_T_SI_STATUS "si_status:" @ MSG_CNOTE_T_SI_UID "si_uid:" @ MSG_CNOTE_T_SI_VALUE "si_value:" @ MSG_CNOTE_T_SI_ZONEID "si_zoneid:" @ MSG_CNOTE_T_SS_FLAGS "ss_flags:" @ MSG_CNOTE_T_SS_SIZE "ss_size:" @ MSG_CNOTE_T_SS_SP "ss_sp:" @ MSG_CNOTE_T_TV_NSEC "tv_nsec:" @ MSG_CNOTE_T_TV_SEC "tv_sec:" @ MSG_CNOTE_T_UTS_MACHINE "machine:" @ MSG_CNOTE_T_UTS_NODENAME "nodename:" @ MSG_CNOTE_T_UTS_RELEASE "release:" @ MSG_CNOTE_T_UTS_SYSNAME "sysname:" @ MSG_CNOTE_T_UTS_VERSION "version:" @ MSG_CNOTE_T_PR_FD "pr_fd:" @ MSG_CNOTE_T_PR_MODE "pr_mode:" @ MSG_CNOTE_T_PR_PATH "pr_path:" @ MSG_CNOTE_T_PR_MAJOR "pr_major:" @ MSG_CNOTE_T_PR_MINOR "pr_minor:" @ MSG_CNOTE_T_PR_RMAJOR "pr_rmajor:" @ MSG_CNOTE_T_PR_RMINOR "pr_rminor:" @ MSG_CNOTE_T_PR_OFFSET "pr_offset:" @ MSG_CNOTE_T_PR_INO "pr_ino:" @ MSG_CNOTE_T_PR_FILEFLAGS "pr_fileflags:" @ MSG_CNOTE_T_PR_FDFLAGS "pr_fdflags:" @ MSG_CNOTE_T_PRU_VERSION "pru_version:" @ MSG_CNOTE_T_PRU_FLAGS "pru_flags:" @ MSG_CNOTE_T_PRU_DATA "pru_data:" @ MSG_CNOTE_T_CWD_FSID "prcwd_fsid:" @ MSG_CNOTE_T_CWD_FSNAME "prcwd_fsname:" @ MSG_CNOTE_T_CWD_MNTPT "prcwd_mntpt:" @ MSG_CNOTE_T_CWD_MNTSPEC "prcwd_mntspec:" @ MSG_CNOTE_T_CWD_CWD "prcwd_cwd:" # Names of fake sections generated from program header data @ MSG_PHDRNAM_CAP ".SUNW_cap(phdr)" @ MSG_PHDRNAM_CAPINFO ".SUNW_capinfo(phdr)" @ MSG_PHDRNAM_CAPCHAIN ".SUNW_capchain(phdr)" @ MSG_PHDRNAM_DYN ".dynamic(phdr)" @ MSG_PHDRNAM_DYNSTR ".dynstr(phdr)" @ MSG_PHDRNAM_DYNSYM ".dynsym(phdr)" @ MSG_PHDRNAM_FINIARR ".fini_array(phdr)" @ MSG_PHDRNAM_HASH ".hash(phdr)" @ MSG_PHDRNAM_INITARR ".init_array(phdr)" @ MSG_PHDRNAM_INTERP ".interp(phdr)" @ MSG_PHDRNAM_LDYNSYM ".SUNW_ldynsym(phdr)" @ MSG_PHDRNAM_MOVE ".move(phdr)" @ MSG_PHDRNAM_NOTE ".note(phdr)" @ MSG_PHDRNAM_PREINITARR ".preinit_array(phdr)" @ MSG_PHDRNAM_REL ".rel(phdr)" @ MSG_PHDRNAM_RELA ".rela(phdr)" @ MSG_PHDRNAM_SYMINFO ".syminfo(phdr)" @ MSG_PHDRNAM_SYMSORT ".SUNW_symsort(phdr)" @ MSG_PHDRNAM_TLSSORT ".SUNW_tlssort(phdr)" @ MSG_PHDRNAM_UNWIND ".eh_frame_hdr(phdr)" @ MSG_PHDRNAM_VER ".SUNW_version(phdr)" /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2010 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Generate a cache of section header information for an ELF * object from the information found in its program headers. * * Malicious code can remove or corrupt section headers. The * resulting program will be difficult to analyze, but is still * runnable. Hence, scribbling on the section headers or removing * them is an effective form of obfuscation. On the other hand, * program headers must be accurate or the program will not run. * Section headers derived from them will necessarily lack information * found in the originals (particularly for non-allocable sections), * but will provide essential symbol information. The focus is on * recovering information that elfdump knows how to display, and that * might be interesting in a forensic situation. * * There are some things we don't attempt to create sections for: * * plt, got * We have no way to determine the length of either of * these sections from the information available via * the program headers or dynamic section. The data in * the PLT is of little use to elfdump. The data in the * GOT might be somewhat more interesting, especially as * it pertains to relocations. However, the sizing issue * remains. * * text, data, bss * Although we could create these, there is little value * to doing so. elfdump cannot display the arbitrary * data in these sections, so this would amount to a * simple repetition of the information already displayed * in the program headers, with no additional benefit. */ #include #include #include #include #include #include #include #include #include <_elfdump.h> /* * Common information about the object that is needed by * all the routines in this module. */ typedef struct { const char *file; int fd; Ehdr *ehdr; Phdr *phdr; size_t phnum; } FSTATE; /* * These values uniquely identify the sections that we know * how to recover. * * Note: We write the sections to the cache array in this same order. * It simplifies this code if the dynamic, dynstr, dynsym, and ldynsym * sections occupy known slots in the cache array. Other sections reference * them by index, and if they are at a known spot, there is no need * for a fixup pass. Putting them in positions [1-4] solves this. * * The order they are in was chosen such that if any one of them exists, * all of the ones before it must also exist. This means that if the * desired section exists, it will end up in the desired index in the * cache array. * * The order of the other sections is arbitrary. I've arranged them * in roughly related groups. */ typedef enum { SINFO_T_NULL = 0, SINFO_T_DYN = 1, SINFO_T_DYNSTR = 2, SINFO_T_DYNSYM = 3, SINFO_T_LDYNSYM = 4, SINFO_T_HASH = 5, SINFO_T_SYMINFO = 6, SINFO_T_SYMSORT = 7, SINFO_T_TLSSORT = 8, SINFO_T_VERNEED = 9, SINFO_T_VERDEF = 10, SINFO_T_VERSYM = 11, SINFO_T_INTERP = 12, SINFO_T_CAP = 13, SINFO_T_CAPINFO = 14, SINFO_T_CAPCHAIN = 15, SINFO_T_UNWIND = 16, SINFO_T_MOVE = 17, SINFO_T_REL = 18, SINFO_T_RELA = 19, SINFO_T_PREINITARR = 20, SINFO_T_INITARR = 21, SINFO_T_FINIARR = 22, SINFO_T_NOTE = 23, SINFO_T_NUM = 24 /* Count of items. Must come last */ } SINFO_TYPE; /* * Table of per-section constant data used to set up the section * header cache and the various sub-parts it references. Indexed by * SINFO_T value. * * note: The sh_flags value should be either SHF_ALLOC, or 0. * get_data() sets SHF_WRITE if the program header containing the * section is writable. The other flags require information that * the program headers don't contain (i.e. SHF_STRINGS, etc) so * we don't set them. */ typedef struct { const char *name; Word sh_type; Word sh_flags; Word sh_addralign; Word sh_entsize; Elf_Type libelf_type; } SINFO_DATA; /* * Many of these sections use an alignment given by M_WORD_ALIGN, a * value that varies depending on the object target machine. Since we * don't know that value at compile time, we settle for a value of * 4 for ELFCLASS32 objects, and 8 for ELFCLASS64. This matches the * platforms we current support (sparc and x86), and is good enough for * a fake section header in any event, as the resulting object is only * analyzed, and is not executed. */ #ifdef _ELF64 #define FAKE_M_WORD_ALIGN 8 #else #define FAKE_M_WORD_ALIGN 4 #endif static SINFO_DATA sinfo_data[SINFO_T_NUM] = { /* SINFO_T_NULL */ { 0 }, /* SINFO_T_DYN */ { MSG_ORIG(MSG_PHDRNAM_DYN), SHT_DYNAMIC, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Dyn), ELF_T_DYN }, /* SINFO_T_DYNSTR */ { MSG_ORIG(MSG_PHDRNAM_DYNSTR), SHT_STRTAB, SHF_ALLOC, 1, 0, ELF_T_BYTE }, /* SINFO_T_DYNSYM */ { MSG_ORIG(MSG_PHDRNAM_DYNSYM), SHT_DYNSYM, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Sym), ELF_T_SYM }, /* SINFO_T_LDYNSYM */ { MSG_ORIG(MSG_PHDRNAM_LDYNSYM), SHT_SUNW_LDYNSYM, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Sym), ELF_T_SYM }, /* SINFO_T_HASH */ { MSG_ORIG(MSG_PHDRNAM_HASH), SHT_HASH, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Word), ELF_T_WORD }, /* SINFO_T_SYMINFO */ { MSG_ORIG(MSG_PHDRNAM_SYMINFO), SHT_SUNW_syminfo, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Syminfo), ELF_T_SYMINFO }, /* SINFO_T_SYMSORT */ { MSG_ORIG(MSG_PHDRNAM_SYMSORT), SHT_SUNW_symsort, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Word), ELF_T_WORD }, /* SINFO_T_TLSSORT */ { MSG_ORIG(MSG_PHDRNAM_TLSSORT), SHT_SUNW_tlssort, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Word), ELF_T_WORD }, /* SINFO_T_VERNEED */ { MSG_ORIG(MSG_PHDRNAM_VER), SHT_SUNW_verneed, SHF_ALLOC, FAKE_M_WORD_ALIGN, 1, ELF_T_VNEED }, /* SINFO_T_VERDEF */ { MSG_ORIG(MSG_PHDRNAM_VER), SHT_SUNW_verdef, SHF_ALLOC, FAKE_M_WORD_ALIGN, 1, ELF_T_VDEF }, /* SINFO_T_VERSYM */ { MSG_ORIG(MSG_PHDRNAM_VER), SHT_SUNW_versym, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Versym), ELF_T_HALF }, /* SINFO_T_INTERP */ { MSG_ORIG(MSG_PHDRNAM_INTERP), SHT_PROGBITS, SHF_ALLOC, 1, 0, ELF_T_BYTE }, /* SINFO_T_CAP */ { MSG_ORIG(MSG_PHDRNAM_CAP), SHT_SUNW_cap, SHF_ALLOC, sizeof (Addr), sizeof (Cap), ELF_T_CAP }, /* SINFO_T_CAPINFO */ { MSG_ORIG(MSG_PHDRNAM_CAPINFO), SHT_SUNW_capinfo, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Capinfo), ELF_T_WORD }, /* SINFO_T_CAPCHAIN */ { MSG_ORIG(MSG_PHDRNAM_CAPCHAIN), SHT_SUNW_capchain, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Capchain), ELF_T_WORD }, /* SINFO_T_UNWIND */ { MSG_ORIG(MSG_PHDRNAM_UNWIND), SHT_AMD64_UNWIND, SHF_ALLOC, sizeof (Addr), 0, ELF_T_BYTE }, /* SINFO_T_MOVE */ { MSG_ORIG(MSG_PHDRNAM_MOVE), SHT_SUNW_move, SHF_ALLOC, sizeof (Lword), sizeof (Move), ELF_T_MOVE }, /* SINFO_T_REL */ { MSG_ORIG(MSG_PHDRNAM_REL), SHT_REL, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Rel), ELF_T_REL }, /* SINFO_T_RELA */ { MSG_ORIG(MSG_PHDRNAM_RELA), SHT_RELA, SHF_ALLOC, FAKE_M_WORD_ALIGN, sizeof (Rela), ELF_T_RELA }, /* SINFO_T_PREINITARR */ { MSG_ORIG(MSG_PHDRNAM_PREINITARR), SHT_PREINIT_ARRAY, SHF_ALLOC, sizeof (Addr), sizeof (Addr), ELF_T_ADDR }, /* SINFO_T_INITARR */ { MSG_ORIG(MSG_PHDRNAM_INITARR), SHT_INIT_ARRAY, SHF_ALLOC, sizeof (Addr), sizeof (Addr), ELF_T_ADDR }, /* SINFO_T_FINIARR */ { MSG_ORIG(MSG_PHDRNAM_FINIARR), SHT_FINI_ARRAY, SHF_ALLOC, sizeof (Addr), sizeof (Addr), ELF_T_ADDR }, /* SINFO_T_NOTE */ { MSG_ORIG(MSG_PHDRNAM_NOTE), SHT_NOTE, 0, FAKE_M_WORD_ALIGN, 1, ELF_T_NOTE } }; /* * As we read program headers and dynamic elements, we build up * the data for our fake section headers in variables of the * SINFO type. SINFO is used to track the sections that can only * appear a fixed number of times (usually once). * * SINFO_LISTELT is used for sections that can occur an arbitrary * number of times. They are kept in a doubly linked circular * buffer. */ typedef struct { SINFO_TYPE type; /* Our type code for the section */ Addr vaddr; /* Virtual memory address */ Off offset; /* File offset of data. Ignored unless */ /* vaddr is 0. Used by program headers */ size_t size; /* # bytes in section */ size_t vercnt; /* Used by verdef and verneed to hold count */ Shdr *shdr; /* Constructed shdr */ Elf_Data *data; /* Constructed data descriptor */ } SINFO; typedef struct _sinfo_listelt { struct _sinfo_listelt *next; struct _sinfo_listelt *prev; SINFO sinfo; } SINFO_LISTELT; /* * Free dynamic memory used by SINFO structures. * * entry: * sinfo - Address of first SINFO structure to free * n - # of structures to clear * * exit: * For each SINFO struct, the section header, data descriptor, * and data buffer are freed if non-NULL. The relevant * fields are set to NULL, and the type is set to SINFO_T_NULL. */ static void sinfo_free(SINFO *sinfo, size_t n) { for (; n-- > 0; sinfo++) { if (sinfo->data != NULL) { if (sinfo->data->d_buf != NULL) free(sinfo->data->d_buf); free(sinfo->data); sinfo->data = NULL; } if (sinfo->shdr) { free(sinfo->shdr); sinfo->shdr = NULL; } sinfo->type = SINFO_T_NULL; } } /* * Allocate a new SINFO_LISTELT and put it at the end of the * doubly linked list anchored by the given list root node. * * On success, a new node has been put at the end of the circular * doubly linked list, and a pointer to the SINFO sub-structure is * returned. On failure, an error is printed, and NULL is returned. */ static SINFO * sinfo_list_alloc(FSTATE *fstate, SINFO_LISTELT *root) { SINFO_LISTELT *elt; if ((elt = malloc(sizeof (*elt))) == NULL) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), fstate->file, strerror(err)); return (0); } elt->next = root; elt->prev = root->prev; root->prev = elt; elt->prev->next = elt; bzero(&elt->sinfo, sizeof (elt->sinfo)); return (&elt->sinfo); } /* * Release the memory used by the given list, restoring it to * an empty list. */ static void sinfo_list_free_all(SINFO_LISTELT *root) { SINFO_LISTELT *elt; for (elt = root->next; elt != root; elt = elt->next) sinfo_free(&elt->sinfo, 1); root->next = root->prev = root; } /* * Given a virtual address and desired size of the data to be found * at that address, look through the program headers for the PT_LOAD * segment that contains it and return the offset within the ELF file * at which it resides. * * entry: * fstate - Object state * addr - virtual address to be translated * size - Size of the data to be found at that address, in bytes * zero_bytes - NULL, or address to receive the number of data * bytes at the end of the data that are not contained * in the file, and which must be zero filled by the caller. * If zero_bytes is NULL, the file must contain all of the * desired data. If zero_bytes is not NULL, then the program * header must reserve the space for all of the data (p_memsz) * but it is acceptable for only part of the data to be in * the file (p_filesz). *zero_bytes is set to the difference * in size, and is the number of bytes the caller must * set to 0 rather than reading from the file. * phdr_ret - NULL, or address of variable to receive pointer * to program header that contains offset. * exit: * On success: If zero_bytes is non-NULL, it is updated. If phdr_ret * is non-NULL, it is updated. The file offset is returned. * * On failure, 0 is returned. Since any ELF file we can understand * must start with an ELF magic number, 0 cannot be a valid file * offset for a virtual address, and is therefore unambiguous as * a failure indication. */ static Off map_addr_to_offset(FSTATE *fstate, Addr addr, size_t size, size_t *zero_bytes, Phdr **phdr_ret) { Off offset; Addr end_addr = addr + size; size_t avail_file; Phdr *phdr = fstate->phdr; size_t phnum = fstate->phnum; for (; phnum--; phdr++) { if (phdr->p_type != PT_LOAD) continue; if ((addr >= phdr->p_vaddr) && (end_addr <= (phdr->p_vaddr + phdr->p_memsz))) { /* * Subtract segment virtual address, leaving the * offset relative to the segment (not the file). */ offset = addr - phdr->p_vaddr; avail_file = phdr->p_filesz - offset; /* * The addr/size are in bounds for this segment. * Is there enough data in the file to satisfy * the request? If zero_bytes is NULL, it must * all be in the file. Otherwise it can be * zero filled. */ if (zero_bytes == NULL) { if (size > avail_file) continue; } else { *zero_bytes = (size > avail_file) ? (size - avail_file) : 0; } if (phdr_ret != NULL) *phdr_ret = phdr; /* Add segment file offset, giving overall offset */ return (phdr->p_offset + offset); } } /* If we get here, the mapping failed */ return (0); } /* * This routine is the same thing as map_addr_to_offset(), except that * it goes the other way, mapping from offset to virtual address. * * The comments for map_addr_to_offset() are applicable if you * reverse offset and address. */ static Addr map_offset_to_addr(FSTATE *fstate, Off offset, size_t size, size_t *zero_bytes, Phdr **phdr_ret) { Off end_offset = offset + size; size_t avail_file; Phdr *phdr = fstate->phdr; size_t phnum = fstate->phnum; for (; phnum--; phdr++) { if (phdr->p_type != PT_LOAD) continue; if ((offset >= phdr->p_offset) && (end_offset <= (phdr->p_offset + phdr->p_memsz))) { /* * Subtract segment offset, leaving the * offset relative to the segment (not the file). */ offset -= phdr->p_offset; avail_file = phdr->p_filesz - offset; /* * The offset/size are in bounds for this segment. * Is there enough data in the file to satisfy * the request? If zero_bytes is NULL, it must * all be in the file. Otherwise it can be * zero filled. */ if (zero_bytes == NULL) { if (size > avail_file) continue; } else { *zero_bytes = (size > avail_file) ? (size - avail_file) : 0; } if (phdr_ret != NULL) *phdr_ret = phdr; /* Add segment virtual address, giving overall addr */ return (phdr->p_vaddr + offset); } } /* If we get here, the mapping failed */ return (0); } /* * Use elf_xlatetom() to convert the bytes in buf from their * in-file representation to their in-memory representation. * * Returns True(1) for success. On failure, an error message is printed * and False(0) is returned. */ static int xlate_data(FSTATE *fstate, void *buf, size_t nbyte, Elf_Type xlate_type) { Elf_Data data; data.d_type = xlate_type; data.d_size = nbyte; data.d_off = 0; data.d_align = 0; data.d_version = fstate->ehdr->e_version; data.d_buf = buf; if (elf_xlatetom(&data, &data, fstate->ehdr->e_ident[EI_DATA]) == NULL) { failure(fstate->file, MSG_ORIG(MSG_ELF_XLATETOM)); return (0); } return (1); } /* * Read nbytes of data into buf, starting at the specified offset * within the ELF file. * * entry: * fstate - Object state * offset - Offset within the file at which desired data resides. * buf - Buffer to receive the data * nbyte - # of bytes to read into buf * xlate_type - An ELF xlate type, specifying the type of data * being input. If xlate_type is ELF_T_BYTE, xlate is not * done. Otherwise, xlate_data() is called to convert the * data into its in-memory representation. * exit: * On success, the data has been written into buf, xlate_data() * called on it if required, and True(1) is returned. Otherwise * False(0) is returned. * * note: * This routine does not move the file pointer. */ static int read_data(FSTATE *fstate, Off offset, void *buf, size_t nbyte, Elf_Type xlate_type) { if (pread(fstate->fd, buf, nbyte, offset) != nbyte) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_READ), fstate->file, strerror(err)); return (0); } if (xlate_type != ELF_T_BYTE) return (xlate_data(fstate, buf, nbyte, xlate_type)); return (1); } /* * Read the hash nbucket/nchain values from the start of the hash * table found at the given virtual address in the mapped ELF object. * * On success, *nbucket, and *nchain have been filled in with their * values, *total contains the number of elements in the hash table, * and this routine returns True (1). * * On failure, False (0) is returned. */ static int hash_size(FSTATE *fstate, SINFO *hash_sinfo, Word *nbucket, Word *nchain, size_t *total) { Off offset; Word buf[2]; offset = map_addr_to_offset(fstate, hash_sinfo->vaddr, sizeof (buf), NULL, NULL); if (offset == 0) return (0); if (read_data(fstate, offset, buf, sizeof (buf), ELF_T_WORD) == 0) return (0); *nbucket = buf[0]; *nchain = buf[1]; *total = 2 + *nbucket + *nchain; return (1); } /* * Read a Verdef structure at the specified file offset and return * its vd_cnt, vd_aux, and vd_next fields. */ static int read_verdef(FSTATE *fstate, Off offset, Half *cnt, Word *aux, Word *next) { Verdef verdef; if (read_data(fstate, offset, &verdef, sizeof (verdef), ELF_T_BYTE) == 0) return (0); /* xlate vd_cnt */ if (xlate_data(fstate, &verdef.vd_cnt, sizeof (verdef.vd_cnt), ELF_T_HALF) == 0) return (0); /* * xlate vd_aux and vd_next. These items are adjacent and are * both Words, so they can be handled in a single operation. */ if (xlate_data(fstate, &verdef.vd_aux, 2 * sizeof (Word), ELF_T_WORD) == 0) return (0); *cnt = verdef.vd_cnt; *aux = verdef.vd_aux; *next = verdef.vd_next; return (1); } /* * Read a Verdaux structure at the specified file offset and return * its vda_next field. */ static int read_verdaux(FSTATE *fstate, Off offset, Word *next) { Verdaux verdaux; if (read_data(fstate, offset, &verdaux, sizeof (verdaux), ELF_T_BYTE) == 0) return (0); /* xlate vda_next */ if (xlate_data(fstate, &verdaux.vda_next, sizeof (verdaux.vda_next), ELF_T_WORD) == 0) return (0); *next = verdaux.vda_next; return (1); } /* * Read a Verneed structure at the specified file offset and return * its vn_cnt, vn_aux, and vn_next fields. */ static int read_verneed(FSTATE *fstate, Off offset, Half *cnt, Word *aux, Word *next) { Verneed verneed; if (read_data(fstate, offset, &verneed, sizeof (verneed), ELF_T_BYTE) == 0) return (0); /* xlate vn_cnt */ if (xlate_data(fstate, &verneed.vn_cnt, sizeof (verneed.vn_cnt), ELF_T_HALF) == 0) return (0); /* * xlate vn_aux and vn_next. These items are adjacent and are * both Words, so they can be handled in a single operation. */ if (xlate_data(fstate, &verneed.vn_aux, 2 * sizeof (Word), ELF_T_WORD) == 0) return (0); *cnt = verneed.vn_cnt; *aux = verneed.vn_aux; *next = verneed.vn_next; return (1); } /* * Read a Vernaux structure at the specified file offset and return * its vna_next field. */ static int read_vernaux(FSTATE *fstate, Off offset, Word *next) { Vernaux vernaux; if (read_data(fstate, offset, &vernaux, sizeof (vernaux), ELF_T_BYTE) == 0) return (0); /* xlate vna_next */ if (xlate_data(fstate, &vernaux.vna_next, sizeof (vernaux.vna_next), ELF_T_WORD) == 0) return (0); *next = vernaux.vna_next; return (1); } /* * Compute the size of Verdef and Verneed sections. Both of these * sections are made up of interleaved main nodes (Verdef and Verneed) * and auxiliary blocks (Verdaux and Vernaux). These nodes refer to * each other by relative offsets. The linker has a lot of flexibility * in how it lays out these items, and we cannot assume a standard * layout. To determine the size of the section, we must read each * main node and compute the high water mark of the memory it and its * auxiliary structs access. * * Although Verdef/Verdaux and Verneed/Vernaux are different types, * their logical organization is the same. Each main block has * a cnt field that tells how many auxiliary blocks it has, an * aux field that gives the offset of the first auxiliary block, and * an offset to the next main block. Each auxiliary block contains * an offset to the next auxiliary block. By breaking the type specific * code into separate sub-functions, we can process both Verdef and * sections Verdaux from a single routine. * * entry: * fstate - Object state * sec - Section to be processed (SINFO_T_VERDEF or SINFO_T_VERNEED). * * exit: * On success, sec->size is set to the section size in bytes, and * True (1) is returned. On failure, False (0) is returned. */ static int verdefneed_size(FSTATE *fstate, SINFO *sec) { int (* read_main)(FSTATE *, Off, Half *, Word *, Word *); int (* read_aux)(FSTATE *, Off, Word *); size_t size_main, size_aux; Off offset, aux_offset; Off highwater, extent; size_t num_main = sec->vercnt; Half v_cnt; Word v_aux, v_next, va_next; /* * Set up the function pointers to the type-specific code * for fetching data from the main and auxiliary blocks. */ if (sec->type == SINFO_T_VERDEF) { read_main = read_verdef; read_aux = read_verdaux; size_main = sizeof (Verdef); size_aux = sizeof (Verdaux); } else { /* SINFO_T_VERNEED */ read_main = read_verneed; read_aux = read_vernaux; size_main = sizeof (Verneed); size_aux = sizeof (Vernaux); } /* * Map starting address to file offset. Save the starting offset * in the SINFO size field. Once we have the high water offset, we * can subtract this from it to get the size. * * Note: The size argument set here is a lower bound --- the * size of the main blocks without any auxiliary ones. It's * the best we can do until the size has been determined for real. */ offset = highwater = map_addr_to_offset(fstate, sec->vaddr, size_main * num_main, NULL, NULL); if (offset == 0) return (0); sec->size = offset; for (; num_main-- > 0; offset += v_next) { /* Does this move the high water mark up? */ extent = offset + size_main; if (extent > highwater) highwater = extent; if ((*read_main)(fstate, offset, &v_cnt, &v_aux, &v_next) == 0) return (0); /* * If there are auxiliary structures referenced, * check their position to see if it pushes * the high water mark. */ aux_offset = offset + v_aux; for (; v_cnt-- > 0; aux_offset += va_next) { extent = aux_offset + size_aux; if (extent > highwater) highwater = extent; if ((*read_aux)(fstate, aux_offset, &va_next) == 0) return (0); } } sec->size = highwater - sec->size; return (1); } /* * Allocate and fill in a fake section header, data descriptor, * and data buffer for the given section. Fill them in and read * the associated data into the buffer. * * entry: * fstate - Object state * sec - Section information * * exit: * On success, the actions described above are complete, and * True (1) is returned. * * On failure, an error is reported, all resources used by sec * are released, and sec->type is set to SINFO_T_NULL, effectively * eliminating its contents from any further use. False (0) is * returned. */ static int get_data(FSTATE *fstate, SINFO *sec) { SINFO_DATA *tinfo; size_t read_bytes, zero_bytes; Phdr *phdr = NULL; /* * If this is a NULL section, or if we've already processed * this item, then we are already done. */ if ((sec->type == SINFO_T_NULL) || (sec->shdr != NULL)) return (1); if (((sec->shdr = malloc(sizeof (*sec->shdr))) == NULL) || ((sec->data = malloc(sizeof (*sec->data))) == NULL)) { int err = errno; sinfo_free(sec, 1); (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), fstate->file, strerror(err)); return (0); } tinfo = &sinfo_data[sec->type]; /* * Fill in fake section header * * sh_name should be the offset of the name in the shstrtab * section referenced by the ELF header. There is no * value to elfdump in creating shstrtab, so we set * sh_name to 0, knowing that elfdump doesn't look at it. */ sec->shdr->sh_name = 0; sec->shdr->sh_type = tinfo->sh_type; sec->shdr->sh_flags = tinfo->sh_flags; if ((tinfo->sh_flags & SHF_ALLOC) == 0) { /* * Non-allocable section: Pass the addr (which is probably * 0) and offset through without inspection. */ sec->shdr->sh_addr = sec->vaddr; sec->shdr->sh_offset = sec->offset; zero_bytes = 0; } else if (sec->vaddr == 0) { /* * Allocable section with a 0 vaddr. Figure out the * real address by mapping the offset to it using the * program headers. */ sec->shdr->sh_addr = map_offset_to_addr(fstate, sec->offset, sec->size, &zero_bytes, &phdr); sec->shdr->sh_offset = sec->offset; } else { /* * Allocable section with non-0 vaddr. Use the vaddr * to derive the offset. */ sec->shdr->sh_addr = sec->vaddr; sec->shdr->sh_offset = map_addr_to_offset(fstate, sec->vaddr, sec->size, &zero_bytes, &phdr); } if (sec->shdr->sh_offset == 0) { sinfo_free(sec, 1); return (0); } /* * If the program header has its write flags set, then set * the section write flag. */ if (phdr && ((phdr->p_flags & PF_W) != 0)) sec->shdr->sh_flags |= SHF_WRITE; sec->shdr->sh_size = sec->size; sec->shdr->sh_link = 0; sec->shdr->sh_info = 0; sec->shdr->sh_addralign = tinfo->sh_addralign; sec->shdr->sh_entsize = tinfo->sh_entsize; /* * Some sections define special meanings for sh_link and sh_info. */ switch (tinfo->sh_type) { case SHT_DYNAMIC: sec->shdr->sh_link = SINFO_T_DYNSTR; break; case SHT_DYNSYM: sec->shdr->sh_link = SINFO_T_DYNSTR; sec->shdr->sh_info = 1; /* First global symbol */ break; case SHT_SUNW_LDYNSYM: sec->shdr->sh_link = SINFO_T_DYNSTR; /* * ldynsym is all local symbols, so the index of the * first global is equivalent to the number of symbols. */ sec->shdr->sh_info = sec->shdr->sh_size / sizeof (Sym); break; case SHT_HASH: case SHT_SUNW_move: case SHT_REL: case SHT_RELA: case SHT_SUNW_versym: sec->shdr->sh_link = SINFO_T_DYNSYM; break; case SHT_SUNW_verdef: case SHT_SUNW_verneed: sec->shdr->sh_link = SINFO_T_DYNSTR; sec->shdr->sh_info = sec->vercnt; break; case SHT_SUNW_syminfo: sec->shdr->sh_link = SINFO_T_DYNSYM; sec->shdr->sh_info = SINFO_T_DYN; break; case SHT_SUNW_symsort: case SHT_SUNW_tlssort: sec->shdr->sh_link = SINFO_T_LDYNSYM; break; } /* Fill in fake Elf_Data descriptor */ sec->data->d_type = tinfo->libelf_type; sec->data->d_size = sec->size; sec->data->d_off = 0; sec->data->d_align = tinfo->sh_addralign; sec->data->d_version = fstate->ehdr->e_version; if (sec->size == 0) { sec->data->d_buf = NULL; return (1); } if ((sec->data->d_buf = malloc(sec->size)) == NULL) { int err = errno; sinfo_free(sec, 1); (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), fstate->file, strerror(err)); return (0); } read_bytes = sec->size - zero_bytes; if ((read_bytes > 0) && (read_data(fstate, sec->shdr->sh_offset, sec->data->d_buf, read_bytes, ELF_T_BYTE) == 0)) { sinfo_free(sec, 1); return (0); } if (zero_bytes > 0) bzero(read_bytes + (char *)sec->data->d_buf, zero_bytes); if ((tinfo->libelf_type != ELF_T_BYTE) && (elf_xlatetom(sec->data, sec->data, fstate->ehdr->e_ident[EI_DATA]) == NULL)) { sinfo_free(sec, 1); failure(fstate->file, MSG_ORIG(MSG_ELF_XLATETOM)); return (0); } return (1); } /* * Generate a section header cache made up of information derived * from the program headers. * * entry: * file - Name of object * fd - Open file handle for object * elf - ELF descriptor * ehdr - Elf header * cache, shnum - Addresses of variables to receive resulting * cache and number of sections. * * exit: * On success, *cache and *shnum are set, and True (1) is returned. * On failure, False (0) is returned. * * note: * The cache returned by this routine must be freed using * fake_shdr_cache_free(), and not by a direct call to free(). * Otherwise, memory will leak. */ int fake_shdr_cache(const char *file, int fd, Elf *elf, Ehdr *ehdr, Cache **cache, size_t *shnum) { /* * The C language guarantees that a structure of homogeneous * items will receive exactly the same layout in a structure * as a plain array of the same type. Hence, this structure, which * gives us by-name or by-index access to the various section * info descriptors we maintain. * * We use this for sections where * - Only one instance is allowed * - We need to be able to access them easily by * name (for instance, when mining the .dynamic * section for information to build them up. * * NOTE: These fields must be in the same order as the * SINFO_T_ type codes that correspond to them. Otherwise, * they will end up in the wrong order in the cache array, * and the sh_link/sh_info fields may be wrong. */ struct { /* Note: No entry is needed for SINFO_T_NULL */ SINFO dyn; SINFO dynstr; SINFO dynsym; SINFO ldynsym; SINFO hash; SINFO syminfo; SINFO symsort; SINFO tlssort; SINFO verneed; SINFO verdef; SINFO versym; SINFO interp; SINFO cap; SINFO capinfo; SINFO capchain; SINFO unwind; SINFO move; SINFO rel; SINFO rela; SINFO preinitarr; SINFO initarr; SINFO finiarr; } sec; static const size_t sinfo_n = sizeof (sec) / sizeof (sec.dyn); SINFO *secarr = (SINFO *) &sec; /* * Doubly linked circular list, used to track sections * where multiple sections of a given type can exist. * seclist is the root of the list. Its sinfo field is not * used --- it serves to anchor the root of the list, allowing * rapid access to the first and last element in the list. */ SINFO_LISTELT seclist; FSTATE fstate; size_t ndx; size_t num_sinfo, num_list_sinfo; SINFO *sinfo; SINFO_LISTELT *sinfo_list; Cache *_cache; fstate.file = file; fstate.fd = fd; fstate.ehdr = ehdr; if (elf_getphdrnum(elf, &fstate.phnum) == -1) { failure(file, MSG_ORIG(MSG_ELF_GETPHDRNUM)); return (0); } if ((fstate.phdr = elf_getphdr(elf)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETPHDR)); return (0); } bzero(&sec, sizeof (sec)); /* Initialize "by-name" sec info */ seclist.next = seclist.prev = &seclist; /* Empty circular list */ /* * Go through the program headers and look for information * we can use to synthesize section headers. By far the most * valuable thing is a dynamic section, the contents of * which point at all sections used by ld.so.1. */ for (ndx = 0; ndx < fstate.phnum; ndx++) { /* * A program header with no file size does * not have a backing section. */ if (fstate.phdr[ndx].p_filesz == 0) continue; switch (fstate.phdr[ndx].p_type) { default: /* Header we can't use. Move on to next one */ continue; case PT_DYNAMIC: sec.dyn.type = SINFO_T_DYN; sinfo = &sec.dyn; break; case PT_INTERP: sec.interp.type = SINFO_T_INTERP; sinfo = &sec.interp; break; case PT_NOTE: if ((sinfo = sinfo_list_alloc(&fstate, &seclist)) == NULL) continue; sinfo->type = SINFO_T_NOTE; break; case PT_SUNW_UNWIND: case PT_SUNW_EH_FRAME: sec.unwind.type = SINFO_T_UNWIND; sinfo = &sec.unwind; break; case PT_SUNWCAP: sec.cap.type = SINFO_T_CAP; sinfo = &sec.cap; break; } /* * Capture the position/extent information for * the header in the SINFO struct set up by the * switch statement above. */ sinfo->vaddr = fstate.phdr[ndx].p_vaddr; sinfo->offset = fstate.phdr[ndx].p_offset; sinfo->size = fstate.phdr[ndx].p_filesz; } /* * If we found a dynamic section, look through it and * gather information about the sections it references. */ if (sec.dyn.type == SINFO_T_DYN) (void) get_data(&fstate, &sec.dyn); if ((sec.dyn.type == SINFO_T_DYN) && (sec.dyn.data->d_buf != NULL)) { Dyn *dyn; for (dyn = sec.dyn.data->d_buf; dyn->d_tag != DT_NULL; dyn++) { switch (dyn->d_tag) { case DT_HASH: sec.hash.type = SINFO_T_HASH; sec.hash.vaddr = dyn->d_un.d_ptr; break; case DT_STRTAB: sec.dynstr.type = SINFO_T_DYNSTR; sec.dynstr.vaddr = dyn->d_un.d_ptr; break; case DT_SYMTAB: sec.dynsym.type = SINFO_T_DYNSYM; sec.dynsym.vaddr = dyn->d_un.d_ptr; break; case DT_RELA: sec.rela.type = SINFO_T_RELA; sec.rela.vaddr = dyn->d_un.d_ptr; break; case DT_RELASZ: sec.rela.size = dyn->d_un.d_val; break; case DT_STRSZ: sec.dynstr.size = dyn->d_un.d_val; break; case DT_REL: sec.rel.type = SINFO_T_REL; sec.rel.vaddr = dyn->d_un.d_ptr; break; case DT_RELSZ: sec.rel.size = dyn->d_un.d_val; break; case DT_INIT_ARRAY: sec.initarr.type = SINFO_T_INITARR; sec.initarr.vaddr = dyn->d_un.d_ptr; break; case DT_INIT_ARRAYSZ: sec.initarr.size = dyn->d_un.d_val; break; case DT_FINI_ARRAY: sec.finiarr.type = SINFO_T_FINIARR; sec.finiarr.vaddr = dyn->d_un.d_ptr; break; case DT_FINI_ARRAYSZ: sec.finiarr.size = dyn->d_un.d_val; break; case DT_PREINIT_ARRAY: sec.preinitarr.type = SINFO_T_PREINITARR; sec.preinitarr.vaddr = dyn->d_un.d_ptr; break; case DT_PREINIT_ARRAYSZ: sec.preinitarr.size = dyn->d_un.d_val; break; case DT_SUNW_CAPINFO: sec.capinfo.type = SINFO_T_CAPINFO; sec.capinfo.vaddr = dyn->d_un.d_ptr; break; case DT_SUNW_CAPCHAIN: sec.capchain.type = SINFO_T_CAPCHAIN; sec.capchain.vaddr = dyn->d_un.d_ptr; break; case DT_SUNW_SYMTAB: sec.ldynsym.type = SINFO_T_LDYNSYM; sec.ldynsym.vaddr = dyn->d_un.d_ptr; break; case DT_SUNW_SYMSZ: sec.ldynsym.size = dyn->d_un.d_val; break; case DT_SUNW_SYMSORT: sec.symsort.type = SINFO_T_SYMSORT; sec.symsort.vaddr = dyn->d_un.d_ptr; break; case DT_SUNW_SYMSORTSZ: sec.symsort.size = dyn->d_un.d_val; break; case DT_SUNW_TLSSORT: sec.tlssort.type = SINFO_T_TLSSORT; sec.tlssort.vaddr = dyn->d_un.d_ptr; break; case DT_SUNW_TLSSORTSZ: sec.tlssort.size = dyn->d_un.d_val; break; case DT_MOVETAB: sec.move.type = SINFO_T_MOVE; sec.move.vaddr = dyn->d_un.d_ptr; break; case DT_MOVESZ: sec.move.size = dyn->d_un.d_val; break; case DT_SYMINFO: sec.syminfo.type = SINFO_T_SYMINFO; sec.syminfo.vaddr = dyn->d_un.d_ptr; break; case DT_SYMINSZ: sec.syminfo.size = dyn->d_un.d_val; break; case DT_VERSYM: sec.versym.type = SINFO_T_VERSYM; sec.versym.vaddr = dyn->d_un.d_ptr; break; case DT_VERDEF: sec.verdef.type = SINFO_T_VERDEF; sec.verdef.vaddr = dyn->d_un.d_ptr; break; case DT_VERDEFNUM: sec.verdef.vercnt = dyn->d_un.d_val; sec.verdef.size = sizeof (Verdef) * dyn->d_un.d_val; break; case DT_VERNEED: sec.verneed.type = SINFO_T_VERNEED; sec.verneed.vaddr = dyn->d_un.d_ptr; break; case DT_VERNEEDNUM: sec.verneed.vercnt = dyn->d_un.d_val; sec.verneed.size = sizeof (Verneed) * dyn->d_un.d_val; break; } } } /* * Different sections depend on each other, and are meaningless * without them. For instance, even if a .dynsym exists, * no use can be made of it without a dynstr. These relationships * fan out: Disqualifying the .dynsym will disqualify the hash * section, and so forth. * * Disqualify sections that don't have the necessary prerequisites. */ /* Things that need the dynamic string table */ if (sec.dynstr.size == 0) sec.dynstr.type = SINFO_T_NULL; if (sec.dynstr.type != SINFO_T_DYNSTR) { sinfo_free(&sec.dyn, 1); /* Data already fetched */ sec.dynsym.type = SINFO_T_NULL; sec.dynsym.type = SINFO_T_NULL; sec.verdef.type = SINFO_T_NULL; sec.verneed.type = SINFO_T_NULL; } /* * The length of the hash section is encoded in its first two * elements (nbucket, and nchain). The length of the dynsym, * ldynsym, and versym are not given in the dynamic section, * but are known to be the same as nchain. * * If we don't have a hash table, or cannot read nbuckets and * nchain, we have to invalidate all of these. */ if (sec.hash.type == SINFO_T_HASH) { Word nbucket; Word nchain; size_t total; if (hash_size(&fstate, &sec.hash, &nbucket, &nchain, &total) == 0) { sec.hash.type = SINFO_T_NULL; } else { /* Use these counts to set sizes for related sections */ sec.hash.size = total * sizeof (Word); sec.dynsym.size = nchain * sizeof (Sym); sec.versym.size = nchain * sizeof (Versym); /* * The ldynsym size received the DT_SUNW_SYMSZ * value, which is the combined size of .dynsym * and .ldynsym. Now that we have the dynsym size, * use it to lower the ldynsym size to its real size. */ if (sec.ldynsym.size > sec.dynsym.size) sec.ldynsym.size -= sec.dynsym.size; } } /* * If the hash table is not present, or if the call to * hash_size() failed, then discard the sections that * need it to determine their length. */ if (sec.hash.type != SINFO_T_HASH) { sec.dynsym.type = SINFO_T_NULL; sec.ldynsym.type = SINFO_T_NULL; sec.versym.type = SINFO_T_NULL; } /* * The runtime linker does not receive size information for * Verdef and Verneed sections. We have to read their data * in pieces and calculate it. */ if ((sec.verdef.type == SINFO_T_VERDEF) && (verdefneed_size(&fstate, &sec.verdef) == 0)) sec.verdef.type = SINFO_T_NULL; if ((sec.verneed.type == SINFO_T_VERNEED) && (verdefneed_size(&fstate, &sec.verneed) == 0)) sec.verneed.type = SINFO_T_NULL; /* Discard any section with a zero length */ ndx = sinfo_n; for (sinfo = secarr; ndx-- > 0; sinfo++) if ((sinfo->type != SINFO_T_NULL) && (sinfo->size == 0)) sinfo->type = SINFO_T_NULL; /* Things that need the dynamic symbol table */ if (sec.dynsym.type != SINFO_T_DYNSYM) { sec.ldynsym.type = SINFO_T_NULL; sec.hash.type = SINFO_T_NULL; sec.syminfo.type = SINFO_T_NULL; sec.versym.type = SINFO_T_NULL; sec.move.type = SINFO_T_NULL; sec.rel.type = SINFO_T_NULL; sec.rela.type = SINFO_T_NULL; } /* Things that need the dynamic local symbol table */ if (sec.ldynsym.type != SINFO_T_DYNSYM) { sec.symsort.type = SINFO_T_NULL; sec.tlssort.type = SINFO_T_NULL; } /* * Look through the results and fetch the data for any sections * we have found. At the same time, count the number. */ num_sinfo = num_list_sinfo = 0; ndx = sinfo_n; for (sinfo = secarr; ndx-- > 0; sinfo++) { if ((sinfo->type != SINFO_T_NULL) && (sinfo->data == NULL)) (void) get_data(&fstate, sinfo); if (sinfo->data != NULL) num_sinfo++; } for (sinfo_list = seclist.next; sinfo_list != &seclist; sinfo_list = sinfo_list->next) { sinfo = &sinfo_list->sinfo; if ((sinfo->type != SINFO_T_NULL) && (sinfo->data == NULL)) (void) get_data(&fstate, sinfo); if (sinfo->data != NULL) num_list_sinfo++; } /* * Allocate the cache array and fill it in. The cache array * ends up taking all the dynamic memory we've allocated * to build up sec and seclist, so on success, we have nothing * left to clean up. If we can't allocate the cache array * though, we have to free up everything else. */ *shnum = num_sinfo + num_list_sinfo + 1; /* Extra for 1st NULL sec. */ if ((*cache = _cache = malloc((*shnum) * sizeof (Cache))) == NULL) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), file, strerror(err)); sinfo_free(secarr, num_sinfo); sinfo_list_free_all(&seclist); return (0); } *_cache = cache_init; _cache++; ndx = 1; for (sinfo = secarr; num_sinfo > 0; sinfo++) { if (sinfo->data != NULL) { _cache->c_scn = NULL; _cache->c_shdr = sinfo->shdr; _cache->c_data = sinfo->data; _cache->c_name = (char *)sinfo_data[sinfo->type].name; _cache->c_ndx = ndx++; _cache++; num_sinfo--; } } for (sinfo_list = seclist.next; num_list_sinfo > 0; sinfo_list = sinfo_list->next) { sinfo = &sinfo_list->sinfo; if (sinfo->data != NULL) { _cache->c_scn = NULL; _cache->c_shdr = sinfo->shdr; _cache->c_data = sinfo->data; _cache->c_name = (char *)sinfo_data[sinfo->type].name; _cache->c_ndx = ndx++; _cache++; num_list_sinfo--; } } return (1); } /* * Release all the memory referenced by a cache array allocated * by fake_shdr_cache(). */ void fake_shdr_cache_free(Cache *cache, size_t shnum) { Cache *_cache; for (_cache = cache; shnum--; _cache++) { if (_cache->c_data != NULL) { if (_cache->c_data->d_buf != NULL) free(_cache->c_data->d_buf); free(_cache->c_data); } if (_cache->c_shdr) free(_cache->c_shdr); } free(cache); } /* * This file and its contents are supplied under the terms of the * Common Development and Distribution License ("CDDL"), version 1.0. * You may only use this file in accordance with the terms of version * 1.0 of the CDDL. * * A full copy of the text of the CDDL should have accompanied this * source. A copy of the CDDL is also available via the Internet at * http://www.illumos.org/license/CDDL. */ /* * Copyright 2015 Nexenta Systems, Inc. All rights reserved. * Copyright 2018 Joyent, Inc. * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. */ /* * A little program who's only purpose is to get all the * CTF type information we want into an object. */ #include #include #include #include #define _STRUCTURED_PROC 1 #include #include #include #include #include /* prgregset_t is a define on intel */ #ifdef prgregset_t typedef prgregset_t #undef prgregset_t prgregset_t; #endif /* instantiate the types for CTF */ auxv_t auxv; prgregset_t prgregset; lwpstatus_t lwpstatus; pstatus_t pstatus; prstatus_t prstatus; psinfo_t psinfo; prpsinfo_t prpsinfo; lwpsinfo_t lwpsinfo; prcred_t prcred; prpriv_t prpriv; priv_impl_info_t priv_impl; fltset_t fltset; siginfo_t siginfo; sigset_t sigset; struct sigaction sigact; stack_t stack; sysset_t sysset; timestruc_t ts; struct utsname uts; prfdinfo_core_t ptfd; prsecflags_t psf; prlwpname_t psn; prupanic_t pru; prcwd_t cwd; /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * * Copyright 2015 Nexenta Systems, Inc. All rights reserved. * Copyright 2018 Joyent, Inc. * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. */ /* * This program is used to generate the contents of the * struct_layout_XXX.c files that contain per-architecture * structure layout information. * * Although not part of elfdump, it is built by the makefile * along with it. Note, the Makefile only builds versions that * are natively supported and therefore you must manually run * this for other architectures. * * To use it: * * 1) Run it, capturing the output in a file. * 2) If this is a replacement for an existing file, * diff the new and old copies to ensure only * the changes you expected are present. * 3) Put the new file in the common directory under the name * struct_layout_XXX.c, where XXX is the name of * the architecture (i386, amd64, sparc, sparcv9, etc). * 2) Add any necessary header and copyright comments. * 3) If this is a new architecture: * - Add an extern statement for struct_layout_XXX() * to struct_layout.h * - Add a case for it to the function sl_struct_layout() * in struct_layout.c. */ #include #include #include #include #include #include #include /* * This extracts CTF information from a temporary object file. * * START and END bracket a struct layout definition. They issue * the typedef boilerplate, and the standard first element (sizeof) * which captures the overall size of the structure. * * SCALAR_FIELD is for scalar struct fields * * ARRAY_FIELD is for array struct fields * * ARRAY_TYPE is for plain (non-struct) array types */ #define START(_name, _type) \ do_start(#_name, #_type) #define END (void) \ do_end() #define SCALAR_FIELD(_type, _field, _sign) \ do_scalar_field(#_type, #_field, _sign, NULL) #define SCALAR_FIELD4(_type, _field, _sign, _rtype) \ do_scalar_field(#_type, #_field, _sign, _rtype) #define ARRAY_FIELD(_type, _field, _sign) \ do_array_field(#_type, #_field, _sign, NULL) #define ARRAY_TYPE(_type, _sign) \ do_array_type(#_type, "elt0", _sign) static void do_start(char *_name, char *_type); static void do_end(void); static void do_start_name(char *name); static void do_start_sizeof(char *_type, char *realtype); static void do_scalar_field(char *_type, char *_field, int _sign, char *dotfield); static void do_array_field(char *_type, char *_field, int _sign, char *dotfield); static void do_array_type(char *_type, char *_field, int _sign); static void get_ctf_file(char *fname); static int get_field_info(char *tname, char *fname, char *dotname, int *offp, int *sizep); static ctf_file_t *ctf; static char *objfile; static char *machname; /* auxv_t, */ static void gen_auxv(void) { START(auxv, auxv_t); SCALAR_FIELD(auxv_t, a_type, 1); SCALAR_FIELD(auxv_t, a_un.a_val, 1); SCALAR_FIELD(auxv_t, a_un.a_ptr, 0); SCALAR_FIELD(auxv_t, a_un.a_fcn, 0); END; } /* prgregset_t, */ static void gen_prgregset(void) { START(prgregset, prgregset_t); ARRAY_TYPE(prgregset_t, 0); END; } /* lwpstatus_t, */ static void gen_lwpstatus(void) { START(lwpstatus, lwpstatus_t); SCALAR_FIELD(lwpstatus_t, pr_flags, 0); SCALAR_FIELD(lwpstatus_t, pr_lwpid, 0); SCALAR_FIELD(lwpstatus_t, pr_why, 0); SCALAR_FIELD(lwpstatus_t, pr_what, 0); SCALAR_FIELD(lwpstatus_t, pr_cursig, 0); SCALAR_FIELD(lwpstatus_t, pr_info, 0); SCALAR_FIELD(lwpstatus_t, pr_lwppend, 0); SCALAR_FIELD(lwpstatus_t, pr_lwphold, 0); SCALAR_FIELD(lwpstatus_t, pr_action, 0); SCALAR_FIELD(lwpstatus_t, pr_altstack, 0); SCALAR_FIELD(lwpstatus_t, pr_oldcontext, 0); SCALAR_FIELD(lwpstatus_t, pr_syscall, 0); SCALAR_FIELD(lwpstatus_t, pr_nsysarg, 0); SCALAR_FIELD(lwpstatus_t, pr_errno, 0); ARRAY_FIELD(lwpstatus_t, pr_sysarg, 0); SCALAR_FIELD(lwpstatus_t, pr_rval1, 0); SCALAR_FIELD(lwpstatus_t, pr_rval2, 0); ARRAY_FIELD(lwpstatus_t, pr_clname, 0); SCALAR_FIELD(lwpstatus_t, pr_tstamp, 0); SCALAR_FIELD(lwpstatus_t, pr_utime, 0); SCALAR_FIELD(lwpstatus_t, pr_stime, 0); SCALAR_FIELD(lwpstatus_t, pr_errpriv, 0); SCALAR_FIELD(lwpstatus_t, pr_ustack, 0); SCALAR_FIELD(lwpstatus_t, pr_instr, 0); SCALAR_FIELD(lwpstatus_t, pr_reg, 0); SCALAR_FIELD(lwpstatus_t, pr_fpreg, 0); END; } /* pstatus_t, */ static void gen_pstatus(void) { START(pstatus, pstatus_t); SCALAR_FIELD(pstatus_t, pr_flags, 1); SCALAR_FIELD(pstatus_t, pr_nlwp, 1); SCALAR_FIELD(pstatus_t, pr_pid, 0); SCALAR_FIELD(pstatus_t, pr_ppid, 0); SCALAR_FIELD(pstatus_t, pr_pgid, 0); SCALAR_FIELD(pstatus_t, pr_sid, 0); SCALAR_FIELD(pstatus_t, pr_aslwpid, 1); SCALAR_FIELD(pstatus_t, pr_agentid, 1); SCALAR_FIELD(pstatus_t, pr_sigpend, 0); SCALAR_FIELD(pstatus_t, pr_brkbase, 0); SCALAR_FIELD(pstatus_t, pr_brksize, 0); SCALAR_FIELD(pstatus_t, pr_stkbase, 0); SCALAR_FIELD(pstatus_t, pr_stksize, 0); SCALAR_FIELD(pstatus_t, pr_utime, 0); SCALAR_FIELD(pstatus_t, pr_stime, 0); SCALAR_FIELD(pstatus_t, pr_cutime, 0); SCALAR_FIELD(pstatus_t, pr_cstime, 0); SCALAR_FIELD(pstatus_t, pr_sigtrace, 0); SCALAR_FIELD(pstatus_t, pr_flttrace, 0); SCALAR_FIELD(pstatus_t, pr_sysentry, 0); SCALAR_FIELD(pstatus_t, pr_sysexit, 0); SCALAR_FIELD(pstatus_t, pr_dmodel, 0); SCALAR_FIELD(pstatus_t, pr_taskid, 1); SCALAR_FIELD(pstatus_t, pr_projid, 1); SCALAR_FIELD(pstatus_t, pr_nzomb, 1); SCALAR_FIELD(pstatus_t, pr_zoneid, 1); SCALAR_FIELD(pstatus_t, pr_lwp, 0); END; } /* prstatus_t, */ static void gen_prstatus(void) { START(prstatus, prstatus_t); SCALAR_FIELD(prstatus_t, pr_flags, 1); SCALAR_FIELD(prstatus_t, pr_why, 1); SCALAR_FIELD(prstatus_t, pr_what, 1); SCALAR_FIELD(prstatus_t, pr_info, 0); SCALAR_FIELD(prstatus_t, pr_cursig, 1); SCALAR_FIELD(prstatus_t, pr_nlwp, 0); SCALAR_FIELD(prstatus_t, pr_sigpend, 0); SCALAR_FIELD(prstatus_t, pr_sighold, 0); SCALAR_FIELD(prstatus_t, pr_altstack, 0); SCALAR_FIELD(prstatus_t, pr_action, 0); SCALAR_FIELD(prstatus_t, pr_pid, 0); SCALAR_FIELD(prstatus_t, pr_ppid, 0); SCALAR_FIELD(prstatus_t, pr_pgrp, 0); SCALAR_FIELD(prstatus_t, pr_sid, 0); SCALAR_FIELD(prstatus_t, pr_utime, 0); SCALAR_FIELD(prstatus_t, pr_stime, 0); SCALAR_FIELD(prstatus_t, pr_cutime, 0); SCALAR_FIELD(prstatus_t, pr_cstime, 0); ARRAY_FIELD(prstatus_t, pr_clname, 0); SCALAR_FIELD(prstatus_t, pr_syscall, 1); SCALAR_FIELD(prstatus_t, pr_nsysarg, 1); ARRAY_FIELD(prstatus_t, pr_sysarg, 1); SCALAR_FIELD(prstatus_t, pr_who, 0); SCALAR_FIELD(prstatus_t, pr_lwppend, 0); SCALAR_FIELD(prstatus_t, pr_oldcontext, 0); SCALAR_FIELD(prstatus_t, pr_brkbase, 0); SCALAR_FIELD(prstatus_t, pr_brksize, 0); SCALAR_FIELD(prstatus_t, pr_stkbase, 0); SCALAR_FIELD(prstatus_t, pr_stksize, 0); SCALAR_FIELD(prstatus_t, pr_processor, 1); SCALAR_FIELD(prstatus_t, pr_bind, 1); SCALAR_FIELD(prstatus_t, pr_instr, 1); SCALAR_FIELD(prstatus_t, pr_reg, 0); END; } /* psinfo_t, */ static void gen_psinfo(void) { START(psinfo, psinfo_t); SCALAR_FIELD(psinfo_t, pr_flag, 1); SCALAR_FIELD(psinfo_t, pr_nlwp, 1); SCALAR_FIELD(psinfo_t, pr_pid, 0); SCALAR_FIELD(psinfo_t, pr_ppid, 0); SCALAR_FIELD(psinfo_t, pr_pgid, 0); SCALAR_FIELD(psinfo_t, pr_sid, 0); SCALAR_FIELD(psinfo_t, pr_uid, 0); SCALAR_FIELD(psinfo_t, pr_euid, 0); SCALAR_FIELD(psinfo_t, pr_gid, 0); SCALAR_FIELD(psinfo_t, pr_egid, 0); SCALAR_FIELD(psinfo_t, pr_addr, 0); SCALAR_FIELD(psinfo_t, pr_size, 0); SCALAR_FIELD(psinfo_t, pr_rssize, 0); SCALAR_FIELD(psinfo_t, pr_ttydev, 0); SCALAR_FIELD(psinfo_t, pr_pctcpu, 0); SCALAR_FIELD(psinfo_t, pr_pctmem, 0); SCALAR_FIELD(psinfo_t, pr_start, 0); SCALAR_FIELD(psinfo_t, pr_time, 0); SCALAR_FIELD(psinfo_t, pr_ctime, 0); ARRAY_FIELD(psinfo_t, pr_fname, 0); ARRAY_FIELD(psinfo_t, pr_psargs, 0); SCALAR_FIELD(psinfo_t, pr_wstat, 1); SCALAR_FIELD(psinfo_t, pr_argc, 1); SCALAR_FIELD(psinfo_t, pr_argv, 0); SCALAR_FIELD(psinfo_t, pr_envp, 0); SCALAR_FIELD(psinfo_t, pr_dmodel, 0); SCALAR_FIELD(psinfo_t, pr_taskid, 0); SCALAR_FIELD(psinfo_t, pr_projid, 0); SCALAR_FIELD(psinfo_t, pr_nzomb, 1); SCALAR_FIELD(psinfo_t, pr_poolid, 0); SCALAR_FIELD(psinfo_t, pr_zoneid, 0); SCALAR_FIELD(psinfo_t, pr_contract, 0); SCALAR_FIELD(psinfo_t, pr_lwp, 0); END; } /* prpsinfo_t, */ static void gen_prpsinfo(void) { START(prpsinfo, prpsinfo_t); SCALAR_FIELD(prpsinfo_t, pr_state, 0); SCALAR_FIELD(prpsinfo_t, pr_sname, 0); SCALAR_FIELD(prpsinfo_t, pr_zomb, 0); SCALAR_FIELD(prpsinfo_t, pr_nice, 0); SCALAR_FIELD(prpsinfo_t, pr_flag, 0); SCALAR_FIELD(prpsinfo_t, pr_uid, 0); SCALAR_FIELD(prpsinfo_t, pr_gid, 0); SCALAR_FIELD(prpsinfo_t, pr_pid, 0); SCALAR_FIELD(prpsinfo_t, pr_ppid, 0); SCALAR_FIELD(prpsinfo_t, pr_pgrp, 0); SCALAR_FIELD(prpsinfo_t, pr_sid, 0); SCALAR_FIELD(prpsinfo_t, pr_addr, 0); SCALAR_FIELD(prpsinfo_t, pr_size, 0); SCALAR_FIELD(prpsinfo_t, pr_rssize, 0); SCALAR_FIELD(prpsinfo_t, pr_wchan, 0); SCALAR_FIELD(prpsinfo_t, pr_start, 0); SCALAR_FIELD(prpsinfo_t, pr_time, 0); SCALAR_FIELD(prpsinfo_t, pr_pri, 1); SCALAR_FIELD(prpsinfo_t, pr_oldpri, 0); SCALAR_FIELD(prpsinfo_t, pr_cpu, 0); SCALAR_FIELD(prpsinfo_t, pr_ottydev, 0); SCALAR_FIELD(prpsinfo_t, pr_lttydev, 0); ARRAY_FIELD(prpsinfo_t, pr_clname, 0); ARRAY_FIELD(prpsinfo_t, pr_fname, 0); ARRAY_FIELD(prpsinfo_t, pr_psargs, 0); SCALAR_FIELD(prpsinfo_t, pr_syscall, 1); SCALAR_FIELD(prpsinfo_t, pr_ctime, 0); SCALAR_FIELD(prpsinfo_t, pr_bysize, 0); SCALAR_FIELD(prpsinfo_t, pr_byrssize, 0); SCALAR_FIELD(prpsinfo_t, pr_argc, 1); SCALAR_FIELD(prpsinfo_t, pr_argv, 0); SCALAR_FIELD(prpsinfo_t, pr_envp, 0); SCALAR_FIELD(prpsinfo_t, pr_wstat, 1); SCALAR_FIELD(prpsinfo_t, pr_pctcpu, 0); SCALAR_FIELD(prpsinfo_t, pr_pctmem, 0); SCALAR_FIELD(prpsinfo_t, pr_euid, 0); SCALAR_FIELD(prpsinfo_t, pr_egid, 0); SCALAR_FIELD(prpsinfo_t, pr_aslwpid, 0); SCALAR_FIELD(prpsinfo_t, pr_dmodel, 0); END; } /* lwpsinfo_t, */ static void gen_lwpsinfo(void) { START(lwpsinfo, lwpsinfo_t); SCALAR_FIELD(lwpsinfo_t, pr_flag, 1); SCALAR_FIELD(lwpsinfo_t, pr_lwpid, 0); SCALAR_FIELD(lwpsinfo_t, pr_addr, 0); SCALAR_FIELD(lwpsinfo_t, pr_wchan, 0); SCALAR_FIELD(lwpsinfo_t, pr_stype, 0); SCALAR_FIELD(lwpsinfo_t, pr_state, 0); SCALAR_FIELD(lwpsinfo_t, pr_sname, 0); SCALAR_FIELD(lwpsinfo_t, pr_nice, 0); SCALAR_FIELD(lwpsinfo_t, pr_syscall, 0); SCALAR_FIELD(lwpsinfo_t, pr_oldpri, 0); SCALAR_FIELD(lwpsinfo_t, pr_cpu, 0); SCALAR_FIELD(lwpsinfo_t, pr_pri, 1); SCALAR_FIELD(lwpsinfo_t, pr_pctcpu, 0); SCALAR_FIELD(lwpsinfo_t, pr_start, 0); SCALAR_FIELD(lwpsinfo_t, pr_time, 0); ARRAY_FIELD(lwpsinfo_t, pr_clname, 0); ARRAY_FIELD(lwpsinfo_t, pr_name, 0); SCALAR_FIELD(lwpsinfo_t, pr_onpro, 1); SCALAR_FIELD(lwpsinfo_t, pr_bindpro, 1); SCALAR_FIELD(lwpsinfo_t, pr_bindpset, 1); SCALAR_FIELD(lwpsinfo_t, pr_lgrp, 1); END; } /* prcred_t, */ static void gen_prcred(void) { START(prcred, prcred_t); SCALAR_FIELD(prcred_t, pr_euid, 0); SCALAR_FIELD(prcred_t, pr_ruid, 0); SCALAR_FIELD(prcred_t, pr_suid, 0); SCALAR_FIELD(prcred_t, pr_egid, 0); SCALAR_FIELD(prcred_t, pr_rgid, 0); SCALAR_FIELD(prcred_t, pr_sgid, 0); SCALAR_FIELD(prcred_t, pr_ngroups, 1); ARRAY_FIELD(prcred_t, pr_groups, 0); END; } /* prpriv_t, */ static void gen_prpriv(void) { START(prpriv, prpriv_t); SCALAR_FIELD(prpriv_t, pr_nsets, 0); SCALAR_FIELD(prpriv_t, pr_setsize, 0); SCALAR_FIELD(prpriv_t, pr_infosize, 0); ARRAY_FIELD(prpriv_t, pr_sets, 0); END; } /* priv_impl_info_t, */ static void gen_priv_impl_info(void) { START(priv_impl_info, priv_impl_info_t); SCALAR_FIELD(priv_impl_info_t, priv_headersize, 0); SCALAR_FIELD(priv_impl_info_t, priv_flags, 0); SCALAR_FIELD(priv_impl_info_t, priv_nsets, 0); SCALAR_FIELD(priv_impl_info_t, priv_setsize, 0); SCALAR_FIELD(priv_impl_info_t, priv_max, 0); SCALAR_FIELD(priv_impl_info_t, priv_infosize, 0); SCALAR_FIELD(priv_impl_info_t, priv_globalinfosize, 0); END; } /* fltset_t, */ static void gen_fltset(void) { START(fltset, fltset_t); ARRAY_FIELD(fltset_t, word, 0); END; } /* * Layout description of siginfo_t, * * Note: many siginfo_t members are #defines mapping to * long dotted members of sub-structs or unions, and * we need the full member spec (with dots) for those. */ static void gen_siginfo(void) { START(siginfo, siginfo_t); SCALAR_FIELD(siginfo_t, si_signo, 0); SCALAR_FIELD(siginfo_t, si_errno, 0); SCALAR_FIELD(siginfo_t, si_code, 1); SCALAR_FIELD4(siginfo_t, si_value.sival_int, 0, "__data.__proc.__pdata.__kill.__value.sival_int"); SCALAR_FIELD4(siginfo_t, si_value.sival_ptr, 0, "__data.__proc.__pdata.__kill.__value.sival_ptr"); SCALAR_FIELD4(siginfo_t, si_pid, 0, "__data.__proc.__pid"); SCALAR_FIELD4(siginfo_t, si_uid, 0, "__data.__proc.__pdata.__kill.__uid"); SCALAR_FIELD4(siginfo_t, si_ctid, 0, "__data.__proc.__ctid"); SCALAR_FIELD4(siginfo_t, si_zoneid, 0, "__data.__proc.__zoneid"); SCALAR_FIELD4(siginfo_t, si_entity, 0, "__data.__rctl.__entity"); SCALAR_FIELD4(siginfo_t, si_addr, 0, "__data.__fault.__addr"); SCALAR_FIELD4(siginfo_t, si_status, 0, "__data.__proc.__pdata.__cld.__status"); SCALAR_FIELD4(siginfo_t, si_band, 0, "__data.__file.__band"); END; } /* sigset_t, */ static void gen_sigset(void) { START(sigset, sigset_t); ARRAY_FIELD(sigset_t, __sigbits, 0); END; } /* struct sigaction, */ static void gen_sigaction(void) { START(sigaction, struct sigaction); SCALAR_FIELD(struct sigaction, sa_flags, 0); SCALAR_FIELD4(struct sigaction, sa_handler, 0, "_funcptr._handler"); SCALAR_FIELD4(struct sigaction, sa_sigaction, 0, "_funcptr._sigaction"); SCALAR_FIELD(struct sigaction, sa_mask, 0); END; } /* stack_t, */ static void gen_stack(void) { START(stack, stack_t); SCALAR_FIELD(stack_t, ss_sp, 0); SCALAR_FIELD(stack_t, ss_size, 0); SCALAR_FIELD(stack_t, ss_flags, 0); END; } /* sysset_t, */ static void gen_sysset(void) { START(sysset, sysset_t); ARRAY_FIELD(sysset_t, word, 0); END; } /* timestruc_t, */ static void gen_timestruc(void) { START(timestruc, timestruc_t); SCALAR_FIELD(timestruc_t, tv_sec, 0); SCALAR_FIELD(timestruc_t, tv_nsec, 0); END; } /* struct utsname, */ static void gen_utsname(void) { START(utsname, struct utsname); ARRAY_FIELD(struct utsname, sysname, 0); ARRAY_FIELD(struct utsname, nodename, 0); ARRAY_FIELD(struct utsname, release, 0); ARRAY_FIELD(struct utsname, version, 0); ARRAY_FIELD(struct utsname, machine, 0); END; } static void gen_prfdinfo(void) { START(prfdinfo, prfdinfo_core_t); SCALAR_FIELD(prfdinfo_core_t, pr_fd, 0); SCALAR_FIELD(prfdinfo_core_t, pr_mode, 0); SCALAR_FIELD(prfdinfo_core_t, pr_uid, 0); SCALAR_FIELD(prfdinfo_core_t, pr_gid, 0); SCALAR_FIELD(prfdinfo_core_t, pr_major, 0); SCALAR_FIELD(prfdinfo_core_t, pr_minor, 0); SCALAR_FIELD(prfdinfo_core_t, pr_rmajor, 0); SCALAR_FIELD(prfdinfo_core_t, pr_rminor, 0); SCALAR_FIELD(prfdinfo_core_t, pr_ino, 0); SCALAR_FIELD(prfdinfo_core_t, pr_offset, 0); SCALAR_FIELD(prfdinfo_core_t, pr_size, 0); SCALAR_FIELD(prfdinfo_core_t, pr_fileflags, 0); SCALAR_FIELD(prfdinfo_core_t, pr_fdflags, 0); ARRAY_FIELD(prfdinfo_core_t, pr_path, 0); END; } static void gen_prsecflags(void) { START(prsecflags, prsecflags_t); SCALAR_FIELD(prsecflags_t, pr_version, 0); SCALAR_FIELD(prsecflags_t, pr_effective, 0); SCALAR_FIELD(prsecflags_t, pr_inherit, 0); SCALAR_FIELD(prsecflags_t, pr_lower, 0); SCALAR_FIELD(prsecflags_t, pr_upper, 0); END; } static void gen_prlwpname(void) { START(prlwpname, prlwpname_t); SCALAR_FIELD(prlwpname_t, pr_lwpid, 0); ARRAY_FIELD(prlwpname_t, pr_lwpname, 0); END; } static void gen_prupanic(void) { START(prupanic, prupanic_t); SCALAR_FIELD(prupanic_t, pru_version, 0); SCALAR_FIELD(prupanic_t, pru_flags, 0); ARRAY_FIELD(prupanic_t, pru_data, 0); END; } static void gen_prcwd(void) { START(prcwd, prcwd_t); SCALAR_FIELD(prcwd_t, prcwd_fsid, 0); ARRAY_FIELD(prcwd_t, prcwd_fsname, 0); ARRAY_FIELD(prcwd_t, prcwd_mntpt, 0); ARRAY_FIELD(prcwd_t, prcwd_mntspec, 0); ARRAY_FIELD(prcwd_t, prcwd_cwd, 0); END; } /*ARGSUSED*/ int main(int argc, char *argv[]) { const char *fmt = "\t&%s_layout,\n"; /* get obj file for input */ if (argc < 3) { (void) fprintf(stderr, "usage: %s {object_file} {MACH}\n", argv[0]); exit(1); } objfile = argv[1]; machname = argv[2]; get_ctf_file(objfile); (void) printf("#include \n"); gen_auxv(); gen_prgregset(); gen_lwpstatus(); gen_pstatus(); gen_prstatus(); gen_psinfo(); gen_prpsinfo(); gen_lwpsinfo(); gen_prcred(); gen_prpriv(); gen_priv_impl_info(); gen_fltset(); gen_siginfo(); gen_sigset(); gen_sigaction(); gen_stack(); gen_sysset(); gen_timestruc(); gen_utsname(); gen_prfdinfo(); gen_prsecflags(); gen_prlwpname(); gen_prupanic(); gen_prcwd(); /* * Generate the full arch_layout description */ (void) printf( "\n\n\n\nstatic const sl_arch_layout_t layout_%s = {\n", machname); (void) printf(fmt, "auxv"); (void) printf(fmt, "fltset"); (void) printf(fmt, "lwpsinfo"); (void) printf(fmt, "lwpstatus"); (void) printf(fmt, "prcred"); (void) printf(fmt, "priv_impl_info"); (void) printf(fmt, "prpriv"); (void) printf(fmt, "psinfo"); (void) printf(fmt, "pstatus"); (void) printf(fmt, "prgregset"); (void) printf(fmt, "prpsinfo"); (void) printf(fmt, "prstatus"); (void) printf(fmt, "sigaction"); (void) printf(fmt, "siginfo"); (void) printf(fmt, "sigset"); (void) printf(fmt, "stack"); (void) printf(fmt, "sysset"); (void) printf(fmt, "timestruc"); (void) printf(fmt, "utsname"); (void) printf(fmt, "prfdinfo"); (void) printf(fmt, "prsecflags"); (void) printf(fmt, "prlwpname"); (void) printf(fmt, "prupanic"); (void) printf(fmt, "prcwd"); (void) printf("};\n"); /* * A public function, to make the information available */ (void) printf("\n\nconst sl_arch_layout_t *\n"); (void) printf("struct_layout_%s(void)\n", machname); (void) printf("{\n\treturn (&layout_%s);\n}\n", machname); return (0); } /* * Helper functions using the CTF library to get type info. */ static void get_ctf_file(char *fname) { int ctferr; objfile = fname; if ((ctf = ctf_open(objfile, &ctferr)) == NULL) { errx(1, "Couldn't open object file %s: %s\n", objfile, ctf_errmsg(ctferr)); } } static void print_row(int boff, int eltlen, int nelts, int issigned, char *comment) { (void) printf("\t{ %d,\t%d,\t%d,\t%d },\t\t/* %s */\n", boff, eltlen, nelts, issigned, comment); } static void do_start(char *sname, char *tname) { do_start_name(sname); do_start_sizeof(tname, NULL); } static void do_start_name(char *sname) { (void) printf("\n\nstatic const sl_%s_layout_t %s_layout = {\n", sname, sname); } static void do_end(void) { (void) printf("};\n"); } static void do_start_sizeof(char *tname, char *rtname) { char comment[100]; ctf_id_t stype; int sz; if (rtname == NULL) rtname = tname; if ((stype = ctf_lookup_by_name(ctf, rtname)) == CTF_ERR) errx(1, "Couldn't find type %s", rtname); if ((stype = ctf_type_resolve(ctf, stype)) == CTF_ERR) errx(1, "Couldn't resolve type %s", tname); if ((sz = (int)ctf_type_size(ctf, stype)) < 0) { errx(1, "Couldn't get size for type %s", tname); } else if (sz == 0) { errx(1, "Invalid type size 0 for %s", tname); } (void) snprintf(comment, sizeof (comment), "sizeof (%s)", tname); print_row(0, sz, 0, 0, comment); } static void do_scalar_field(char *tname, char *fname, int _sign, char *dotfield) { int rc, off, sz, ftype; rc = get_field_info(tname, fname, dotfield, &off, &ftype); if (rc < 0) errx(1, "Can't get field info for %s->%s", tname, fname); if ((ftype = ctf_type_resolve(ctf, ftype)) == CTF_ERR) errx(1, "Couldn't resolve type of %s->%s", tname, fname); if ((sz = (int)ctf_type_size(ctf, ftype)) < 0) { errx(1, "Couldn't get size for type ID %d", ftype); } else if (sz == 0) { errx(1, "Invalid type size 0 for type ID %d", ftype); } print_row(off, sz, 0, _sign, fname); } static void do_array_field(char *tname, char *fname, int _sign, char *dotfield) { char comment[100]; ctf_arinfo_t ai; int typekind; int esz, rc, off, ftype; rc = get_field_info(tname, fname, dotfield, &off, &ftype); if (rc < 0) errx(1, "Can't get field info for %s->%s", tname, fname); if ((ftype = ctf_type_resolve(ctf, ftype)) == CTF_ERR) errx(1, "Couldn't resolve type of %s->%s", tname, fname); typekind = ctf_type_kind(ctf, ftype); if (typekind != CTF_K_ARRAY) errx(1, "Wrong type for %s->%s", tname, fname); rc = ctf_array_info(ctf, ftype, &ai); if (rc != 0) errx(1, "Can't get array info for %s->%s\n", tname, fname); esz = ctf_type_size(ctf, ai.ctr_contents); if (esz < 0) errx(1, "Can't get element size for %s->%s\n", tname, fname); (void) snprintf(comment, sizeof (comment), "%s[]", fname); print_row(off, esz, ai.ctr_nelems, _sign, comment); } static void do_array_type(char *tname, char *fname, int _sign) { ctf_arinfo_t ai; int stype, typekind; int esz, rc; if ((stype = ctf_lookup_by_name(ctf, tname)) == CTF_ERR) errx(1, "Couldn't find type %s", tname); if ((stype = ctf_type_resolve(ctf, stype)) == CTF_ERR) errx(1, "Couldn't resolve type %s", tname); typekind = ctf_type_kind(ctf, stype); if (typekind != CTF_K_ARRAY) errx(1, "Wrong type for %s->%s", tname, fname); rc = ctf_array_info(ctf, stype, &ai); if (rc != 0) errx(1, "Can't get array info for %s->%s\n", tname, fname); esz = ctf_type_size(ctf, ai.ctr_contents); if (esz < 0) errx(1, "Can't get element size for %s->%s\n", tname, fname); print_row(0, esz, ai.ctr_nelems, _sign, fname); } struct gfinfo { char *tname; /* top type name, i.e. the struct */ char *fname; /* field name */ char *dotname; /* full field name with dots (optional) */ char *prefix; /* current field search prefix */ int base_off; int fld_off; int fld_type; }; static int gfi_iter(const char *fname, ctf_id_t mbrtid, ulong_t off, void *varg); /* * Lookup field "fname" in type "tname". If "dotname" is non-NULL, * that's the full field name with dots, i.e. a_un.un_foo, which * we must search for by walking the struct CTF recursively. */ static int get_field_info(char *tname, char *fname, char *dotname, int *offp, int *tidp) { struct gfinfo gfi; ctf_id_t stype; int typekind; int rc; if ((stype = ctf_lookup_by_name(ctf, tname)) == CTF_ERR) errx(1, "Couldn't find type %s", tname); if ((stype = ctf_type_resolve(ctf, stype)) == CTF_ERR) errx(1, "Couldn't resolve type %s", tname); /* If fname has a dot, use it as dotname too. */ if (dotname == NULL && strchr(fname, '.') != NULL) dotname = fname; gfi.tname = tname; gfi.fname = fname; gfi.dotname = dotname; gfi.prefix = ""; gfi.base_off = 0; gfi.fld_off = 0; gfi.fld_type = 0; typekind = ctf_type_kind(ctf, stype); switch (typekind) { case CTF_K_STRUCT: case CTF_K_UNION: rc = ctf_member_iter(ctf, stype, gfi_iter, &gfi); break; default: errx(1, "Unexpected top-level type for %s", tname); break; } if (rc < 0) errx(1, "Error getting info for %s.%s", tname, fname); if (rc == 0) errx(1, "Did not find %s.%s", tname, fname); *offp = gfi.fld_off; *tidp = gfi.fld_type; return (0); } /* * Iteration callback for ctf_member_iter * Return <0 on error, 0 to keep looking, >0 for found. * * If no dotname, simple search for fieldname. * If we're asked to search with dotname, we need to do a full * recursive walk of the types under the dotname. */ int gfi_iter(const char *fieldname, ctf_id_t mbrtid, ulong_t off, void *varg) { char namebuf[100]; struct gfinfo *gfi = varg; char *saveprefix; int saveoff; int typekind; int byteoff; int len, rc; byteoff = gfi->base_off + (int)(off >> 3); /* Easy cases first: no dotname */ if (gfi->dotname == NULL) { if (strcmp(gfi->fname, fieldname) == 0) { gfi->fld_off = byteoff; gfi->fld_type = mbrtid; return (1); } return (0); } /* Exact match on the dotname? */ (void) snprintf(namebuf, sizeof (namebuf), "%s%s", gfi->prefix, fieldname); if (strcmp(gfi->dotname, namebuf) == 0) { gfi->fld_off = byteoff; gfi->fld_type = mbrtid; return (1); } /* * May need to recurse under this field, but * only if there's a match through '.' */ (void) strlcat(namebuf, ".", sizeof (namebuf)); len = strlen(namebuf); if (strncmp(gfi->dotname, namebuf, len) != 0) return (0); typekind = ctf_type_kind(ctf, mbrtid); switch (typekind) { case CTF_K_STRUCT: case CTF_K_UNION: break; default: return (0); } /* Recursively walk members */ saveprefix = gfi->prefix; saveoff = gfi->base_off; gfi->prefix = namebuf; gfi->base_off = byteoff; rc = ctf_member_iter(ctf, mbrtid, gfi_iter, gfi); gfi->prefix = saveprefix; gfi->base_off = saveoff; return (rc); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright 2024 Oxide Computer Company */ /* * Dump an elf file. */ #include #include #include #include #include #include <_libelf.h> #include #include #include #include #include #include #include #include #include #include #include #include <_elfdump.h> #include #include #include const Cache cache_init = {NULL, NULL, NULL, NULL, 0}; /* * The -I, -N, and -T options are called "match options", because * they allow selecting the items to be displayed based on matching * their index, name, or type. * * The ELF information to which -I, -N, or -T are applied in * the current invocation is called the "match item". */ typedef enum { MATCH_ITEM_PT, /* Program header (PT_) */ MATCH_ITEM_SHT /* Section header (SHT_) */ } match_item_t; /* match_opt_t is used to note which match option was used */ typedef enum { MATCH_OPT_NAME, /* Record contains a name */ MATCH_OPT_NDX, /* Record contains a single index */ MATCH_OPT_RANGE, /* Record contains an index range */ MATCH_OPT_TYPE, /* Record contains a type (shdr or phdr) */ } match_opt_t; typedef struct _match { struct _match *next; /* Pointer to next item in list */ match_opt_t opt_type; union { const char *name; /* MATCH_OPT_NAME */ struct { /* MATCH_OPT_NDX and MATCH_OPT_RANGE */ int start; int end; /* Only for MATCH_OPT_RANGE */ } ndx; uint32_t type; /* MATCH_OPT_TYPE */ } value; } match_rec_t; static struct { match_item_t item_type; /* Type of item being matched */ match_rec_t *list; /* Records for (-I, -N, -T) options */ } match_state; const char * _elfdump_msg(Msg mid) { return (gettext(MSG_ORIG(mid))); } /* * Determine whether a symbol name should be demangled. */ const char * demangle(const char *name, uint_t flags) { if (flags & FLG_CTL_DEMANGLE) return (Elf_demangle_name(name)); else return ((char *)name); } /* * Define our own standard error routine. */ void failure(const char *file, const char *func) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_FAILURE), file, func, elf_errmsg(elf_errno())); } /* * The full usage message */ static void detail_usage() { (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL1)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL2)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL3)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL4)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL5)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL6)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL7)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL8)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL9)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL10)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL11)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL12)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL13)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL14)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL15)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL16)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL17)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL18)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL19)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL20)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL21)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL22)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL23)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL24)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL25)); (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL26)); } /* * Output a block of raw data as hex bytes. Each row is given * the index of the first byte in the row. * * entry: * data - Pointer to first byte of data to be displayed * n - # of bytes of data * bytes_per_col - # of space separated bytes to output in each column. * col_per_row - # of columns to output per row * * exit: * The formatted data has been sent to stdout. */ typedef struct { uint_t dd_indent; } dump_data_t; static int dump_hex_bytes_cb(void *arg, uint64_t addr, const char *str, size_t len __unused) { char index[MAXNDXSIZE]; dump_data_t *dd = arg; size_t index_width; (void) snprintf(index, sizeof (index), MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(addr)); index_width = strlen(index); index_width = S_ROUND(index_width, 8); dbg_print(0, MSG_ORIG(MSG_HEXDUMP_ROW), dd->dd_indent, MSG_ORIG(MSG_STR_EMPTY), index_width, index, str); return (0); } void dump_hex_bytes(const void *data, size_t n, int indent, int bytes_per_col, int col_per_row) { hexdump_t h; dump_data_t dd = { .dd_indent = indent }; hexdump_init(&h); hexdump_set_grouping(&h, bytes_per_col); hexdump_set_width(&h, bytes_per_col * col_per_row); (void) hexdumph(&h, data, n, HDF_DOUBLESPACE, dump_hex_bytes_cb, &dd); hexdump_fini(&h); } /* * Convert the ASCII representation of an index, or index range, into * binary form, and store it in rec: * * index: An positive or 0 valued integer * range: Two indexes, separated by a ':' character, denoting * a range of allowed values. If the second value is omitted, * any values equal to or greater than the first will match. * * exit: * On success, *rec is filled in with a MATCH_OPT_NDX or MATCH_OPT_RANGE * value, and this function returns (1). On failure, the contents * of *rec are undefined, and (0) is returned. */ int process_index_opt(const char *str, match_rec_t *rec) { #define SKIP_BLANK for (; *str && isspace(*str); str++) char *endptr; rec->value.ndx.start = strtol(str, &endptr, 10); /* Value must use some of the input, and be 0 or positive */ if ((str == endptr) || (rec->value.ndx.start < 0)) return (0); str = endptr; SKIP_BLANK; if (*str != ':') { rec->opt_type = MATCH_OPT_NDX; } else { str++; /* Skip the ':' */ rec->opt_type = MATCH_OPT_RANGE; SKIP_BLANK; if (*str == '\0') { rec->value.ndx.end = -1; /* Indicates "to end" */ } else { rec->value.ndx.end = strtol(str, &endptr, 10); if ((str == endptr) || (rec->value.ndx.end < 0)) return (0); str = endptr; SKIP_BLANK; } } /* Syntax error if anything is left over */ if (*str != '\0') return (0); return (1); #undef SKIP_BLANK } /* * Convert a string containing a specific type of ELF constant, or an ASCII * representation of a number, to an integer. Strings starting with '0' * are taken to be octal, those staring with '0x' are hex, and all * others are decimal. * * entry: * str - String to be converted * ctype - Constant type * v - Address of variable to receive resulting value. * * exit: * On success, returns True (1) and *v is set to the value. * On failure, returns False (0) and *v is undefined. */ typedef enum { ATOUI_PT, ATOUI_SHT, ATOUI_OSABI } atoui_type_t; static int atoui(const char *str, atoui_type_t type, uint32_t *v) { conv_strtol_uvalue_t uvalue; char *endptr; if (conv_iter_strtol_init(str, &uvalue) != 0) { switch (type) { case ATOUI_PT: if (conv_iter_phdr_type(CONV_OSABI_ALL, CONV_FMT_ALT_CF, conv_iter_strtol, &uvalue) == CONV_ITER_DONE) break; (void) conv_iter_phdr_type(CONV_OSABI_ALL, CONV_FMT_ALT_NF, conv_iter_strtol, &uvalue); break; case ATOUI_SHT: if (conv_iter_sec_type(CONV_OSABI_ALL, CONV_MACH_ALL, CONV_FMT_ALT_CF, conv_iter_strtol, &uvalue) == CONV_ITER_DONE) break; (void) conv_iter_sec_type(CONV_OSABI_ALL, CONV_MACH_ALL, CONV_FMT_ALT_NF, conv_iter_strtol, &uvalue); break; case ATOUI_OSABI: if (conv_iter_ehdr_osabi(CONV_FMT_ALT_CF, conv_iter_strtol, &uvalue) == CONV_ITER_DONE) break; (void) conv_iter_ehdr_osabi(CONV_FMT_ALT_NF, conv_iter_strtol, &uvalue); break; } if (uvalue.csl_found) { *v = uvalue.csl_value; return (1); } } *v = strtoull(str, &endptr, 0); /* If the left over part contains anything but whitespace, fail */ for (; *endptr; endptr++) if (!isspace(*endptr)) return (0); return (1); } /* * Called after getopt() processing is finished if there is a non-empty * match list. Prepares the matching code for use. * * exit: * Returns True (1) if no errors are encountered. Writes an * error string to stderr and returns False (0) otherwise. */ static int match_prepare(char *argv0, uint_t flags) { match_rec_t *list; const char *str; int minus_p = (flags & FLG_SHOW_PHDR) != 0; atoui_type_t atoui_type; /* * Flag ambiguous attempt to use match option with both -p and * and one or more section SHOW options. In this case, we * can't tell what type of item we're supposed to match against. */ if (minus_p && (flags & FLG_MASK_SHOW_SHDR)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_AMBIG_MATCH), basename(argv0)); return (0); } /* Set the match type, based on the presence of the -p option */ if (minus_p) { match_state.item_type = MATCH_ITEM_PT; atoui_type = ATOUI_PT; } else { match_state.item_type = MATCH_ITEM_SHT; atoui_type = ATOUI_SHT; } /* * Scan match list and perform any necessary fixups: * * MATCH_OPT_NAME: If -p is specified, convert MATCH_OPT_NAME (-N) * requests into MATCH_OPT_TYPE (-T). * * MATCH_OPT_TYPE: Now that we know item type we are matching * against, we can convert the string saved in the name * field during getopt() processing into an integer and * write it into the type field. */ for (list = match_state.list; list; list = list->next) { if ((list->opt_type == MATCH_OPT_NAME) && minus_p) list->opt_type = MATCH_OPT_TYPE; if (list->opt_type != MATCH_OPT_TYPE) continue; str = list->value.name; if (atoui(str, atoui_type, &list->value.type) == 0) { const char *fmt = minus_p ? MSG_INTL(MSG_ERR_BAD_T_PT) : MSG_INTL(MSG_ERR_BAD_T_SHT); (void) fprintf(stderr, fmt, basename(argv0), str); return (0); } } return (1); } /* * Returns True (1) if the item with the given name or index should * be displayed, and False (0) if it should not be. * * entry: * match_flags - Bitmask specifying matching options, as described * in _elfdump.h. * name - If MATCH_F_NAME flag is set, name of item under * consideration. Otherwise ignored. * should not be considered. * ndx - If MATCH_F_NDX flag is set, index of item under consideration. * type - If MATCH_F_TYPE is set, type of item under consideration. * If MATCH_F_PHDR is set, this would be a program * header type (PT_). Otherwise, a section header type (SHT_). * * exit: * True will be returned if the given name/index matches those given * by one of the (-I, -N -T) command line options, or if no such option * was used in the command invocation and MATCH_F_STRICT is not * set. */ int match(match_flags_t match_flags, const char *name, uint_t ndx, uint_t type) { match_item_t item_type = (match_flags & MATCH_F_PHDR) ? MATCH_ITEM_PT : MATCH_ITEM_SHT; match_rec_t *list; /* * If there is no match list, then we use the MATCH_F_STRICT * flag to decide what to return. In the strict case, we return * False (0), in the normal case, True (1). */ if (match_state.list == NULL) return ((match_flags & MATCH_F_STRICT) == 0); /* * If item being checked is not the current match type, * then allow it. */ if (item_type != match_state.item_type) return (1); /* Run through the match records and check for a hit */ for (list = match_state.list; list; list = list->next) { switch (list->opt_type) { case MATCH_OPT_NAME: if (((match_flags & MATCH_F_NAME) == 0) || (name == NULL)) break; if (strcmp(list->value.name, name) == 0) return (1); break; case MATCH_OPT_NDX: if ((match_flags & MATCH_F_NDX) && (ndx == list->value.ndx.start)) return (1); break; case MATCH_OPT_RANGE: /* * A range end value less than 0 means that any value * above the start is acceptible. */ if ((match_flags & MATCH_F_NDX) && (ndx >= list->value.ndx.start) && ((list->value.ndx.end < 0) || (ndx <= list->value.ndx.end))) return (1); break; case MATCH_OPT_TYPE: if ((match_flags & MATCH_F_TYPE) && (type == list->value.type)) return (1); break; } } /* Nothing matched */ return (0); } /* * Add an entry to match_state.list for use by match(). This routine is for * use during getopt() processing. It should not be called once * match_prepare() has been called. * * Return True (1) for success. On failure, an error is written * to stderr, and False (0) is returned. */ static int add_match_record(char *argv0, match_rec_t *data) { match_rec_t *rec; match_rec_t *list; if ((rec = malloc(sizeof (*rec))) == NULL) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), basename(argv0), strerror(err)); return (0); } *rec = *data; /* Insert at end of match_state.list */ if (match_state.list == NULL) { match_state.list = rec; } else { for (list = match_state.list; list->next != NULL; list = list->next) ; list->next = rec; } rec->next = NULL; return (1); } static int decide(const char *file, int fd, Elf *elf, uint_t flags, const char *wname, int wfd, uchar_t osabi) { int r; if (gelf_getclass(elf) == ELFCLASS64) r = regular64(file, fd, elf, flags, wname, wfd, osabi); else r = regular32(file, fd, elf, flags, wname, wfd, osabi); return (r); } static int archive(const char *file, int fd, Elf *elf, uint_t flags, const char *wname, int wfd, uchar_t osabi) { Elf_Cmd cmd = ELF_C_READ; Elf_Arhdr *arhdr; Elf *_elf = NULL; size_t ptr; Elf_Arsym *arsym = NULL; /* * Determine if the archive symbol table itself is required. */ if ((flags & FLG_SHOW_SYMBOLS) && match(MATCH_F_NAME, MSG_ORIG(MSG_ELF_ARSYM), 0, 0)) { /* * Get the archive symbol table. */ if (((arsym = elf_getarsym(elf, &ptr)) == 0) && elf_errno()) { /* * The arsym could be 0 even though there was no error. * Print the error message only when there was * real error from elf_getarsym(). */ failure(file, MSG_ORIG(MSG_ELF_GETARSYM)); return (0); } } /* * Print the archive symbol table only when the archive symbol * table exists and it was requested to print. */ if (arsym) { size_t cnt; char index[MAXNDXSIZE]; size_t offset = 0, _offset = 0; const char *fmt_arsym1, *fmt_arsym2; /* * Print out all the symbol entries. The format width used * corresponds to whether the archive symbol table is 32 * or 64-bit. We see them via Elf_Arhdr as size_t values * in either case with no information loss (see the comments * in libelf/getarsym.c) so this is done simply to improve * the user presentation. */ if (_elf_getarsymwordsize(elf) == 8) { dbg_print(0, MSG_INTL(MSG_ARCHIVE_SYMTAB_64)); dbg_print(0, MSG_INTL(MSG_ARCHIVE_FIELDS_64)); fmt_arsym1 = MSG_ORIG(MSG_FMT_ARSYM1_64); fmt_arsym2 = MSG_ORIG(MSG_FMT_ARSYM2_64); } else { dbg_print(0, MSG_INTL(MSG_ARCHIVE_SYMTAB_32)); dbg_print(0, MSG_INTL(MSG_ARCHIVE_FIELDS_32)); fmt_arsym1 = MSG_ORIG(MSG_FMT_ARSYM1_32); fmt_arsym2 = MSG_ORIG(MSG_FMT_ARSYM2_32); } for (cnt = 0; cnt < ptr; cnt++, arsym++) { /* * For each object obtain an elf descriptor so that we * can establish the members name. Note, we have had * archives where the archive header has not been * obtainable so be lenient with errors. */ if ((offset == 0) || ((arsym->as_off != 0) && (arsym->as_off != _offset))) { if (_elf) (void) elf_end(_elf); if (elf_rand(elf, arsym->as_off) != arsym->as_off) { failure(file, MSG_ORIG(MSG_ELF_RAND)); arhdr = NULL; } else if ((_elf = elf_begin(fd, ELF_C_READ, elf)) == 0) { failure(file, MSG_ORIG(MSG_ELF_BEGIN)); arhdr = NULL; } else if ((arhdr = elf_getarhdr(_elf)) == 0) { failure(file, MSG_ORIG(MSG_ELF_GETARHDR)); arhdr = NULL; } _offset = arsym->as_off; if (offset == 0) offset = _offset; } (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(cnt)); if (arsym->as_off) dbg_print(0, fmt_arsym1, index, EC_XWORD(arsym->as_off), arhdr ? arhdr->ar_name : MSG_INTL(MSG_STR_UNKNOWN), (arsym->as_name ? demangle(arsym->as_name, flags) : MSG_INTL(MSG_STR_NULL))); else dbg_print(0, fmt_arsym2, index, EC_XWORD(arsym->as_off)); } if (_elf) (void) elf_end(_elf); /* * If we only need the archive symbol table return. */ if ((flags & FLG_SHOW_SYMBOLS) && match(MATCH_F_STRICT | MATCH_F_NAME, MSG_ORIG(MSG_ELF_ARSYM), -1, -1)) return (0); /* * Reset elf descriptor in preparation for processing each * member. */ if (offset) (void) elf_rand(elf, offset); } /* * Process each object within the archive. */ while ((_elf = elf_begin(fd, cmd, elf)) != NULL) { char name[MAXPATHLEN]; if ((arhdr = elf_getarhdr(_elf)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_GETARHDR)); return (0); } if (*arhdr->ar_name != '/') { (void) snprintf(name, MAXPATHLEN, MSG_ORIG(MSG_FMT_ARNAME), file, arhdr->ar_name); dbg_print(0, MSG_ORIG(MSG_FMT_NLSTR), name); switch (elf_kind(_elf)) { case ELF_K_AR: if (archive(name, fd, _elf, flags, wname, wfd, osabi) == 1) return (1); break; case ELF_K_ELF: if (decide(name, fd, _elf, flags, wname, wfd, osabi) == 1) return (1); break; default: (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADFILE), name); break; } } cmd = elf_next(_elf); (void) elf_end(_elf); } return (0); } int main(int argc, char **argv, char **envp) { Elf *elf; int var, fd, wfd = 0; char *wname = NULL; uint_t flags = 0; match_rec_t match_data; int ret; uchar_t osabi = ELFOSABI_NONE; /* * Establish locale. */ (void) setlocale(LC_MESSAGES, MSG_ORIG(MSG_STR_EMPTY)); (void) textdomain(MSG_ORIG(MSG_SUNW_OST_SGS)); (void) setvbuf(stdout, NULL, _IOLBF, 0); (void) setvbuf(stderr, NULL, _IOLBF, 0); opterr = 0; while ((var = getopt(argc, argv, MSG_ORIG(MSG_STR_OPTIONS))) != EOF) { switch (var) { case 'C': flags |= FLG_CTL_DEMANGLE; break; case 'c': flags |= FLG_SHOW_SHDR; break; case 'd': flags |= FLG_SHOW_DYNAMIC; break; case 'e': flags |= FLG_SHOW_EHDR; break; case 'G': flags |= FLG_SHOW_GOT; break; case 'g': flags |= FLG_SHOW_GROUP; break; case 'H': flags |= FLG_SHOW_CAP; break; case 'h': flags |= FLG_SHOW_HASH; break; case 'I': if (!process_index_opt(optarg, &match_data)) goto usage_brief; if (!add_match_record(argv[0], &match_data)) return (1); flags |= FLG_CTL_MATCH; break; case 'i': flags |= FLG_SHOW_INTERP; break; case 'k': flags |= FLG_CALC_CHECKSUM; break; case 'l': flags |= FLG_CTL_LONGNAME; break; case 'm': flags |= FLG_SHOW_MOVE; break; case 'N': match_data.opt_type = MATCH_OPT_NAME; match_data.value.name = optarg; if (!add_match_record(argv[0], &match_data)) return (1); flags |= FLG_CTL_MATCH; break; case 'n': flags |= FLG_SHOW_NOTE; break; case 'O': { uint32_t val; /* * osabi is a uchar_t in the ELF header. * Don't accept any value that exceeds * that range. */ if ((atoui(optarg, ATOUI_OSABI, &val) == 0) || (val > 255)) { (void) fprintf(stderr, MSG_INTL(MSG_ERR_BAD_T_OSABI), basename(argv[0]), optarg); return (1); } osabi = val; } flags |= FLG_CTL_OSABI; break; case 'P': flags |= FLG_CTL_FAKESHDR; break; case 'p': flags |= FLG_SHOW_PHDR; break; case 'r': flags |= FLG_SHOW_RELOC; break; case 'S': flags |= FLG_SHOW_SORT; break; case 's': flags |= FLG_SHOW_SYMBOLS; break; case 'T': /* * We can't evaluate the value yet, because * we need to know if -p is used or not in * order to tell if we're seeing section header * or program header types. So, we save the * string in the name field, and then convert * it to a type integer in a following pass. */ match_data.opt_type = MATCH_OPT_TYPE; match_data.value.name = optarg; if (!add_match_record(argv[0], &match_data)) return (1); flags |= FLG_CTL_MATCH; break; case 'u': flags |= FLG_SHOW_UNWIND; break; case 'v': flags |= FLG_SHOW_VERSIONS; break; case 'w': wname = optarg; break; case 'y': flags |= FLG_SHOW_SYMINFO; break; case '?': (void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF), basename(argv[0])); detail_usage(); return (1); default: break; } } /* -p and -w are mutually exclusive. -w only works with sections */ if (((flags & FLG_SHOW_PHDR) != 0) && (wname != NULL)) goto usage_brief; /* If a match argument is present, prepare the match state */ if ((match_state.list != NULL) && (match_prepare(argv[0], flags) == 0)) return (1); /* * Decide what to do if no options specifying something to * show or do are present. * * If there is no -w and no match options, then we will set all * the show flags, causing a full display of everything in the * file that we know how to handle. * * Otherwise, if there is no match list, we generate a usage * error and quit. * * In the case where there is a match list, we go ahead and call * regular() anyway, leaving it to decide what to do. If -w is * present, regular() will use the match list to handle it. * In addition, in the absence of explicit show/calc flags, regular() * will compare the section headers to the match list and use * that to generate the FLG_ bits that will display the information * specified by the match list. */ if ((flags & ~FLG_MASK_CTL) == 0) { if (!wname && (match_state.list == NULL)) flags |= FLG_MASK_SHOW; else if (match_state.list == NULL) goto usage_brief; } /* There needs to be at least 1 filename left following the options */ if ((var = argc - optind) == 0) goto usage_brief; /* * If the -l/-C option is specified, set up the liblddbg.so. */ if (flags & FLG_CTL_LONGNAME) dbg_desc->d_extra |= DBG_E_LONG; if (flags & FLG_CTL_DEMANGLE) dbg_desc->d_extra |= DBG_E_DEMANGLE; /* * If the -w option has indicated an output file open it. It's * arguable whether this option has much use when multiple files are * being processed. * * If wname is non-NULL, we know that -p was not specified, due * to the test above. */ if (wname) { if ((wfd = open(wname, (O_RDWR | O_CREAT | O_TRUNC), 0666)) < 0) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_OPEN), wname, strerror(err)); return (1); } } /* * Open the input file, initialize the elf interface, and * process it. */ ret = 0; for (; (optind < argc) && (ret == 0); optind++) { const char *file = argv[optind]; if ((fd = open(argv[optind], O_RDONLY)) == -1) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_ERR_OPEN), file, strerror(err)); continue; } (void) elf_version(EV_CURRENT); if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { failure(file, MSG_ORIG(MSG_ELF_BEGIN)); (void) close(fd); continue; } if (var > 1) dbg_print(0, MSG_ORIG(MSG_FMT_NLSTRNL), file); switch (elf_kind(elf)) { case ELF_K_AR: ret = archive(file, fd, elf, flags, wname, wfd, osabi); break; case ELF_K_ELF: ret = decide(file, fd, elf, flags, wname, wfd, osabi); break; default: (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADFILE), file); break; } (void) close(fd); (void) elf_end(elf); } if (wfd) (void) close(wfd); return (ret); usage_brief: /* Control comes here for a simple usage message and exit */ (void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF), basename(argv[0])); return (1); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include #include #include #include #include <_elfdump.h> #include #include /* * Functions for extracting and formatting numeric values from * structure data. */ /* * Extract the integral field into the value union given and * perform any necessary byte swapping to make the result readable * on the elfdump host. */ void sl_extract_num_field(const char *data, int do_swap, const sl_field_t *fdesc, sl_data_t *field_data) { /* Copy the value bytes into our union */ (void) memcpy(field_data, data + fdesc->slf_offset, fdesc->slf_eltlen); /* Do byte swapping as necessary */ if (do_swap) { switch (fdesc->slf_eltlen) { case 2: field_data->sld_ui16 = BSWAP_HALF(field_data->sld_ui16); break; case 4: field_data->sld_ui32 = BSWAP_WORD(field_data->sld_ui32); break; case 8: field_data->sld_ui64 = BSWAP_LWORD(field_data->sld_ui64); break; } } } /* * Extract the given integer field, and return its value, cast * to Word. Note that this operation must not be used on values * that can be negative, or larger than 32-bits, as information * can be lost. */ Word sl_extract_as_word(const char *data, int do_swap, const sl_field_t *fdesc) { sl_data_t v; /* Extract the value from the raw data */ sl_extract_num_field(data, do_swap, fdesc, &v); if (fdesc->slf_sign) { switch (fdesc->slf_eltlen) { case 1: return ((Word) v.sld_i8); case 2: return ((Word) v.sld_i16); case 4: return ((Word) v.sld_i32); case 8: return ((Word) v.sld_i64); } } else { switch (fdesc->slf_eltlen) { case 1: return ((Word) v.sld_ui8); case 2: return ((Word) v.sld_ui16); case 4: return ((Word) v.sld_ui32); case 8: return ((Word) v.sld_ui64); } } /* This should not be reached */ assert(0); return (0); } /* * Extract the given integer field, and return its value, cast * to Lword. Note that this operation must not be used on values * that can be negative, as information can be lost. */ Lword sl_extract_as_lword(const char *data, int do_swap, const sl_field_t *fdesc) { sl_data_t v; /* Extract the value from the raw data */ sl_extract_num_field(data, do_swap, fdesc, &v); if (fdesc->slf_sign) { switch (fdesc->slf_eltlen) { case 1: return ((Lword) v.sld_i8); case 2: return ((Lword) v.sld_i16); case 4: return ((Lword) v.sld_i32); case 8: return ((Lword) v.sld_i64); } } else { switch (fdesc->slf_eltlen) { case 1: return ((Lword) v.sld_ui8); case 2: return ((Lword) v.sld_ui16); case 4: return ((Lword) v.sld_ui32); case 8: return ((Lword) v.sld_ui64); } } /* This should not be reached */ assert(0); return (0); } /* * Extract the given integer field, and return its value, cast * to int32_t. Note that this operation must not be used on unsigned * values larger than 31-bits, or on signed values larger than 32-bits, * as information can be lost. */ Sword sl_extract_as_sword(const char *data, int do_swap, const sl_field_t *fdesc) { sl_data_t v; /* Extract the value from the raw data */ sl_extract_num_field(data, do_swap, fdesc, &v); if (fdesc->slf_sign) { switch (fdesc->slf_eltlen) { case 1: return ((Sword)v.sld_i8); case 2: return ((Sword)v.sld_i16); case 4: return ((Sword)v.sld_i32); case 8: return ((Sword)v.sld_i64); } } else { switch (fdesc->slf_eltlen) { case 1: return ((Sword)v.sld_ui8); case 2: return ((Sword)v.sld_ui16); case 4: return ((Sword)v.sld_ui32); case 8: return ((Sword)v.sld_ui64); } } /* This should not be reached */ assert(0); return (0); } /* * Extract the integral field and format it into the supplied buffer. */ const char * sl_fmt_num(const char *data, int do_swap, const sl_field_t *fdesc, sl_fmt_num_t fmt_type, sl_fmtbuf_t buf) { /* * These static arrays are indexed by [fdesc->slf_sign][fmt_type] * to get a format string to use for the specified combination. */ static const char *fmt_i8[2][3] = { { MSG_ORIG(MSG_CNOTE_FMT_U), MSG_ORIG(MSG_CNOTE_FMT_X), MSG_ORIG(MSG_CNOTE_FMT_Z2X) }, { MSG_ORIG(MSG_CNOTE_FMT_D), MSG_ORIG(MSG_CNOTE_FMT_X), MSG_ORIG(MSG_CNOTE_FMT_Z2X) } }; static const char *fmt_i16[2][3] = { { MSG_ORIG(MSG_CNOTE_FMT_U), MSG_ORIG(MSG_CNOTE_FMT_X), MSG_ORIG(MSG_CNOTE_FMT_Z4X) }, { MSG_ORIG(MSG_CNOTE_FMT_D), MSG_ORIG(MSG_CNOTE_FMT_X), MSG_ORIG(MSG_CNOTE_FMT_Z4X) } }; static const char *fmt_i32[2][3] = { { MSG_ORIG(MSG_CNOTE_FMT_U), MSG_ORIG(MSG_CNOTE_FMT_X), MSG_ORIG(MSG_CNOTE_FMT_Z8X) }, { MSG_ORIG(MSG_CNOTE_FMT_D), MSG_ORIG(MSG_CNOTE_FMT_X), MSG_ORIG(MSG_CNOTE_FMT_Z8X) } }; static const char *fmt_i64[2][3] = { { MSG_ORIG(MSG_CNOTE_FMT_LLU), MSG_ORIG(MSG_CNOTE_FMT_LLX), MSG_ORIG(MSG_CNOTE_FMT_Z16LLX) }, { MSG_ORIG(MSG_CNOTE_FMT_LLD), MSG_ORIG(MSG_CNOTE_FMT_LLX), MSG_ORIG(MSG_CNOTE_FMT_Z16LLX) } }; sl_data_t v; /* Extract the value from the raw data */ sl_extract_num_field(data, do_swap, fdesc, &v); /* * Format into the buffer. Note that we depend on the signed * and unsigned versions of each width being equivalent as long * as the format specifies the proper formatting. */ switch (fdesc->slf_eltlen) { case 1: (void) snprintf(buf, sizeof (sl_fmtbuf_t), fmt_i8[fdesc->slf_sign][fmt_type], (uint32_t)v.sld_ui8); break; case 2: (void) snprintf(buf, sizeof (sl_fmtbuf_t), fmt_i16[fdesc->slf_sign][fmt_type], (uint32_t)v.sld_ui16); break; case 4: (void) snprintf(buf, sizeof (sl_fmtbuf_t), fmt_i32[fdesc->slf_sign][fmt_type], v.sld_ui32); break; case 8: (void) snprintf(buf, sizeof (sl_fmtbuf_t), fmt_i64[fdesc->slf_sign][fmt_type], v.sld_ui64); break; } return (buf); } /* * Return structure layout definition for the given machine type, * or NULL if the specified machine is not supported. */ const sl_arch_layout_t * sl_mach(Half mach) { switch (mach) { case EM_386: return (struct_layout_i386()); case EM_AMD64: return (struct_layout_amd64()); } /* Unsupported architecture */ return (NULL); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. * Copyright 2018 Joyent, Inc. * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. */ #ifndef _STRUCT_LAYOUT_H #define _STRUCT_LAYOUT_H #include #include <_machelf.h> /* * Local include file for elfdump, used to define structure layout * definitions for various system structs. */ #ifdef __cplusplus extern "C" { #endif /* * illumos defines system structs that elfdump needs to display * data from. We have a variety of hurdles to overcome in doing this: * * - The size of system types can differ between ELFCLASS32 and * ELFCLASS64. * - Stucture layout can differ between architectures, so a given * field can have a different struct offset than is native * for the system running elfdump. Depending on the struct * in question, the layout for one platform may be impossible * to achieve on another. * - The byte order of the core object can differ from that * of the system running elfdump. * * The result is that in the fully general case, each architecture * can have a slightly different definition of these structures. * The usual approach of assigning a pointer of the desired structure * type and then accessing fields through that pointer cannot be used * here. That approach can only be used to access structures with the * native layout of the elfdump host. We want any instance of elfdump * to be able to examine a Solaris object for any supported architecture, * so we need a more flexible approach. * * The solution to this problem lies in the fact that the binary * layout of these public types cannot be changed, except in backward * compatible ways. They are written to core files or published in * other ways such that we can't make changes that would make it * impossible to analyze old files. This means that we can build * table of offsets and sizes for each field of each struct, on * a per-archecture basis. These tables can be used to access the * struct fields directly from the note desc data, and elfdump * on any host can read the data from any other host. * * When reading these tables, it can be very helpful to examine * the struct definition at the same time. */ /* * sl_field_t is used to describe a struct field */ typedef struct { ushort_t slf_offset; /* Offset from start of struct */ ushort_t slf_eltlen; /* Size of datum, in bytes */ ushort_t slf_nelts; /* 0 for scalar, # of els for array */ uchar_t slf_sign; /* True (1) if signed quantity */ } sl_field_t; /* * This type is used to extract and manipulate data described by * sl_field_t. We rely on the C guarantee that all the fields in * a union have offset 0. */ typedef union { char sld_i8; uchar_t sld_ui8; short sld_i16; ushort_t sld_ui16; int32_t sld_i32; uint32_t sld_ui32; int64_t sld_i64; uint64_t sld_ui64; } sl_data_t; /* * Buffer large enough to format any integral value in a field */ typedef char sl_fmtbuf_t[CONV_INV_BUFSIZE * 2]; /* * Types of formatting done by fmt_num() */ typedef enum { SL_FMT_NUM_DEC = 0, /* Decimal integer */ SL_FMT_NUM_HEX = 1, /* Hex integer, with natural width */ SL_FMT_NUM_ZHEX = 2, /* Hex integer, fixed width with zero fill */ } sl_fmt_num_t; /* * Layout description of auxv_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t a_type; sl_field_t a_val; sl_field_t a_ptr; sl_field_t a_fcn; } sl_auxv_layout_t; /* * Layout description of prgregset_t, an architecture specific * array of general register c values */ typedef struct { sl_field_t sizeof_struct; sl_field_t elt0; } sl_prgregset_layout_t; /* * Layout description of lwpstatus_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_flags; sl_field_t pr_lwpid; sl_field_t pr_why; sl_field_t pr_what; sl_field_t pr_cursig; sl_field_t pr_info; sl_field_t pr_lwppend; sl_field_t pr_lwphold; sl_field_t pr_action; sl_field_t pr_altstack; sl_field_t pr_oldcontext; sl_field_t pr_syscall; sl_field_t pr_nsysarg; sl_field_t pr_errno; sl_field_t pr_sysarg; sl_field_t pr_rval1; sl_field_t pr_rval2; sl_field_t pr_clname; sl_field_t pr_tstamp; sl_field_t pr_utime; sl_field_t pr_stime; sl_field_t pr_errpriv; sl_field_t pr_ustack; sl_field_t pr_instr; sl_field_t pr_reg; sl_field_t pr_fpreg; } sl_lwpstatus_layout_t; /* * Layout description of pstatus_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_flags; sl_field_t pr_nlwp; sl_field_t pr_pid; sl_field_t pr_ppid; sl_field_t pr_pgid; sl_field_t pr_sid; sl_field_t pr_aslwpid; sl_field_t pr_agentid; sl_field_t pr_sigpend; sl_field_t pr_brkbase; sl_field_t pr_brksize; sl_field_t pr_stkbase; sl_field_t pr_stksize; sl_field_t pr_utime; sl_field_t pr_stime; sl_field_t pr_cutime; sl_field_t pr_cstime; sl_field_t pr_sigtrace; sl_field_t pr_flttrace; sl_field_t pr_sysentry; sl_field_t pr_sysexit; sl_field_t pr_dmodel; sl_field_t pr_taskid; sl_field_t pr_projid; sl_field_t pr_nzomb; sl_field_t pr_zoneid; sl_field_t pr_lwp; } sl_pstatus_layout_t; /* * Layout description of prstatus_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_flags; sl_field_t pr_why; sl_field_t pr_what; sl_field_t pr_info; sl_field_t pr_cursig; sl_field_t pr_nlwp; sl_field_t pr_sigpend; sl_field_t pr_sighold; sl_field_t pr_altstack; sl_field_t pr_action; sl_field_t pr_pid; sl_field_t pr_ppid; sl_field_t pr_pgrp; sl_field_t pr_sid; sl_field_t pr_utime; sl_field_t pr_stime; sl_field_t pr_cutime; sl_field_t pr_cstime; sl_field_t pr_clname; sl_field_t pr_syscall; sl_field_t pr_nsysarg; sl_field_t pr_sysarg; sl_field_t pr_who; sl_field_t pr_lwppend; sl_field_t pr_oldcontext; sl_field_t pr_brkbase; sl_field_t pr_brksize; sl_field_t pr_stkbase; sl_field_t pr_stksize; sl_field_t pr_processor; sl_field_t pr_bind; sl_field_t pr_instr; sl_field_t pr_reg; } sl_prstatus_layout_t; /* * Layout description of psinfo_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_flag; sl_field_t pr_nlwp; sl_field_t pr_pid; sl_field_t pr_ppid; sl_field_t pr_pgid; sl_field_t pr_sid; sl_field_t pr_uid; sl_field_t pr_euid; sl_field_t pr_gid; sl_field_t pr_egid; sl_field_t pr_addr; sl_field_t pr_size; sl_field_t pr_rssize; sl_field_t pr_ttydev; sl_field_t pr_pctcpu; sl_field_t pr_pctmem; sl_field_t pr_start; sl_field_t pr_time; sl_field_t pr_ctime; sl_field_t pr_fname; sl_field_t pr_psargs; sl_field_t pr_wstat; sl_field_t pr_argc; sl_field_t pr_argv; sl_field_t pr_envp; sl_field_t pr_dmodel; sl_field_t pr_taskid; sl_field_t pr_projid; sl_field_t pr_nzomb; sl_field_t pr_poolid; sl_field_t pr_zoneid; sl_field_t pr_contract; sl_field_t pr_lwp; } sl_psinfo_layout_t; /* * Layout description of prpsinfo_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_state; sl_field_t pr_sname; sl_field_t pr_zomb; sl_field_t pr_nice; sl_field_t pr_flag; sl_field_t pr_uid; sl_field_t pr_gid; sl_field_t pr_pid; sl_field_t pr_ppid; sl_field_t pr_pgrp; sl_field_t pr_sid; sl_field_t pr_addr; sl_field_t pr_size; sl_field_t pr_rssize; sl_field_t pr_wchan; sl_field_t pr_start; sl_field_t pr_time; sl_field_t pr_pri; sl_field_t pr_oldpri; sl_field_t pr_cpu; sl_field_t pr_ottydev; sl_field_t pr_lttydev; sl_field_t pr_clname; sl_field_t pr_fname; sl_field_t pr_psargs; sl_field_t pr_syscall; sl_field_t pr_ctime; sl_field_t pr_bysize; sl_field_t pr_byrssize; sl_field_t pr_argc; sl_field_t pr_argv; sl_field_t pr_envp; sl_field_t pr_wstat; sl_field_t pr_pctcpu; sl_field_t pr_pctmem; sl_field_t pr_euid; sl_field_t pr_egid; sl_field_t pr_aslwpid; sl_field_t pr_dmodel; } sl_prpsinfo_layout_t; /* * Layout description of lwpsinfo_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_flag; sl_field_t pr_lwpid; sl_field_t pr_addr; sl_field_t pr_wchan; sl_field_t pr_stype; sl_field_t pr_state; sl_field_t pr_sname; sl_field_t pr_nice; sl_field_t pr_syscall; sl_field_t pr_oldpri; sl_field_t pr_cpu; sl_field_t pr_pri; sl_field_t pr_pctcpu; sl_field_t pr_start; sl_field_t pr_time; sl_field_t pr_clname; sl_field_t pr_name; sl_field_t pr_onpro; sl_field_t pr_bindpro; sl_field_t pr_bindpset; sl_field_t pr_lgrp; } sl_lwpsinfo_layout_t; /* * Layout description of prcred_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_euid; sl_field_t pr_ruid; sl_field_t pr_suid; sl_field_t pr_egid; sl_field_t pr_rgid; sl_field_t pr_sgid; sl_field_t pr_ngroups; sl_field_t pr_groups; } sl_prcred_layout_t; /* * Layout description of prpriv_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_nsets; sl_field_t pr_setsize; sl_field_t pr_infosize; sl_field_t pr_sets; } sl_prpriv_layout_t; /* * Layout description of priv_impl_info_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t priv_headersize; sl_field_t priv_flags; sl_field_t priv_nsets; sl_field_t priv_setsize; sl_field_t priv_max; sl_field_t priv_infosize; sl_field_t priv_globalinfosize; } sl_priv_impl_info_layout_t; /* * Layout description of fltset_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t word; } sl_fltset_layout_t; /* * Layout description of siginfo_t, from . * * siginfo_t is unusual, in that it contains a large union * full of private fields. There are macros defined to give * access to these fields via the names documented in the * siginfo manpage. We stick to the documented names * rather than try to unravel the undocumented blob. Hence, * the layout description below is a "logical" view of siginfo_t. * The fields below are not necessarily in the same order as * they appear in siginfo_t, nor are they everything that is in * that struct. They may also overlap each other, if they are * contained within of the union. * * The f_ prefixes are used to prevent our field names from * clashing with the macros defined in siginfo.h. */ typedef struct { sl_field_t sizeof_struct; sl_field_t f_si_signo; sl_field_t f_si_errno; sl_field_t f_si_code; sl_field_t f_si_value_int; sl_field_t f_si_value_ptr; sl_field_t f_si_pid; sl_field_t f_si_uid; sl_field_t f_si_ctid; sl_field_t f_si_zoneid; sl_field_t f_si_entity; sl_field_t f_si_addr; sl_field_t f_si_status; sl_field_t f_si_band; } sl_siginfo_layout_t; /* * Layout description of sigset_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t sigbits; } sl_sigset_layout_t; /* * Layout description of struct sigaction, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t sa_flags; sl_field_t sa_hand; sl_field_t sa_sigact; sl_field_t sa_mask; } sl_sigaction_layout_t; /* * Layout description of stack_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t ss_sp; sl_field_t ss_size; sl_field_t ss_flags; } sl_stack_layout_t; /* * Layout description of sysset_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t word; } sl_sysset_layout_t; /* * Layout description of timestruc_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t tv_sec; sl_field_t tv_nsec; } sl_timestruc_layout_t; /* * Layout description of struct utsname, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t sysname; sl_field_t nodename; sl_field_t release; sl_field_t version; sl_field_t machine; } sl_utsname_layout_t; /* * Layout description of prfdinfo_core_t, from . */ typedef struct { sl_field_t sizeof_struct; sl_field_t pr_fd; sl_field_t pr_mode; sl_field_t pr_uid; sl_field_t pr_gid; sl_field_t pr_major; sl_field_t pr_minor; sl_field_t pr_rmajor; sl_field_t pr_rminor; sl_field_t pr_ino; sl_field_t pr_offset; sl_field_t pr_size; sl_field_t pr_fileflags; sl_field_t pr_fdflags; sl_field_t pr_path; } sl_prfdinfo_layout_t; typedef struct { sl_field_t sizeof_struct; sl_field_t pr_version; sl_field_t pr_effective; sl_field_t pr_inherit; sl_field_t pr_lower; sl_field_t pr_upper; } sl_prsecflags_layout_t; typedef struct { sl_field_t sizeof_struct; sl_field_t pr_lwpid; sl_field_t pr_lwpname; } sl_prlwpname_layout_t; typedef struct { sl_field_t sizeof_struct; sl_field_t pru_version; sl_field_t pru_flags; sl_field_t pru_data; } sl_prupanic_layout_t; typedef struct { sl_field_t sizeof_struct; sl_field_t prcwd_fsid; sl_field_t prcwd_fsname; sl_field_t prcwd_mntpt; sl_field_t prcwd_mntspec; sl_field_t prcwd_cwd; } sl_prcwd_layout_t; /* * This type collects all of the layout definitions for * a given architecture. */ typedef struct { const sl_auxv_layout_t *auxv; /* auxv_t */ const sl_fltset_layout_t *fltset; /* fltset_t */ const sl_lwpsinfo_layout_t *lwpsinfo; /* lwpsinfo_t */ const sl_lwpstatus_layout_t *lwpstatus; /* lwpstatus_t */ const sl_prcred_layout_t *prcred; /* prcred_t */ const sl_priv_impl_info_layout_t *priv_impl_info; /* priv_impl_info_t */ const sl_prpriv_layout_t *prpriv; /* prpriv_t */ const sl_psinfo_layout_t *psinfo; /* psinfo_t */ const sl_pstatus_layout_t *pstatus; /* pstatus_t */ const sl_prgregset_layout_t *prgregset; /* prgregset_t */ const sl_prpsinfo_layout_t *prpsinfo; /* prpsinfo_t */ const sl_prstatus_layout_t *prstatus; /* prstatus_t */ const sl_sigaction_layout_t *sigaction; /* struct sigaction */ const sl_siginfo_layout_t *siginfo; /* siginfo_t */ const sl_sigset_layout_t *sigset; /* sigset_t */ const sl_stack_layout_t *stack; /* stack_t */ const sl_sysset_layout_t *sysset; /* sysset_t */ const sl_timestruc_layout_t *timestruc; /* timestruc_t */ const sl_utsname_layout_t *utsname; /* struct utsname */ const sl_prfdinfo_layout_t *prfdinfo; /* prdinfo_t */ const sl_prsecflags_layout_t *prsecflags; /* prsecflags_t */ const sl_prlwpname_layout_t *prlwpname; /* prlwpname_t */ const sl_prupanic_layout_t *prupanic; /* prupanic_t */ const sl_prcwd_layout_t *prcwd; /* prcwd_t */ } sl_arch_layout_t; extern void sl_extract_num_field(const char *data, int do_swap, const sl_field_t *fdesc, sl_data_t *field_data); extern Word sl_extract_as_word(const char *data, int do_swap, const sl_field_t *fdesc); extern Lword sl_extract_as_lword(const char *data, int do_swap, const sl_field_t *fdesc); extern Sword sl_extract_as_sword(const char *data, int do_swap, const sl_field_t *fdesc); extern const char *sl_fmt_num(const char *data, int do_swap, const sl_field_t *fdesc, sl_fmt_num_t fmt_type, sl_fmtbuf_t buf); extern const sl_arch_layout_t *sl_mach(Half); extern const sl_arch_layout_t *struct_layout_i386(void); extern const sl_arch_layout_t *struct_layout_amd64(void); #ifdef __cplusplus } #endif #endif /* _STRUCT_LAYOUT_H */ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. * Copyright 2018 Joyent, Inc. * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. */ #include static const sl_auxv_layout_t auxv_layout = { { 0, 16, 0, 0 }, /* sizeof (auxv_t) */ { 0, 4, 0, 1 }, /* a_type */ { 8, 8, 0, 1 }, /* a_un.a_val */ { 8, 8, 0, 0 }, /* a_un.a_ptr */ { 8, 8, 0, 0 }, /* a_un.a_fcn */ }; static const sl_prgregset_layout_t prgregset_layout = { { 0, 224, 0, 0 }, /* sizeof (prgregset_t) */ { 0, 8, 28, 0 }, /* elt0 */ }; static const sl_lwpstatus_layout_t lwpstatus_layout = { { 0, 1296, 0, 0 }, /* sizeof (lwpstatus_t) */ { 0, 4, 0, 0 }, /* pr_flags */ { 4, 4, 0, 0 }, /* pr_lwpid */ { 8, 2, 0, 0 }, /* pr_why */ { 10, 2, 0, 0 }, /* pr_what */ { 12, 2, 0, 0 }, /* pr_cursig */ { 16, 256, 0, 0 }, /* pr_info */ { 272, 16, 0, 0 }, /* pr_lwppend */ { 288, 16, 0, 0 }, /* pr_lwphold */ { 304, 32, 0, 0 }, /* pr_action */ { 336, 24, 0, 0 }, /* pr_altstack */ { 360, 8, 0, 0 }, /* pr_oldcontext */ { 368, 2, 0, 0 }, /* pr_syscall */ { 370, 2, 0, 0 }, /* pr_nsysarg */ { 372, 4, 0, 0 }, /* pr_errno */ { 376, 8, 8, 0 }, /* pr_sysarg[] */ { 440, 8, 0, 0 }, /* pr_rval1 */ { 448, 8, 0, 0 }, /* pr_rval2 */ { 456, 1, 8, 0 }, /* pr_clname[] */ { 464, 16, 0, 0 }, /* pr_tstamp */ { 480, 16, 0, 0 }, /* pr_utime */ { 496, 16, 0, 0 }, /* pr_stime */ { 524, 4, 0, 0 }, /* pr_errpriv */ { 528, 8, 0, 0 }, /* pr_ustack */ { 536, 8, 0, 0 }, /* pr_instr */ { 544, 224, 0, 0 }, /* pr_reg */ { 768, 528, 0, 0 }, /* pr_fpreg */ }; static const sl_pstatus_layout_t pstatus_layout = { { 0, 1680, 0, 0 }, /* sizeof (pstatus_t) */ { 0, 4, 0, 1 }, /* pr_flags */ { 4, 4, 0, 1 }, /* pr_nlwp */ { 8, 4, 0, 0 }, /* pr_pid */ { 12, 4, 0, 0 }, /* pr_ppid */ { 16, 4, 0, 0 }, /* pr_pgid */ { 20, 4, 0, 0 }, /* pr_sid */ { 24, 4, 0, 1 }, /* pr_aslwpid */ { 28, 4, 0, 1 }, /* pr_agentid */ { 32, 16, 0, 0 }, /* pr_sigpend */ { 48, 8, 0, 0 }, /* pr_brkbase */ { 56, 8, 0, 0 }, /* pr_brksize */ { 64, 8, 0, 0 }, /* pr_stkbase */ { 72, 8, 0, 0 }, /* pr_stksize */ { 80, 16, 0, 0 }, /* pr_utime */ { 96, 16, 0, 0 }, /* pr_stime */ { 112, 16, 0, 0 }, /* pr_cutime */ { 128, 16, 0, 0 }, /* pr_cstime */ { 144, 16, 0, 0 }, /* pr_sigtrace */ { 160, 16, 0, 0 }, /* pr_flttrace */ { 176, 64, 0, 0 }, /* pr_sysentry */ { 240, 64, 0, 0 }, /* pr_sysexit */ { 304, 1, 0, 0 }, /* pr_dmodel */ { 308, 4, 0, 1 }, /* pr_taskid */ { 312, 4, 0, 1 }, /* pr_projid */ { 316, 4, 0, 1 }, /* pr_nzomb */ { 320, 4, 0, 1 }, /* pr_zoneid */ { 384, 1296, 0, 0 }, /* pr_lwp */ }; static const sl_prstatus_layout_t prstatus_layout = { { 0, 824, 0, 0 }, /* sizeof (prstatus_t) */ { 0, 4, 0, 1 }, /* pr_flags */ { 4, 2, 0, 1 }, /* pr_why */ { 6, 2, 0, 1 }, /* pr_what */ { 8, 256, 0, 0 }, /* pr_info */ { 264, 2, 0, 1 }, /* pr_cursig */ { 266, 2, 0, 0 }, /* pr_nlwp */ { 268, 16, 0, 0 }, /* pr_sigpend */ { 284, 16, 0, 0 }, /* pr_sighold */ { 304, 24, 0, 0 }, /* pr_altstack */ { 328, 32, 0, 0 }, /* pr_action */ { 360, 4, 0, 0 }, /* pr_pid */ { 364, 4, 0, 0 }, /* pr_ppid */ { 368, 4, 0, 0 }, /* pr_pgrp */ { 372, 4, 0, 0 }, /* pr_sid */ { 376, 16, 0, 0 }, /* pr_utime */ { 392, 16, 0, 0 }, /* pr_stime */ { 408, 16, 0, 0 }, /* pr_cutime */ { 424, 16, 0, 0 }, /* pr_cstime */ { 440, 1, 8, 0 }, /* pr_clname[] */ { 448, 2, 0, 1 }, /* pr_syscall */ { 450, 2, 0, 1 }, /* pr_nsysarg */ { 456, 8, 8, 1 }, /* pr_sysarg[] */ { 520, 4, 0, 0 }, /* pr_who */ { 524, 16, 0, 0 }, /* pr_lwppend */ { 544, 8, 0, 0 }, /* pr_oldcontext */ { 552, 8, 0, 0 }, /* pr_brkbase */ { 560, 8, 0, 0 }, /* pr_brksize */ { 568, 8, 0, 0 }, /* pr_stkbase */ { 576, 8, 0, 0 }, /* pr_stksize */ { 584, 2, 0, 1 }, /* pr_processor */ { 586, 2, 0, 1 }, /* pr_bind */ { 592, 8, 0, 1 }, /* pr_instr */ { 600, 224, 0, 0 }, /* pr_reg */ }; static const sl_psinfo_layout_t psinfo_layout = { { 0, 416, 0, 0 }, /* sizeof (psinfo_t) */ { 0, 4, 0, 1 }, /* pr_flag */ { 4, 4, 0, 1 }, /* pr_nlwp */ { 8, 4, 0, 0 }, /* pr_pid */ { 12, 4, 0, 0 }, /* pr_ppid */ { 16, 4, 0, 0 }, /* pr_pgid */ { 20, 4, 0, 0 }, /* pr_sid */ { 24, 4, 0, 0 }, /* pr_uid */ { 28, 4, 0, 0 }, /* pr_euid */ { 32, 4, 0, 0 }, /* pr_gid */ { 36, 4, 0, 0 }, /* pr_egid */ { 40, 8, 0, 0 }, /* pr_addr */ { 48, 8, 0, 0 }, /* pr_size */ { 56, 8, 0, 0 }, /* pr_rssize */ { 72, 8, 0, 0 }, /* pr_ttydev */ { 80, 2, 0, 0 }, /* pr_pctcpu */ { 82, 2, 0, 0 }, /* pr_pctmem */ { 88, 16, 0, 0 }, /* pr_start */ { 104, 16, 0, 0 }, /* pr_time */ { 120, 16, 0, 0 }, /* pr_ctime */ { 136, 1, 16, 0 }, /* pr_fname[] */ { 152, 1, 80, 0 }, /* pr_psargs[] */ { 232, 4, 0, 1 }, /* pr_wstat */ { 236, 4, 0, 1 }, /* pr_argc */ { 240, 8, 0, 0 }, /* pr_argv */ { 248, 8, 0, 0 }, /* pr_envp */ { 256, 1, 0, 0 }, /* pr_dmodel */ { 260, 4, 0, 0 }, /* pr_taskid */ { 264, 4, 0, 0 }, /* pr_projid */ { 268, 4, 0, 1 }, /* pr_nzomb */ { 272, 4, 0, 0 }, /* pr_poolid */ { 276, 4, 0, 0 }, /* pr_zoneid */ { 280, 4, 0, 0 }, /* pr_contract */ { 288, 128, 0, 0 }, /* pr_lwp */ }; static const sl_prpsinfo_layout_t prpsinfo_layout = { { 0, 328, 0, 0 }, /* sizeof (prpsinfo_t) */ { 0, 1, 0, 0 }, /* pr_state */ { 1, 1, 0, 0 }, /* pr_sname */ { 2, 1, 0, 0 }, /* pr_zomb */ { 3, 1, 0, 0 }, /* pr_nice */ { 4, 4, 0, 0 }, /* pr_flag */ { 8, 4, 0, 0 }, /* pr_uid */ { 12, 4, 0, 0 }, /* pr_gid */ { 16, 4, 0, 0 }, /* pr_pid */ { 20, 4, 0, 0 }, /* pr_ppid */ { 24, 4, 0, 0 }, /* pr_pgrp */ { 28, 4, 0, 0 }, /* pr_sid */ { 32, 8, 0, 0 }, /* pr_addr */ { 40, 8, 0, 0 }, /* pr_size */ { 48, 8, 0, 0 }, /* pr_rssize */ { 56, 8, 0, 0 }, /* pr_wchan */ { 64, 16, 0, 0 }, /* pr_start */ { 80, 16, 0, 0 }, /* pr_time */ { 96, 4, 0, 1 }, /* pr_pri */ { 100, 1, 0, 0 }, /* pr_oldpri */ { 101, 1, 0, 0 }, /* pr_cpu */ { 102, 2, 0, 0 }, /* pr_ottydev */ { 104, 8, 0, 0 }, /* pr_lttydev */ { 112, 1, 8, 0 }, /* pr_clname[] */ { 120, 1, 16, 0 }, /* pr_fname[] */ { 136, 1, 80, 0 }, /* pr_psargs[] */ { 216, 2, 0, 1 }, /* pr_syscall */ { 224, 16, 0, 0 }, /* pr_ctime */ { 240, 8, 0, 0 }, /* pr_bysize */ { 248, 8, 0, 0 }, /* pr_byrssize */ { 256, 4, 0, 1 }, /* pr_argc */ { 264, 8, 0, 0 }, /* pr_argv */ { 272, 8, 0, 0 }, /* pr_envp */ { 280, 4, 0, 1 }, /* pr_wstat */ { 284, 2, 0, 0 }, /* pr_pctcpu */ { 286, 2, 0, 0 }, /* pr_pctmem */ { 288, 4, 0, 0 }, /* pr_euid */ { 292, 4, 0, 0 }, /* pr_egid */ { 296, 4, 0, 0 }, /* pr_aslwpid */ { 300, 1, 0, 0 }, /* pr_dmodel */ }; static const sl_lwpsinfo_layout_t lwpsinfo_layout = { { 0, 128, 0, 0 }, /* sizeof (lwpsinfo_t) */ { 0, 4, 0, 1 }, /* pr_flag */ { 4, 4, 0, 0 }, /* pr_lwpid */ { 8, 8, 0, 0 }, /* pr_addr */ { 16, 8, 0, 0 }, /* pr_wchan */ { 24, 1, 0, 0 }, /* pr_stype */ { 25, 1, 0, 0 }, /* pr_state */ { 26, 1, 0, 0 }, /* pr_sname */ { 27, 1, 0, 0 }, /* pr_nice */ { 28, 2, 0, 0 }, /* pr_syscall */ { 30, 1, 0, 0 }, /* pr_oldpri */ { 31, 1, 0, 0 }, /* pr_cpu */ { 32, 4, 0, 1 }, /* pr_pri */ { 36, 2, 0, 0 }, /* pr_pctcpu */ { 40, 16, 0, 0 }, /* pr_start */ { 56, 16, 0, 0 }, /* pr_time */ { 72, 1, 8, 0 }, /* pr_clname[] */ { 80, 1, 16, 0 }, /* pr_name[] */ { 96, 4, 0, 1 }, /* pr_onpro */ { 100, 4, 0, 1 }, /* pr_bindpro */ { 104, 4, 0, 1 }, /* pr_bindpset */ { 108, 4, 0, 1 }, /* pr_lgrp */ }; static const sl_prcred_layout_t prcred_layout = { { 0, 32, 0, 0 }, /* sizeof (prcred_t) */ { 0, 4, 0, 0 }, /* pr_euid */ { 4, 4, 0, 0 }, /* pr_ruid */ { 8, 4, 0, 0 }, /* pr_suid */ { 12, 4, 0, 0 }, /* pr_egid */ { 16, 4, 0, 0 }, /* pr_rgid */ { 20, 4, 0, 0 }, /* pr_sgid */ { 24, 4, 0, 1 }, /* pr_ngroups */ { 28, 4, 1, 0 }, /* pr_groups[] */ }; static const sl_prpriv_layout_t prpriv_layout = { { 0, 16, 0, 0 }, /* sizeof (prpriv_t) */ { 0, 4, 0, 0 }, /* pr_nsets */ { 4, 4, 0, 0 }, /* pr_setsize */ { 8, 4, 0, 0 }, /* pr_infosize */ { 12, 4, 1, 0 }, /* pr_sets[] */ }; static const sl_priv_impl_info_layout_t priv_impl_info_layout = { { 0, 28, 0, 0 }, /* sizeof (priv_impl_info_t) */ { 0, 4, 0, 0 }, /* priv_headersize */ { 4, 4, 0, 0 }, /* priv_flags */ { 8, 4, 0, 0 }, /* priv_nsets */ { 12, 4, 0, 0 }, /* priv_setsize */ { 16, 4, 0, 0 }, /* priv_max */ { 20, 4, 0, 0 }, /* priv_infosize */ { 24, 4, 0, 0 }, /* priv_globalinfosize */ }; static const sl_fltset_layout_t fltset_layout = { { 0, 16, 0, 0 }, /* sizeof (fltset_t) */ { 0, 4, 4, 0 }, /* word[] */ }; static const sl_siginfo_layout_t siginfo_layout = { { 0, 256, 0, 0 }, /* sizeof (siginfo_t) */ { 0, 4, 0, 0 }, /* si_signo */ { 8, 4, 0, 0 }, /* si_errno */ { 4, 4, 0, 1 }, /* si_code */ { 32, 4, 0, 0 }, /* si_value.sival_int */ { 32, 8, 0, 0 }, /* si_value.sival_ptr */ { 16, 4, 0, 0 }, /* si_pid */ { 24, 4, 0, 0 }, /* si_uid */ { 48, 4, 0, 0 }, /* si_ctid */ { 52, 4, 0, 0 }, /* si_zoneid */ { 16, 4, 0, 0 }, /* si_entity */ { 16, 8, 0, 0 }, /* si_addr */ { 32, 4, 0, 0 }, /* si_status */ { 24, 8, 0, 0 }, /* si_band */ }; static const sl_sigset_layout_t sigset_layout = { { 0, 16, 0, 0 }, /* sizeof (sigset_t) */ { 0, 4, 4, 0 }, /* __sigbits[] */ }; static const sl_sigaction_layout_t sigaction_layout = { { 0, 32, 0, 0 }, /* sizeof (struct sigaction) */ { 0, 4, 0, 0 }, /* sa_flags */ { 8, 8, 0, 0 }, /* sa_handler */ { 8, 8, 0, 0 }, /* sa_sigaction */ { 16, 16, 0, 0 }, /* sa_mask */ }; static const sl_stack_layout_t stack_layout = { { 0, 24, 0, 0 }, /* sizeof (stack_t) */ { 0, 8, 0, 0 }, /* ss_sp */ { 8, 8, 0, 0 }, /* ss_size */ { 16, 4, 0, 0 }, /* ss_flags */ }; static const sl_sysset_layout_t sysset_layout = { { 0, 64, 0, 0 }, /* sizeof (sysset_t) */ { 0, 4, 16, 0 }, /* word[] */ }; static const sl_timestruc_layout_t timestruc_layout = { { 0, 16, 0, 0 }, /* sizeof (timestruc_t) */ { 0, 8, 0, 0 }, /* tv_sec */ { 8, 8, 0, 0 }, /* tv_nsec */ }; static const sl_utsname_layout_t utsname_layout = { { 0, 1285, 0, 0 }, /* sizeof (struct utsname) */ { 0, 1, 257, 0 }, /* sysname[] */ { 257, 1, 257, 0 }, /* nodename[] */ { 514, 1, 257, 0 }, /* release[] */ { 771, 1, 257, 0 }, /* version[] */ { 1028, 1, 257, 0 }, /* machine[] */ }; static const sl_prfdinfo_layout_t prfdinfo_layout = { { 0, 1088, 0, 0 }, /* sizeof (prfdinfo_core_t) */ { 0, 4, 0, 0 }, /* pr_fd */ { 4, 4, 0, 0 }, /* pr_mode */ { 8, 4, 0, 0 }, /* pr_uid */ { 12, 4, 0, 0 }, /* pr_gid */ { 16, 4, 0, 0 }, /* pr_major */ { 20, 4, 0, 0 }, /* pr_minor */ { 24, 4, 0, 0 }, /* pr_rmajor */ { 28, 4, 0, 0 }, /* pr_rminor */ { 32, 8, 0, 0 }, /* pr_ino */ { 40, 8, 0, 0 }, /* pr_offset */ { 48, 8, 0, 0 }, /* pr_size */ { 56, 4, 0, 0 }, /* pr_fileflags */ { 60, 4, 0, 0 }, /* pr_fdflags */ { 64, 1, 1024, 0 }, /* pr_path[] */ }; static const sl_prsecflags_layout_t prsecflags_layout = { { 0, 40, 0, 0 }, /* sizeof (prsecflags_t) */ { 0, 4, 0, 0 }, /* pr_version */ { 8, 8, 0, 0 }, /* pr_effective */ { 16, 8, 0, 0 }, /* pr_inherit */ { 24, 8, 0, 0 }, /* pr_lower */ { 32, 8, 0, 0 }, /* pr_upper */ }; static const sl_prlwpname_layout_t prlwpname_layout = { { 0, 40, 0, 0 }, /* sizeof (prlwpname_t) */ { 0, 8, 0, 0 }, /* pr_lwpid */ { 8, 1, 32, 0 }, /* pr_lwpname[] */ }; static const sl_prupanic_layout_t prupanic_layout = { { 0, 1032, 0, 0 }, /* sizeof (prupanic_t) */ { 0, 4, 0, 0 }, /* pru_version */ { 4, 4, 0, 0 }, /* pru_flags */ { 8, 1, 1024, 0 }, /* pru_data[] */ }; static const sl_prcwd_layout_t prcwd_layout = { { 0, 3096, 0, 0 }, /* sizeof (prcwd_t) */ { 0, 8, 0, 0 }, /* prcwd_fsid */ { 8, 1, 16, 0 }, /* prcwd_fsname[] */ { 24, 1, 1024, 0 }, /* prcwd_mntpt[] */ { 1048, 1, 1024, 0 }, /* prcwd_mntspec[] */ { 2072, 1, 1024, 0 }, /* prcwd_cwd[] */ }; static const sl_arch_layout_t layout_amd64 = { &auxv_layout, &fltset_layout, &lwpsinfo_layout, &lwpstatus_layout, &prcred_layout, &priv_impl_info_layout, &prpriv_layout, &psinfo_layout, &pstatus_layout, &prgregset_layout, &prpsinfo_layout, &prstatus_layout, &sigaction_layout, &siginfo_layout, &sigset_layout, &stack_layout, &sysset_layout, ×truc_layout, &utsname_layout, &prfdinfo_layout, &prsecflags_layout, &prlwpname_layout, &prupanic_layout, &prcwd_layout, }; const sl_arch_layout_t * struct_layout_amd64(void) { return (&layout_amd64); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. * Copyright 2018 Joyent, Inc. * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. */ #include static const sl_auxv_layout_t auxv_layout = { { 0, 8, 0, 0 }, /* sizeof (auxv_t) */ { 0, 4, 0, 1 }, /* a_type */ { 4, 4, 0, 1 }, /* a_un.a_val */ { 4, 4, 0, 0 }, /* a_un.a_ptr */ { 4, 4, 0, 0 }, /* a_un.a_fcn */ }; static const sl_prgregset_layout_t prgregset_layout = { { 0, 76, 0, 0 }, /* sizeof (prgregset_t) */ { 0, 4, 19, 0 }, /* elt0 */ }; static const sl_lwpstatus_layout_t lwpstatus_layout = { { 0, 800, 0, 0 }, /* sizeof (lwpstatus_t) */ { 0, 4, 0, 0 }, /* pr_flags */ { 4, 4, 0, 0 }, /* pr_lwpid */ { 8, 2, 0, 0 }, /* pr_why */ { 10, 2, 0, 0 }, /* pr_what */ { 12, 2, 0, 0 }, /* pr_cursig */ { 16, 128, 0, 0 }, /* pr_info */ { 144, 16, 0, 0 }, /* pr_lwppend */ { 160, 16, 0, 0 }, /* pr_lwphold */ { 176, 32, 0, 0 }, /* pr_action */ { 208, 12, 0, 0 }, /* pr_altstack */ { 220, 4, 0, 0 }, /* pr_oldcontext */ { 224, 2, 0, 0 }, /* pr_syscall */ { 226, 2, 0, 0 }, /* pr_nsysarg */ { 228, 4, 0, 0 }, /* pr_errno */ { 232, 4, 8, 0 }, /* pr_sysarg[] */ { 264, 4, 0, 0 }, /* pr_rval1 */ { 268, 4, 0, 0 }, /* pr_rval2 */ { 272, 1, 8, 0 }, /* pr_clname[] */ { 280, 8, 0, 0 }, /* pr_tstamp */ { 288, 8, 0, 0 }, /* pr_utime */ { 296, 8, 0, 0 }, /* pr_stime */ { 332, 4, 0, 0 }, /* pr_errpriv */ { 336, 4, 0, 0 }, /* pr_ustack */ { 340, 4, 0, 0 }, /* pr_instr */ { 344, 76, 0, 0 }, /* pr_reg */ { 420, 380, 0, 0 }, /* pr_fpreg */ }; static const sl_pstatus_layout_t pstatus_layout = { { 0, 1136, 0, 0 }, /* sizeof (pstatus_t) */ { 0, 4, 0, 1 }, /* pr_flags */ { 4, 4, 0, 1 }, /* pr_nlwp */ { 8, 4, 0, 0 }, /* pr_pid */ { 12, 4, 0, 0 }, /* pr_ppid */ { 16, 4, 0, 0 }, /* pr_pgid */ { 20, 4, 0, 0 }, /* pr_sid */ { 24, 4, 0, 1 }, /* pr_aslwpid */ { 28, 4, 0, 1 }, /* pr_agentid */ { 32, 16, 0, 0 }, /* pr_sigpend */ { 48, 4, 0, 0 }, /* pr_brkbase */ { 52, 4, 0, 0 }, /* pr_brksize */ { 56, 4, 0, 0 }, /* pr_stkbase */ { 60, 4, 0, 0 }, /* pr_stksize */ { 64, 8, 0, 0 }, /* pr_utime */ { 72, 8, 0, 0 }, /* pr_stime */ { 80, 8, 0, 0 }, /* pr_cutime */ { 88, 8, 0, 0 }, /* pr_cstime */ { 96, 16, 0, 0 }, /* pr_sigtrace */ { 112, 16, 0, 0 }, /* pr_flttrace */ { 128, 64, 0, 0 }, /* pr_sysentry */ { 192, 64, 0, 0 }, /* pr_sysexit */ { 256, 1, 0, 0 }, /* pr_dmodel */ { 260, 4, 0, 1 }, /* pr_taskid */ { 264, 4, 0, 1 }, /* pr_projid */ { 268, 4, 0, 1 }, /* pr_nzomb */ { 272, 4, 0, 1 }, /* pr_zoneid */ { 336, 800, 0, 0 }, /* pr_lwp */ }; static const sl_prstatus_layout_t prstatus_layout = { { 0, 432, 0, 0 }, /* sizeof (prstatus_t) */ { 0, 4, 0, 1 }, /* pr_flags */ { 4, 2, 0, 1 }, /* pr_why */ { 6, 2, 0, 1 }, /* pr_what */ { 8, 128, 0, 0 }, /* pr_info */ { 136, 2, 0, 1 }, /* pr_cursig */ { 138, 2, 0, 0 }, /* pr_nlwp */ { 140, 16, 0, 0 }, /* pr_sigpend */ { 156, 16, 0, 0 }, /* pr_sighold */ { 172, 12, 0, 0 }, /* pr_altstack */ { 184, 32, 0, 0 }, /* pr_action */ { 216, 4, 0, 0 }, /* pr_pid */ { 220, 4, 0, 0 }, /* pr_ppid */ { 224, 4, 0, 0 }, /* pr_pgrp */ { 228, 4, 0, 0 }, /* pr_sid */ { 232, 8, 0, 0 }, /* pr_utime */ { 240, 8, 0, 0 }, /* pr_stime */ { 248, 8, 0, 0 }, /* pr_cutime */ { 256, 8, 0, 0 }, /* pr_cstime */ { 264, 1, 8, 0 }, /* pr_clname[] */ { 272, 2, 0, 1 }, /* pr_syscall */ { 274, 2, 0, 1 }, /* pr_nsysarg */ { 276, 4, 8, 1 }, /* pr_sysarg[] */ { 308, 4, 0, 0 }, /* pr_who */ { 312, 16, 0, 0 }, /* pr_lwppend */ { 328, 4, 0, 0 }, /* pr_oldcontext */ { 332, 4, 0, 0 }, /* pr_brkbase */ { 336, 4, 0, 0 }, /* pr_brksize */ { 340, 4, 0, 0 }, /* pr_stkbase */ { 344, 4, 0, 0 }, /* pr_stksize */ { 348, 2, 0, 1 }, /* pr_processor */ { 350, 2, 0, 1 }, /* pr_bind */ { 352, 4, 0, 1 }, /* pr_instr */ { 356, 76, 0, 0 }, /* pr_reg */ }; static const sl_psinfo_layout_t psinfo_layout = { { 0, 336, 0, 0 }, /* sizeof (psinfo_t) */ { 0, 4, 0, 1 }, /* pr_flag */ { 4, 4, 0, 1 }, /* pr_nlwp */ { 8, 4, 0, 0 }, /* pr_pid */ { 12, 4, 0, 0 }, /* pr_ppid */ { 16, 4, 0, 0 }, /* pr_pgid */ { 20, 4, 0, 0 }, /* pr_sid */ { 24, 4, 0, 0 }, /* pr_uid */ { 28, 4, 0, 0 }, /* pr_euid */ { 32, 4, 0, 0 }, /* pr_gid */ { 36, 4, 0, 0 }, /* pr_egid */ { 40, 4, 0, 0 }, /* pr_addr */ { 44, 4, 0, 0 }, /* pr_size */ { 48, 4, 0, 0 }, /* pr_rssize */ { 56, 4, 0, 0 }, /* pr_ttydev */ { 60, 2, 0, 0 }, /* pr_pctcpu */ { 62, 2, 0, 0 }, /* pr_pctmem */ { 64, 8, 0, 0 }, /* pr_start */ { 72, 8, 0, 0 }, /* pr_time */ { 80, 8, 0, 0 }, /* pr_ctime */ { 88, 1, 16, 0 }, /* pr_fname[] */ { 104, 1, 80, 0 }, /* pr_psargs[] */ { 184, 4, 0, 1 }, /* pr_wstat */ { 188, 4, 0, 1 }, /* pr_argc */ { 192, 4, 0, 0 }, /* pr_argv */ { 196, 4, 0, 0 }, /* pr_envp */ { 200, 1, 0, 0 }, /* pr_dmodel */ { 204, 4, 0, 0 }, /* pr_taskid */ { 208, 4, 0, 0 }, /* pr_projid */ { 212, 4, 0, 1 }, /* pr_nzomb */ { 216, 4, 0, 0 }, /* pr_poolid */ { 220, 4, 0, 0 }, /* pr_zoneid */ { 224, 4, 0, 0 }, /* pr_contract */ { 232, 104, 0, 0 }, /* pr_lwp */ }; static const sl_prpsinfo_layout_t prpsinfo_layout = { { 0, 260, 0, 0 }, /* sizeof (prpsinfo_t) */ { 0, 1, 0, 0 }, /* pr_state */ { 1, 1, 0, 0 }, /* pr_sname */ { 2, 1, 0, 0 }, /* pr_zomb */ { 3, 1, 0, 0 }, /* pr_nice */ { 4, 4, 0, 0 }, /* pr_flag */ { 8, 4, 0, 0 }, /* pr_uid */ { 12, 4, 0, 0 }, /* pr_gid */ { 16, 4, 0, 0 }, /* pr_pid */ { 20, 4, 0, 0 }, /* pr_ppid */ { 24, 4, 0, 0 }, /* pr_pgrp */ { 28, 4, 0, 0 }, /* pr_sid */ { 32, 4, 0, 0 }, /* pr_addr */ { 36, 4, 0, 0 }, /* pr_size */ { 40, 4, 0, 0 }, /* pr_rssize */ { 44, 4, 0, 0 }, /* pr_wchan */ { 48, 8, 0, 0 }, /* pr_start */ { 56, 8, 0, 0 }, /* pr_time */ { 64, 4, 0, 1 }, /* pr_pri */ { 68, 1, 0, 0 }, /* pr_oldpri */ { 69, 1, 0, 0 }, /* pr_cpu */ { 70, 2, 0, 0 }, /* pr_ottydev */ { 72, 4, 0, 0 }, /* pr_lttydev */ { 76, 1, 8, 0 }, /* pr_clname[] */ { 84, 1, 16, 0 }, /* pr_fname[] */ { 100, 1, 80, 0 }, /* pr_psargs[] */ { 180, 2, 0, 1 }, /* pr_syscall */ { 184, 8, 0, 0 }, /* pr_ctime */ { 192, 4, 0, 0 }, /* pr_bysize */ { 196, 4, 0, 0 }, /* pr_byrssize */ { 200, 4, 0, 1 }, /* pr_argc */ { 204, 4, 0, 0 }, /* pr_argv */ { 208, 4, 0, 0 }, /* pr_envp */ { 212, 4, 0, 1 }, /* pr_wstat */ { 216, 2, 0, 0 }, /* pr_pctcpu */ { 218, 2, 0, 0 }, /* pr_pctmem */ { 220, 4, 0, 0 }, /* pr_euid */ { 224, 4, 0, 0 }, /* pr_egid */ { 228, 4, 0, 0 }, /* pr_aslwpid */ { 232, 1, 0, 0 }, /* pr_dmodel */ }; static const sl_lwpsinfo_layout_t lwpsinfo_layout = { { 0, 104, 0, 0 }, /* sizeof (lwpsinfo_t) */ { 0, 4, 0, 1 }, /* pr_flag */ { 4, 4, 0, 0 }, /* pr_lwpid */ { 8, 4, 0, 0 }, /* pr_addr */ { 12, 4, 0, 0 }, /* pr_wchan */ { 16, 1, 0, 0 }, /* pr_stype */ { 17, 1, 0, 0 }, /* pr_state */ { 18, 1, 0, 0 }, /* pr_sname */ { 19, 1, 0, 0 }, /* pr_nice */ { 20, 2, 0, 0 }, /* pr_syscall */ { 22, 1, 0, 0 }, /* pr_oldpri */ { 23, 1, 0, 0 }, /* pr_cpu */ { 24, 4, 0, 1 }, /* pr_pri */ { 28, 2, 0, 0 }, /* pr_pctcpu */ { 32, 8, 0, 0 }, /* pr_start */ { 40, 8, 0, 0 }, /* pr_time */ { 48, 1, 8, 0 }, /* pr_clname[] */ { 56, 1, 16, 0 }, /* pr_name[] */ { 72, 4, 0, 1 }, /* pr_onpro */ { 76, 4, 0, 1 }, /* pr_bindpro */ { 80, 4, 0, 1 }, /* pr_bindpset */ { 84, 4, 0, 1 }, /* pr_lgrp */ }; static const sl_prcred_layout_t prcred_layout = { { 0, 32, 0, 0 }, /* sizeof (prcred_t) */ { 0, 4, 0, 0 }, /* pr_euid */ { 4, 4, 0, 0 }, /* pr_ruid */ { 8, 4, 0, 0 }, /* pr_suid */ { 12, 4, 0, 0 }, /* pr_egid */ { 16, 4, 0, 0 }, /* pr_rgid */ { 20, 4, 0, 0 }, /* pr_sgid */ { 24, 4, 0, 1 }, /* pr_ngroups */ { 28, 4, 1, 0 }, /* pr_groups[] */ }; static const sl_prpriv_layout_t prpriv_layout = { { 0, 16, 0, 0 }, /* sizeof (prpriv_t) */ { 0, 4, 0, 0 }, /* pr_nsets */ { 4, 4, 0, 0 }, /* pr_setsize */ { 8, 4, 0, 0 }, /* pr_infosize */ { 12, 4, 1, 0 }, /* pr_sets[] */ }; static const sl_priv_impl_info_layout_t priv_impl_info_layout = { { 0, 28, 0, 0 }, /* sizeof (priv_impl_info_t) */ { 0, 4, 0, 0 }, /* priv_headersize */ { 4, 4, 0, 0 }, /* priv_flags */ { 8, 4, 0, 0 }, /* priv_nsets */ { 12, 4, 0, 0 }, /* priv_setsize */ { 16, 4, 0, 0 }, /* priv_max */ { 20, 4, 0, 0 }, /* priv_infosize */ { 24, 4, 0, 0 }, /* priv_globalinfosize */ }; static const sl_fltset_layout_t fltset_layout = { { 0, 16, 0, 0 }, /* sizeof (fltset_t) */ { 0, 4, 4, 0 }, /* word[] */ }; static const sl_siginfo_layout_t siginfo_layout = { { 0, 128, 0, 0 }, /* sizeof (siginfo_t) */ { 0, 4, 0, 0 }, /* si_signo */ { 8, 4, 0, 0 }, /* si_errno */ { 4, 4, 0, 1 }, /* si_code */ { 20, 4, 0, 0 }, /* si_value.sival_int */ { 20, 4, 0, 0 }, /* si_value.sival_ptr */ { 12, 4, 0, 0 }, /* si_pid */ { 16, 4, 0, 0 }, /* si_uid */ { 28, 4, 0, 0 }, /* si_ctid */ { 32, 4, 0, 0 }, /* si_zoneid */ { 12, 4, 0, 0 }, /* si_entity */ { 12, 4, 0, 0 }, /* si_addr */ { 20, 4, 0, 0 }, /* si_status */ { 16, 4, 0, 0 }, /* si_band */ }; static const sl_sigset_layout_t sigset_layout = { { 0, 16, 0, 0 }, /* sizeof (sigset_t) */ { 0, 4, 4, 0 }, /* __sigbits[] */ }; static const sl_sigaction_layout_t sigaction_layout = { { 0, 32, 0, 0 }, /* sizeof (struct sigaction) */ { 0, 4, 0, 0 }, /* sa_flags */ { 4, 4, 0, 0 }, /* sa_handler */ { 4, 4, 0, 0 }, /* sa_sigaction */ { 8, 16, 0, 0 }, /* sa_mask */ }; static const sl_stack_layout_t stack_layout = { { 0, 12, 0, 0 }, /* sizeof (stack_t) */ { 0, 4, 0, 0 }, /* ss_sp */ { 4, 4, 0, 0 }, /* ss_size */ { 8, 4, 0, 0 }, /* ss_flags */ }; static const sl_sysset_layout_t sysset_layout = { { 0, 64, 0, 0 }, /* sizeof (sysset_t) */ { 0, 4, 16, 0 }, /* word[] */ }; static const sl_timestruc_layout_t timestruc_layout = { { 0, 8, 0, 0 }, /* sizeof (timestruc_t) */ { 0, 4, 0, 0 }, /* tv_sec */ { 4, 4, 0, 0 }, /* tv_nsec */ }; static const sl_utsname_layout_t utsname_layout = { { 0, 1285, 0, 0 }, /* sizeof (struct utsname) */ { 0, 1, 257, 0 }, /* sysname[] */ { 257, 1, 257, 0 }, /* nodename[] */ { 514, 1, 257, 0 }, /* release[] */ { 771, 1, 257, 0 }, /* version[] */ { 1028, 1, 257, 0 }, /* machine[] */ }; static const sl_prfdinfo_layout_t prfdinfo_layout = { { 0, 1088, 0, 0 }, /* sizeof (prfdinfo_core_t) */ { 0, 4, 0, 0 }, /* pr_fd */ { 4, 4, 0, 0 }, /* pr_mode */ { 8, 4, 0, 0 }, /* pr_uid */ { 12, 4, 0, 0 }, /* pr_gid */ { 16, 4, 0, 0 }, /* pr_major */ { 20, 4, 0, 0 }, /* pr_minor */ { 24, 4, 0, 0 }, /* pr_rmajor */ { 28, 4, 0, 0 }, /* pr_rminor */ { 32, 8, 0, 0 }, /* pr_ino */ { 40, 8, 0, 0 }, /* pr_offset */ { 48, 8, 0, 0 }, /* pr_size */ { 56, 4, 0, 0 }, /* pr_fileflags */ { 60, 4, 0, 0 }, /* pr_fdflags */ { 64, 1, 1024, 0 }, /* pr_path[] */ }; static const sl_prsecflags_layout_t prsecflags_layout = { { 0, 40, 0, 0 }, /* sizeof (prsecflags_t) */ { 0, 4, 0, 0 }, /* pr_version */ { 8, 8, 0, 0 }, /* pr_effective */ { 16, 8, 0, 0 }, /* pr_inherit */ { 24, 8, 0, 0 }, /* pr_lower */ { 32, 8, 0, 0 }, /* pr_upper */ }; static const sl_prlwpname_layout_t prlwpname_layout = { { 0, 40, 0, 0 }, /* sizeof (prlwpname_t) */ { 0, 8, 0, 0 }, /* pr_lwpid */ { 8, 1, 32, 0 }, /* pr_lwpname[] */ }; static const sl_prupanic_layout_t prupanic_layout = { { 0, 1032, 0, 0 }, /* sizeof (prupanic_t) */ { 0, 4, 0, 0 }, /* pru_version */ { 4, 4, 0, 0 }, /* pru_flags */ { 8, 1, 1024, 0 }, /* pru_data[] */ }; static const sl_prcwd_layout_t prcwd_layout = { { 0, 3096, 0, 0 }, /* sizeof (prcwd_t) */ { 0, 8, 0, 0 }, /* prcwd_fsid */ { 8, 1, 16, 0 }, /* prcwd_fsname[] */ { 24, 1, 1024, 0 }, /* prcwd_mntpt[] */ { 1048, 1, 1024, 0 }, /* prcwd_mntspec[] */ { 2072, 1, 1024, 0 }, /* prcwd_cwd[] */ }; static const sl_arch_layout_t layout_i386 = { &auxv_layout, &fltset_layout, &lwpsinfo_layout, &lwpstatus_layout, &prcred_layout, &priv_impl_info_layout, &prpriv_layout, &psinfo_layout, &pstatus_layout, &prgregset_layout, &prpsinfo_layout, &prstatus_layout, &sigaction_layout, &siginfo_layout, &sigset_layout, &stack_layout, &sysset_layout, ×truc_layout, &utsname_layout, &prfdinfo_layout, &prsecflags_layout, &prlwpname_layout, &prupanic_layout, &prcwd_layout, }; const sl_arch_layout_t * struct_layout_i386(void) { return (&layout_i386); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. * Copyright 2018 Joyent, Inc. * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. */ #include static const sl_auxv_layout_t auxv_layout = { { 0, 8, 0, 0 }, /* sizeof (auxv_t) */ { 0, 4, 0, 1 }, /* a_type */ { 4, 4, 0, 1 }, /* a_un.a_val */ { 4, 4, 0, 0 }, /* a_un.a_ptr */ { 4, 4, 0, 0 }, /* a_un.a_fcn */ }; static const sl_prgregset_layout_t prgregset_layout = { { 0, 152, 0, 0 }, /* sizeof (prgregset_t) */ { 0, 4, 38, 0 }, /* elt0 */ }; static const sl_lwpstatus_layout_t lwpstatus_layout = { { 0, 896, 0, 0 }, /* sizeof (lwpstatus_t) */ { 0, 4, 0, 0 }, /* pr_flags */ { 4, 4, 0, 0 }, /* pr_lwpid */ { 8, 2, 0, 0 }, /* pr_why */ { 10, 2, 0, 0 }, /* pr_what */ { 12, 2, 0, 0 }, /* pr_cursig */ { 16, 128, 0, 0 }, /* pr_info */ { 144, 16, 0, 0 }, /* pr_lwppend */ { 160, 16, 0, 0 }, /* pr_lwphold */ { 176, 32, 0, 0 }, /* pr_action */ { 208, 12, 0, 0 }, /* pr_altstack */ { 220, 4, 0, 0 }, /* pr_oldcontext */ { 224, 2, 0, 0 }, /* pr_syscall */ { 226, 2, 0, 0 }, /* pr_nsysarg */ { 228, 4, 0, 0 }, /* pr_errno */ { 232, 4, 8, 0 }, /* pr_sysarg[] */ { 264, 4, 0, 0 }, /* pr_rval1 */ { 268, 4, 0, 0 }, /* pr_rval2 */ { 272, 1, 8, 0 }, /* pr_clname[] */ { 280, 8, 0, 0 }, /* pr_tstamp */ { 288, 8, 0, 0 }, /* pr_utime */ { 296, 8, 0, 0 }, /* pr_stime */ { 332, 4, 0, 0 }, /* pr_errpriv */ { 336, 4, 0, 0 }, /* pr_ustack */ { 340, 4, 0, 0 }, /* pr_instr */ { 344, 152, 0, 0 }, /* pr_reg */ { 496, 400, 0, 0 }, /* pr_fpreg */ }; static const sl_pstatus_layout_t pstatus_layout = { { 0, 1232, 0, 0 }, /* sizeof (pstatus_t) */ { 0, 4, 0, 1 }, /* pr_flags */ { 4, 4, 0, 1 }, /* pr_nlwp */ { 8, 4, 0, 0 }, /* pr_pid */ { 12, 4, 0, 0 }, /* pr_ppid */ { 16, 4, 0, 0 }, /* pr_pgid */ { 20, 4, 0, 0 }, /* pr_sid */ { 24, 4, 0, 1 }, /* pr_aslwpid */ { 28, 4, 0, 1 }, /* pr_agentid */ { 32, 16, 0, 0 }, /* pr_sigpend */ { 48, 4, 0, 0 }, /* pr_brkbase */ { 52, 4, 0, 0 }, /* pr_brksize */ { 56, 4, 0, 0 }, /* pr_stkbase */ { 60, 4, 0, 0 }, /* pr_stksize */ { 64, 8, 0, 0 }, /* pr_utime */ { 72, 8, 0, 0 }, /* pr_stime */ { 80, 8, 0, 0 }, /* pr_cutime */ { 88, 8, 0, 0 }, /* pr_cstime */ { 96, 16, 0, 0 }, /* pr_sigtrace */ { 112, 16, 0, 0 }, /* pr_flttrace */ { 128, 64, 0, 0 }, /* pr_sysentry */ { 192, 64, 0, 0 }, /* pr_sysexit */ { 256, 1, 0, 0 }, /* pr_dmodel */ { 260, 4, 0, 1 }, /* pr_taskid */ { 264, 4, 0, 1 }, /* pr_projid */ { 268, 4, 0, 1 }, /* pr_nzomb */ { 272, 4, 0, 1 }, /* pr_zoneid */ { 336, 896, 0, 0 }, /* pr_lwp */ }; static const sl_prstatus_layout_t prstatus_layout = { { 0, 508, 0, 0 }, /* sizeof (prstatus_t) */ { 0, 4, 0, 1 }, /* pr_flags */ { 4, 2, 0, 1 }, /* pr_why */ { 6, 2, 0, 1 }, /* pr_what */ { 8, 128, 0, 0 }, /* pr_info */ { 136, 2, 0, 1 }, /* pr_cursig */ { 138, 2, 0, 0 }, /* pr_nlwp */ { 140, 16, 0, 0 }, /* pr_sigpend */ { 156, 16, 0, 0 }, /* pr_sighold */ { 172, 12, 0, 0 }, /* pr_altstack */ { 184, 32, 0, 0 }, /* pr_action */ { 216, 4, 0, 0 }, /* pr_pid */ { 220, 4, 0, 0 }, /* pr_ppid */ { 224, 4, 0, 0 }, /* pr_pgrp */ { 228, 4, 0, 0 }, /* pr_sid */ { 232, 8, 0, 0 }, /* pr_utime */ { 240, 8, 0, 0 }, /* pr_stime */ { 248, 8, 0, 0 }, /* pr_cutime */ { 256, 8, 0, 0 }, /* pr_cstime */ { 264, 1, 8, 0 }, /* pr_clname[] */ { 272, 2, 0, 1 }, /* pr_syscall */ { 274, 2, 0, 1 }, /* pr_nsysarg */ { 276, 4, 8, 1 }, /* pr_sysarg[] */ { 308, 4, 0, 0 }, /* pr_who */ { 312, 16, 0, 0 }, /* pr_lwppend */ { 328, 4, 0, 0 }, /* pr_oldcontext */ { 332, 4, 0, 0 }, /* pr_brkbase */ { 336, 4, 0, 0 }, /* pr_brksize */ { 340, 4, 0, 0 }, /* pr_stkbase */ { 344, 4, 0, 0 }, /* pr_stksize */ { 348, 2, 0, 1 }, /* pr_processor */ { 350, 2, 0, 1 }, /* pr_bind */ { 352, 4, 0, 1 }, /* pr_instr */ { 356, 152, 0, 0 }, /* pr_reg */ }; static const sl_psinfo_layout_t psinfo_layout = { { 0, 336, 0, 0 }, /* sizeof (psinfo_t) */ { 0, 4, 0, 1 }, /* pr_flag */ { 4, 4, 0, 1 }, /* pr_nlwp */ { 8, 4, 0, 0 }, /* pr_pid */ { 12, 4, 0, 0 }, /* pr_ppid */ { 16, 4, 0, 0 }, /* pr_pgid */ { 20, 4, 0, 0 }, /* pr_sid */ { 24, 4, 0, 0 }, /* pr_uid */ { 28, 4, 0, 0 }, /* pr_euid */ { 32, 4, 0, 0 }, /* pr_gid */ { 36, 4, 0, 0 }, /* pr_egid */ { 40, 4, 0, 0 }, /* pr_addr */ { 44, 4, 0, 0 }, /* pr_size */ { 48, 4, 0, 0 }, /* pr_rssize */ { 56, 4, 0, 0 }, /* pr_ttydev */ { 60, 2, 0, 0 }, /* pr_pctcpu */ { 62, 2, 0, 0 }, /* pr_pctmem */ { 64, 8, 0, 0 }, /* pr_start */ { 72, 8, 0, 0 }, /* pr_time */ { 80, 8, 0, 0 }, /* pr_ctime */ { 88, 1, 16, 0 }, /* pr_fname[] */ { 104, 1, 80, 0 }, /* pr_psargs[] */ { 184, 4, 0, 1 }, /* pr_wstat */ { 188, 4, 0, 1 }, /* pr_argc */ { 192, 4, 0, 0 }, /* pr_argv */ { 196, 4, 0, 0 }, /* pr_envp */ { 200, 1, 0, 0 }, /* pr_dmodel */ { 204, 4, 0, 0 }, /* pr_taskid */ { 208, 4, 0, 0 }, /* pr_projid */ { 212, 4, 0, 1 }, /* pr_nzomb */ { 216, 4, 0, 0 }, /* pr_poolid */ { 220, 4, 0, 0 }, /* pr_zoneid */ { 224, 4, 0, 0 }, /* pr_contract */ { 232, 104, 0, 0 }, /* pr_lwp */ }; static const sl_prpsinfo_layout_t prpsinfo_layout = { { 0, 260, 0, 0 }, /* sizeof (prpsinfo_t) */ { 0, 1, 0, 0 }, /* pr_state */ { 1, 1, 0, 0 }, /* pr_sname */ { 2, 1, 0, 0 }, /* pr_zomb */ { 3, 1, 0, 0 }, /* pr_nice */ { 4, 4, 0, 0 }, /* pr_flag */ { 8, 4, 0, 0 }, /* pr_uid */ { 12, 4, 0, 0 }, /* pr_gid */ { 16, 4, 0, 0 }, /* pr_pid */ { 20, 4, 0, 0 }, /* pr_ppid */ { 24, 4, 0, 0 }, /* pr_pgrp */ { 28, 4, 0, 0 }, /* pr_sid */ { 32, 4, 0, 0 }, /* pr_addr */ { 36, 4, 0, 0 }, /* pr_size */ { 40, 4, 0, 0 }, /* pr_rssize */ { 44, 4, 0, 0 }, /* pr_wchan */ { 48, 8, 0, 0 }, /* pr_start */ { 56, 8, 0, 0 }, /* pr_time */ { 64, 4, 0, 1 }, /* pr_pri */ { 68, 1, 0, 0 }, /* pr_oldpri */ { 69, 1, 0, 0 }, /* pr_cpu */ { 70, 2, 0, 0 }, /* pr_ottydev */ { 72, 4, 0, 0 }, /* pr_lttydev */ { 76, 1, 8, 0 }, /* pr_clname[] */ { 84, 1, 16, 0 }, /* pr_fname[] */ { 100, 1, 80, 0 }, /* pr_psargs[] */ { 180, 2, 0, 1 }, /* pr_syscall */ { 184, 8, 0, 0 }, /* pr_ctime */ { 192, 4, 0, 0 }, /* pr_bysize */ { 196, 4, 0, 0 }, /* pr_byrssize */ { 200, 4, 0, 1 }, /* pr_argc */ { 204, 4, 0, 0 }, /* pr_argv */ { 208, 4, 0, 0 }, /* pr_envp */ { 212, 4, 0, 1 }, /* pr_wstat */ { 216, 2, 0, 0 }, /* pr_pctcpu */ { 218, 2, 0, 0 }, /* pr_pctmem */ { 220, 4, 0, 0 }, /* pr_euid */ { 224, 4, 0, 0 }, /* pr_egid */ { 228, 4, 0, 0 }, /* pr_aslwpid */ { 232, 1, 0, 0 }, /* pr_dmodel */ }; static const sl_lwpsinfo_layout_t lwpsinfo_layout = { { 0, 104, 0, 0 }, /* sizeof (lwpsinfo_t) */ { 0, 4, 0, 1 }, /* pr_flag */ { 4, 4, 0, 0 }, /* pr_lwpid */ { 8, 4, 0, 0 }, /* pr_addr */ { 12, 4, 0, 0 }, /* pr_wchan */ { 16, 1, 0, 0 }, /* pr_stype */ { 17, 1, 0, 0 }, /* pr_state */ { 18, 1, 0, 0 }, /* pr_sname */ { 19, 1, 0, 0 }, /* pr_nice */ { 20, 2, 0, 0 }, /* pr_syscall */ { 22, 1, 0, 0 }, /* pr_oldpri */ { 23, 1, 0, 0 }, /* pr_cpu */ { 24, 4, 0, 1 }, /* pr_pri */ { 28, 2, 0, 0 }, /* pr_pctcpu */ { 32, 8, 0, 0 }, /* pr_start */ { 40, 8, 0, 0 }, /* pr_time */ { 48, 1, 8, 0 }, /* pr_clname[] */ { 56, 1, 16, 0 }, /* pr_name[] */ { 72, 4, 0, 1 }, /* pr_onpro */ { 76, 4, 0, 1 }, /* pr_bindpro */ { 80, 4, 0, 1 }, /* pr_bindpset */ { 84, 4, 0, 1 }, /* pr_lgrp */ }; static const sl_prcred_layout_t prcred_layout = { { 0, 32, 0, 0 }, /* sizeof (prcred_t) */ { 0, 4, 0, 0 }, /* pr_euid */ { 4, 4, 0, 0 }, /* pr_ruid */ { 8, 4, 0, 0 }, /* pr_suid */ { 12, 4, 0, 0 }, /* pr_egid */ { 16, 4, 0, 0 }, /* pr_rgid */ { 20, 4, 0, 0 }, /* pr_sgid */ { 24, 4, 0, 1 }, /* pr_ngroups */ { 28, 4, 1, 0 }, /* pr_groups[] */ }; static const sl_prpriv_layout_t prpriv_layout = { { 0, 16, 0, 0 }, /* sizeof (prpriv_t) */ { 0, 4, 0, 0 }, /* pr_nsets */ { 4, 4, 0, 0 }, /* pr_setsize */ { 8, 4, 0, 0 }, /* pr_infosize */ { 12, 4, 1, 0 }, /* pr_sets[] */ }; static const sl_priv_impl_info_layout_t priv_impl_info_layout = { { 0, 28, 0, 0 }, /* sizeof (priv_impl_info_t) */ { 0, 4, 0, 0 }, /* priv_headersize */ { 4, 4, 0, 0 }, /* priv_flags */ { 8, 4, 0, 0 }, /* priv_nsets */ { 12, 4, 0, 0 }, /* priv_setsize */ { 16, 4, 0, 0 }, /* priv_max */ { 20, 4, 0, 0 }, /* priv_infosize */ { 24, 4, 0, 0 }, /* priv_globalinfosize */ }; static const sl_fltset_layout_t fltset_layout = { { 0, 16, 0, 0 }, /* sizeof (fltset_t) */ { 0, 4, 4, 0 }, /* word[] */ }; static const sl_siginfo_layout_t siginfo_layout = { { 0, 128, 0, 0 }, /* sizeof (siginfo_t) */ { 0, 4, 0, 0 }, /* si_signo */ { 8, 4, 0, 0 }, /* si_errno */ { 4, 4, 0, 1 }, /* si_code */ { 20, 4, 0, 0 }, /* si_value.sival_int */ { 20, 4, 0, 0 }, /* si_value.sival_ptr */ { 12, 4, 0, 0 }, /* si_pid */ { 16, 4, 0, 0 }, /* si_uid */ { 28, 4, 0, 0 }, /* si_ctid */ { 32, 4, 0, 0 }, /* si_zoneid */ { 12, 4, 0, 0 }, /* si_entity */ { 12, 4, 0, 0 }, /* si_addr */ { 20, 4, 0, 0 }, /* si_status */ { 16, 4, 0, 0 }, /* si_band */ }; static const sl_sigset_layout_t sigset_layout = { { 0, 16, 0, 0 }, /* sizeof (sigset_t) */ { 0, 4, 4, 0 }, /* __sigbits[] */ }; static const sl_sigaction_layout_t sigaction_layout = { { 0, 32, 0, 0 }, /* sizeof (struct sigaction) */ { 0, 4, 0, 0 }, /* sa_flags */ { 4, 4, 0, 0 }, /* sa_handler */ { 4, 4, 0, 0 }, /* sa_sigaction */ { 8, 16, 0, 0 }, /* sa_mask */ }; static const sl_stack_layout_t stack_layout = { { 0, 12, 0, 0 }, /* sizeof (stack_t) */ { 0, 4, 0, 0 }, /* ss_sp */ { 4, 4, 0, 0 }, /* ss_size */ { 8, 4, 0, 0 }, /* ss_flags */ }; static const sl_sysset_layout_t sysset_layout = { { 0, 64, 0, 0 }, /* sizeof (sysset_t) */ { 0, 4, 16, 0 }, /* word[] */ }; static const sl_timestruc_layout_t timestruc_layout = { { 0, 8, 0, 0 }, /* sizeof (timestruc_t) */ { 0, 4, 0, 0 }, /* tv_sec */ { 4, 4, 0, 0 }, /* tv_nsec */ }; static const sl_utsname_layout_t utsname_layout = { { 0, 1285, 0, 0 }, /* sizeof (struct utsname) */ { 0, 1, 257, 0 }, /* sysname[] */ { 257, 1, 257, 0 }, /* nodename[] */ { 514, 1, 257, 0 }, /* release[] */ { 771, 1, 257, 0 }, /* version[] */ { 1028, 1, 257, 0 }, /* machine[] */ }; static const sl_prfdinfo_layout_t prfdinfo_layout = { { 0, 1088, 0, 0 }, /* sizeof (prfdinfo_core_t) */ { 0, 4, 0, 0 }, /* pr_fd */ { 4, 4, 0, 0 }, /* pr_mode */ { 8, 4, 0, 0 }, /* pr_uid */ { 12, 4, 0, 0 }, /* pr_gid */ { 16, 4, 0, 0 }, /* pr_major */ { 20, 4, 0, 0 }, /* pr_minor */ { 24, 4, 0, 0 }, /* pr_rmajor */ { 28, 4, 0, 0 }, /* pr_rminor */ { 32, 8, 0, 0 }, /* pr_ino */ { 40, 8, 0, 0 }, /* pr_offset */ { 48, 8, 0, 0 }, /* pr_size */ { 56, 4, 0, 0 }, /* pr_fileflags */ { 60, 4, 0, 0 }, /* pr_fdflags */ { 64, 1, 1024, 0 }, /* pr_path[] */ }; static const sl_prsecflags_layout_t prsecflags_layout = { { 0, 40, 0, 0 }, /* sizeof (prsecflags_t) */ { 0, 4, 0, 0 }, /* pr_version */ { 8, 8, 0, 0 }, /* pr_effective */ { 16, 8, 0, 0 }, /* pr_inherit */ { 24, 8, 0, 0 }, /* pr_lower */ { 32, 8, 0, 0 }, /* pr_upper */ }; static const sl_prlwpname_layout_t prlwpname_layout = { { 0, 40, 0, 0 }, /* sizeof (prlwpname_t) */ { 0, 8, 0, 0 }, /* pr_lwpid */ { 8, 1, 32, 0 }, /* pr_lwpname[] */ }; static const sl_prupanic_layout_t prupanic_layout = { { 0, 1032, 0, 0 }, /* sizeof (prupanic_t) */ { 0, 4, 0, 0 }, /* pru_version */ { 4, 4, 0, 0 }, /* pru_flags */ { 8, 1, 1024, 0 }, /* pru_data[] */ }; static const sl_prcwd_layout_t prcwd_layout = { { 0, 3096, 0, 0 }, /* sizeof (prcwd_t) */ { 0, 8, 0, 0 }, /* prcwd_fsid */ { 8, 1, 16, 0 }, /* prcwd_fsname[] */ { 24, 1, 1024, 0 }, /* prcwd_mntpt[] */ { 1048, 1, 1024, 0 }, /* prcwd_mntspec[] */ { 2072, 1, 1024, 0 }, /* prcwd_cwd[] */ }; static const sl_arch_layout_t layout_sparc = { &auxv_layout, &fltset_layout, &lwpsinfo_layout, &lwpstatus_layout, &prcred_layout, &priv_impl_info_layout, &prpriv_layout, &psinfo_layout, &pstatus_layout, &prgregset_layout, &prpsinfo_layout, &prstatus_layout, &sigaction_layout, &siginfo_layout, &sigset_layout, &stack_layout, &sysset_layout, ×truc_layout, &utsname_layout, &prfdinfo_layout, &prsecflags_layout, &prlwpname_layout, &prupanic_layout, &prcwd_layout, }; const sl_arch_layout_t * struct_layout_sparc(void) { return (&layout_sparc); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. * Copyright 2018 Joyent, Inc. * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. */ #include static const sl_auxv_layout_t auxv_layout = { { 0, 16, 0, 0 }, /* sizeof (auxv_t) */ { 0, 4, 0, 1 }, /* a_type */ { 8, 8, 0, 1 }, /* a_un.a_val */ { 8, 8, 0, 0 }, /* a_un.a_ptr */ { 8, 8, 0, 0 }, /* a_un.a_fcn */ }; static const sl_prgregset_layout_t prgregset_layout = { { 0, 304, 0, 0 }, /* sizeof (prgregset_t) */ { 0, 8, 38, 0 }, /* elt0 */ }; static const sl_lwpstatus_layout_t lwpstatus_layout = { { 0, 1392, 0, 0 }, /* sizeof (lwpstatus_t) */ { 0, 4, 0, 0 }, /* pr_flags */ { 4, 4, 0, 0 }, /* pr_lwpid */ { 8, 2, 0, 0 }, /* pr_why */ { 10, 2, 0, 0 }, /* pr_what */ { 12, 2, 0, 0 }, /* pr_cursig */ { 16, 256, 0, 0 }, /* pr_info */ { 272, 16, 0, 0 }, /* pr_lwppend */ { 288, 16, 0, 0 }, /* pr_lwphold */ { 304, 32, 0, 0 }, /* pr_action */ { 336, 24, 0, 0 }, /* pr_altstack */ { 360, 8, 0, 0 }, /* pr_oldcontext */ { 368, 2, 0, 0 }, /* pr_syscall */ { 370, 2, 0, 0 }, /* pr_nsysarg */ { 372, 4, 0, 0 }, /* pr_errno */ { 376, 8, 8, 0 }, /* pr_sysarg[] */ { 440, 8, 0, 0 }, /* pr_rval1 */ { 448, 8, 0, 0 }, /* pr_rval2 */ { 456, 1, 8, 0 }, /* pr_clname[] */ { 464, 16, 0, 0 }, /* pr_tstamp */ { 480, 16, 0, 0 }, /* pr_utime */ { 496, 16, 0, 0 }, /* pr_stime */ { 524, 4, 0, 0 }, /* pr_errpriv */ { 528, 8, 0, 0 }, /* pr_ustack */ { 536, 8, 0, 0 }, /* pr_instr */ { 544, 304, 0, 0 }, /* pr_reg */ { 848, 544, 0, 0 }, /* pr_fpreg */ }; static const sl_pstatus_layout_t pstatus_layout = { { 0, 1776, 0, 0 }, /* sizeof (pstatus_t) */ { 0, 4, 0, 1 }, /* pr_flags */ { 4, 4, 0, 1 }, /* pr_nlwp */ { 8, 4, 0, 0 }, /* pr_pid */ { 12, 4, 0, 0 }, /* pr_ppid */ { 16, 4, 0, 0 }, /* pr_pgid */ { 20, 4, 0, 0 }, /* pr_sid */ { 24, 4, 0, 1 }, /* pr_aslwpid */ { 28, 4, 0, 1 }, /* pr_agentid */ { 32, 16, 0, 0 }, /* pr_sigpend */ { 48, 8, 0, 0 }, /* pr_brkbase */ { 56, 8, 0, 0 }, /* pr_brksize */ { 64, 8, 0, 0 }, /* pr_stkbase */ { 72, 8, 0, 0 }, /* pr_stksize */ { 80, 16, 0, 0 }, /* pr_utime */ { 96, 16, 0, 0 }, /* pr_stime */ { 112, 16, 0, 0 }, /* pr_cutime */ { 128, 16, 0, 0 }, /* pr_cstime */ { 144, 16, 0, 0 }, /* pr_sigtrace */ { 160, 16, 0, 0 }, /* pr_flttrace */ { 176, 64, 0, 0 }, /* pr_sysentry */ { 240, 64, 0, 0 }, /* pr_sysexit */ { 304, 1, 0, 0 }, /* pr_dmodel */ { 308, 4, 0, 1 }, /* pr_taskid */ { 312, 4, 0, 1 }, /* pr_projid */ { 316, 4, 0, 1 }, /* pr_nzomb */ { 320, 4, 0, 1 }, /* pr_zoneid */ { 384, 1392, 0, 0 }, /* pr_lwp */ }; static const sl_prstatus_layout_t prstatus_layout = { { 0, 904, 0, 0 }, /* sizeof (prstatus_t) */ { 0, 4, 0, 1 }, /* pr_flags */ { 4, 2, 0, 1 }, /* pr_why */ { 6, 2, 0, 1 }, /* pr_what */ { 8, 256, 0, 0 }, /* pr_info */ { 264, 2, 0, 1 }, /* pr_cursig */ { 266, 2, 0, 0 }, /* pr_nlwp */ { 268, 16, 0, 0 }, /* pr_sigpend */ { 284, 16, 0, 0 }, /* pr_sighold */ { 304, 24, 0, 0 }, /* pr_altstack */ { 328, 32, 0, 0 }, /* pr_action */ { 360, 4, 0, 0 }, /* pr_pid */ { 364, 4, 0, 0 }, /* pr_ppid */ { 368, 4, 0, 0 }, /* pr_pgrp */ { 372, 4, 0, 0 }, /* pr_sid */ { 376, 16, 0, 0 }, /* pr_utime */ { 392, 16, 0, 0 }, /* pr_stime */ { 408, 16, 0, 0 }, /* pr_cutime */ { 424, 16, 0, 0 }, /* pr_cstime */ { 440, 1, 8, 0 }, /* pr_clname[] */ { 448, 2, 0, 1 }, /* pr_syscall */ { 450, 2, 0, 1 }, /* pr_nsysarg */ { 456, 8, 8, 1 }, /* pr_sysarg[] */ { 520, 4, 0, 0 }, /* pr_who */ { 524, 16, 0, 0 }, /* pr_lwppend */ { 544, 8, 0, 0 }, /* pr_oldcontext */ { 552, 8, 0, 0 }, /* pr_brkbase */ { 560, 8, 0, 0 }, /* pr_brksize */ { 568, 8, 0, 0 }, /* pr_stkbase */ { 576, 8, 0, 0 }, /* pr_stksize */ { 584, 2, 0, 1 }, /* pr_processor */ { 586, 2, 0, 1 }, /* pr_bind */ { 592, 8, 0, 1 }, /* pr_instr */ { 600, 304, 0, 0 }, /* pr_reg */ }; static const sl_psinfo_layout_t psinfo_layout = { { 0, 416, 0, 0 }, /* sizeof (psinfo_t) */ { 0, 4, 0, 1 }, /* pr_flag */ { 4, 4, 0, 1 }, /* pr_nlwp */ { 8, 4, 0, 0 }, /* pr_pid */ { 12, 4, 0, 0 }, /* pr_ppid */ { 16, 4, 0, 0 }, /* pr_pgid */ { 20, 4, 0, 0 }, /* pr_sid */ { 24, 4, 0, 0 }, /* pr_uid */ { 28, 4, 0, 0 }, /* pr_euid */ { 32, 4, 0, 0 }, /* pr_gid */ { 36, 4, 0, 0 }, /* pr_egid */ { 40, 8, 0, 0 }, /* pr_addr */ { 48, 8, 0, 0 }, /* pr_size */ { 56, 8, 0, 0 }, /* pr_rssize */ { 72, 8, 0, 0 }, /* pr_ttydev */ { 80, 2, 0, 0 }, /* pr_pctcpu */ { 82, 2, 0, 0 }, /* pr_pctmem */ { 88, 16, 0, 0 }, /* pr_start */ { 104, 16, 0, 0 }, /* pr_time */ { 120, 16, 0, 0 }, /* pr_ctime */ { 136, 1, 16, 0 }, /* pr_fname[] */ { 152, 1, 80, 0 }, /* pr_psargs[] */ { 232, 4, 0, 1 }, /* pr_wstat */ { 236, 4, 0, 1 }, /* pr_argc */ { 240, 8, 0, 0 }, /* pr_argv */ { 248, 8, 0, 0 }, /* pr_envp */ { 256, 1, 0, 0 }, /* pr_dmodel */ { 260, 4, 0, 0 }, /* pr_taskid */ { 264, 4, 0, 0 }, /* pr_projid */ { 268, 4, 0, 1 }, /* pr_nzomb */ { 272, 4, 0, 0 }, /* pr_poolid */ { 276, 4, 0, 0 }, /* pr_zoneid */ { 280, 4, 0, 0 }, /* pr_contract */ { 288, 128, 0, 0 }, /* pr_lwp */ }; static const sl_prpsinfo_layout_t prpsinfo_layout = { { 0, 328, 0, 0 }, /* sizeof (prpsinfo_t) */ { 0, 1, 0, 0 }, /* pr_state */ { 1, 1, 0, 0 }, /* pr_sname */ { 2, 1, 0, 0 }, /* pr_zomb */ { 3, 1, 0, 0 }, /* pr_nice */ { 4, 4, 0, 0 }, /* pr_flag */ { 8, 4, 0, 0 }, /* pr_uid */ { 12, 4, 0, 0 }, /* pr_gid */ { 16, 4, 0, 0 }, /* pr_pid */ { 20, 4, 0, 0 }, /* pr_ppid */ { 24, 4, 0, 0 }, /* pr_pgrp */ { 28, 4, 0, 0 }, /* pr_sid */ { 32, 8, 0, 0 }, /* pr_addr */ { 40, 8, 0, 0 }, /* pr_size */ { 48, 8, 0, 0 }, /* pr_rssize */ { 56, 8, 0, 0 }, /* pr_wchan */ { 64, 16, 0, 0 }, /* pr_start */ { 80, 16, 0, 0 }, /* pr_time */ { 96, 4, 0, 1 }, /* pr_pri */ { 100, 1, 0, 0 }, /* pr_oldpri */ { 101, 1, 0, 0 }, /* pr_cpu */ { 102, 2, 0, 0 }, /* pr_ottydev */ { 104, 8, 0, 0 }, /* pr_lttydev */ { 112, 1, 8, 0 }, /* pr_clname[] */ { 120, 1, 16, 0 }, /* pr_fname[] */ { 136, 1, 80, 0 }, /* pr_psargs[] */ { 216, 2, 0, 1 }, /* pr_syscall */ { 224, 16, 0, 0 }, /* pr_ctime */ { 240, 8, 0, 0 }, /* pr_bysize */ { 248, 8, 0, 0 }, /* pr_byrssize */ { 256, 4, 0, 1 }, /* pr_argc */ { 264, 8, 0, 0 }, /* pr_argv */ { 272, 8, 0, 0 }, /* pr_envp */ { 280, 4, 0, 1 }, /* pr_wstat */ { 284, 2, 0, 0 }, /* pr_pctcpu */ { 286, 2, 0, 0 }, /* pr_pctmem */ { 288, 4, 0, 0 }, /* pr_euid */ { 292, 4, 0, 0 }, /* pr_egid */ { 296, 4, 0, 0 }, /* pr_aslwpid */ { 300, 1, 0, 0 }, /* pr_dmodel */ }; static const sl_lwpsinfo_layout_t lwpsinfo_layout = { { 0, 128, 0, 0 }, /* sizeof (lwpsinfo_t) */ { 0, 4, 0, 1 }, /* pr_flag */ { 4, 4, 0, 0 }, /* pr_lwpid */ { 8, 8, 0, 0 }, /* pr_addr */ { 16, 8, 0, 0 }, /* pr_wchan */ { 24, 1, 0, 0 }, /* pr_stype */ { 25, 1, 0, 0 }, /* pr_state */ { 26, 1, 0, 0 }, /* pr_sname */ { 27, 1, 0, 0 }, /* pr_nice */ { 28, 2, 0, 0 }, /* pr_syscall */ { 30, 1, 0, 0 }, /* pr_oldpri */ { 31, 1, 0, 0 }, /* pr_cpu */ { 32, 4, 0, 1 }, /* pr_pri */ { 36, 2, 0, 0 }, /* pr_pctcpu */ { 40, 16, 0, 0 }, /* pr_start */ { 56, 16, 0, 0 }, /* pr_time */ { 72, 1, 8, 0 }, /* pr_clname[] */ { 80, 1, 16, 0 }, /* pr_name[] */ { 96, 4, 0, 1 }, /* pr_onpro */ { 100, 4, 0, 1 }, /* pr_bindpro */ { 104, 4, 0, 1 }, /* pr_bindpset */ { 108, 4, 0, 1 }, /* pr_lgrp */ }; static const sl_prcred_layout_t prcred_layout = { { 0, 32, 0, 0 }, /* sizeof (prcred_t) */ { 0, 4, 0, 0 }, /* pr_euid */ { 4, 4, 0, 0 }, /* pr_ruid */ { 8, 4, 0, 0 }, /* pr_suid */ { 12, 4, 0, 0 }, /* pr_egid */ { 16, 4, 0, 0 }, /* pr_rgid */ { 20, 4, 0, 0 }, /* pr_sgid */ { 24, 4, 0, 1 }, /* pr_ngroups */ { 28, 4, 1, 0 }, /* pr_groups[] */ }; static const sl_prpriv_layout_t prpriv_layout = { { 0, 16, 0, 0 }, /* sizeof (prpriv_t) */ { 0, 4, 0, 0 }, /* pr_nsets */ { 4, 4, 0, 0 }, /* pr_setsize */ { 8, 4, 0, 0 }, /* pr_infosize */ { 12, 4, 1, 0 }, /* pr_sets[] */ }; static const sl_priv_impl_info_layout_t priv_impl_info_layout = { { 0, 28, 0, 0 }, /* sizeof (priv_impl_info_t) */ { 0, 4, 0, 0 }, /* priv_headersize */ { 4, 4, 0, 0 }, /* priv_flags */ { 8, 4, 0, 0 }, /* priv_nsets */ { 12, 4, 0, 0 }, /* priv_setsize */ { 16, 4, 0, 0 }, /* priv_max */ { 20, 4, 0, 0 }, /* priv_infosize */ { 24, 4, 0, 0 }, /* priv_globalinfosize */ }; static const sl_fltset_layout_t fltset_layout = { { 0, 16, 0, 0 }, /* sizeof (fltset_t) */ { 0, 4, 4, 0 }, /* word[] */ }; static const sl_siginfo_layout_t siginfo_layout = { { 0, 256, 0, 0 }, /* sizeof (siginfo_t) */ { 0, 4, 0, 0 }, /* si_signo */ { 8, 4, 0, 0 }, /* si_errno */ { 4, 4, 0, 1 }, /* si_code */ { 32, 4, 0, 0 }, /* si_value.sival_int */ { 32, 8, 0, 0 }, /* si_value.sival_ptr */ { 16, 4, 0, 0 }, /* si_pid */ { 24, 4, 0, 0 }, /* si_uid */ { 48, 4, 0, 0 }, /* si_ctid */ { 52, 4, 0, 0 }, /* si_zoneid */ { 16, 4, 0, 0 }, /* si_entity */ { 16, 8, 0, 0 }, /* si_addr */ { 32, 4, 0, 0 }, /* si_status */ { 24, 8, 0, 0 }, /* si_band */ }; static const sl_sigset_layout_t sigset_layout = { { 0, 16, 0, 0 }, /* sizeof (sigset_t) */ { 0, 4, 4, 0 }, /* __sigbits[] */ }; static const sl_sigaction_layout_t sigaction_layout = { { 0, 32, 0, 0 }, /* sizeof (struct sigaction) */ { 0, 4, 0, 0 }, /* sa_flags */ { 8, 8, 0, 0 }, /* sa_handler */ { 8, 8, 0, 0 }, /* sa_sigaction */ { 16, 16, 0, 0 }, /* sa_mask */ }; static const sl_stack_layout_t stack_layout = { { 0, 24, 0, 0 }, /* sizeof (stack_t) */ { 0, 8, 0, 0 }, /* ss_sp */ { 8, 8, 0, 0 }, /* ss_size */ { 16, 4, 0, 0 }, /* ss_flags */ }; static const sl_sysset_layout_t sysset_layout = { { 0, 64, 0, 0 }, /* sizeof (sysset_t) */ { 0, 4, 16, 0 }, /* word[] */ }; static const sl_timestruc_layout_t timestruc_layout = { { 0, 16, 0, 0 }, /* sizeof (timestruc_t) */ { 0, 8, 0, 0 }, /* tv_sec */ { 8, 8, 0, 0 }, /* tv_nsec */ }; static const sl_utsname_layout_t utsname_layout = { { 0, 1285, 0, 0 }, /* sizeof (struct utsname) */ { 0, 1, 257, 0 }, /* sysname[] */ { 257, 1, 257, 0 }, /* nodename[] */ { 514, 1, 257, 0 }, /* release[] */ { 771, 1, 257, 0 }, /* version[] */ { 1028, 1, 257, 0 }, /* machine[] */ }; static const sl_prfdinfo_layout_t prfdinfo_layout = { { 0, 1088, 0, 0 }, /* sizeof (prfdinfo_core_t) */ { 0, 4, 0, 0 }, /* pr_fd */ { 4, 4, 0, 0 }, /* pr_mode */ { 8, 4, 0, 0 }, /* pr_uid */ { 12, 4, 0, 0 }, /* pr_gid */ { 16, 4, 0, 0 }, /* pr_major */ { 20, 4, 0, 0 }, /* pr_minor */ { 24, 4, 0, 0 }, /* pr_rmajor */ { 28, 4, 0, 0 }, /* pr_rminor */ { 32, 8, 0, 0 }, /* pr_ino */ { 40, 8, 0, 0 }, /* pr_offset */ { 48, 8, 0, 0 }, /* pr_size */ { 56, 4, 0, 0 }, /* pr_fileflags */ { 60, 4, 0, 0 }, /* pr_fdflags */ { 64, 1, 1024, 0 }, /* pr_path[] */ }; static const sl_prsecflags_layout_t prsecflags_layout = { { 0, 40, 0, 0 }, /* sizeof (prsecflags_t) */ { 0, 4, 0, 0 }, /* pr_version */ { 8, 8, 0, 0 }, /* pr_effective */ { 16, 8, 0, 0 }, /* pr_inherit */ { 24, 8, 0, 0 }, /* pr_lower */ { 32, 8, 0, 0 }, /* pr_upper */ }; static const sl_prlwpname_layout_t prlwpname_layout = { { 0, 40, 0, 0 }, /* sizeof (prlwpname_t) */ { 0, 8, 0, 0 }, /* pr_lwpid */ { 8, 1, 32, 0 }, /* pr_lwpname[] */ }; static const sl_prupanic_layout_t prupanic_layout = { { 0, 1032, 0, 0 }, /* sizeof (prupanic_t) */ { 0, 4, 0, 0 }, /* pru_version */ { 4, 4, 0, 0 }, /* pru_flags */ { 8, 1, 1024, 0 }, /* pru_data[] */ }; static const sl_prcwd_layout_t prcwd_layout = { { 0, 3096, 0, 0 }, /* sizeof (prcwd_t) */ { 0, 8, 0, 0 }, /* prcwd_fsid */ { 8, 1, 16, 0 }, /* prcwd_fsname[] */ { 24, 1, 1024, 0 }, /* prcwd_mntpt[] */ { 1048, 1, 1024, 0 }, /* prcwd_mntspec[] */ { 2072, 1, 1024, 0 }, /* prcwd_cwd[] */ }; static const sl_arch_layout_t layout_sparcv9 = { &auxv_layout, &fltset_layout, &lwpsinfo_layout, &lwpstatus_layout, &prcred_layout, &priv_impl_info_layout, &prpriv_layout, &psinfo_layout, &pstatus_layout, &prgregset_layout, &prpsinfo_layout, &prstatus_layout, &sigaction_layout, &siginfo_layout, &sigset_layout, &stack_layout, &sysset_layout, ×truc_layout, &utsname_layout, &prfdinfo_layout, &prsecflags_layout, &prlwpname_layout, &prupanic_layout, &prcwd_layout, }; const sl_arch_layout_t * struct_layout_sparcv9(void) { return (&layout_sparcv9); }