1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _MDB_PROC_H 28 #define _MDB_PROC_H 29 30 #include <mdb/mdb_target_impl.h> 31 #include <mdb/mdb_io_impl.h> 32 #include <mdb/mdb_addrvec.h> 33 #include <mdb/mdb_modapi.h> 34 #include <mdb/mdb_gelf.h> 35 #include <mdb/mdb_tdb.h> 36 37 #include <sys/param.h> 38 #include <libproc.h> 39 40 #ifdef __cplusplus 41 extern "C" { 42 #endif 43 44 #ifdef _MDB 45 46 /* 47 * The proc target must provide support for examining multi-threaded processes 48 * that use the raw LWP interface, as well as those that use either of the 49 * existing libthread.so implementations. We must also support multiple active 50 * instances of the proc target, as well as the notion that a clean process 51 * can dlopen() libthread after startup, at which point we need to switch to 52 * using libthread_db interfaces to properly debug it. To satisfy these 53 * constraints, we declare an ops vector of functions for obtaining the 54 * register sets of each thread. The proc target will define two versions 55 * of this vector, one for the LWP mode and one for the libthread_db mode, 56 * and then switch the ops vector pointer as appropriate during debugging. 57 * The macros defined below expand to calls to the appropriate entry point. 58 */ 59 typedef struct pt_ptl_ops { 60 int (*ptl_ctor)(mdb_tgt_t *); 61 void (*ptl_dtor)(mdb_tgt_t *, void *); 62 mdb_tgt_tid_t (*ptl_tid)(mdb_tgt_t *, void *); 63 int (*ptl_iter)(mdb_tgt_t *, void *, mdb_addrvec_t *); 64 int (*ptl_getregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, prgregset_t); 65 int (*ptl_setregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, prgregset_t); 66 int (*ptl_getxregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, 67 prxregset_t **, size_t *); 68 void (*ptl_freexregs)(mdb_tgt_t *, void *, prxregset_t *, size_t); 69 int (*ptl_setxregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, 70 const prxregset_t *, size_t); 71 int (*ptl_getfpregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, 72 prfpregset_t *); 73 int (*ptl_setfpregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, 74 const prfpregset_t *); 75 } pt_ptl_ops_t; 76 77 #define PTL_CTOR(t) \ 78 (((pt_data_t *)(t)->t_data)->p_ptl_ops->ptl_ctor(t)) 79 80 #define PTL_DTOR(t) \ 81 (((pt_data_t *)(t)->t_data)->p_ptl_ops->ptl_dtor((t), \ 82 ((pt_data_t *)((t)->t_data))->p_ptl_hdl)) 83 84 #define PTL_TID(t) \ 85 (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_tid((t), \ 86 ((pt_data_t *)(t)->t_data)->p_ptl_hdl)) 87 88 #define PTL_ITER(t, ap) \ 89 (((pt_data_t *)(t)->t_data)->p_ptl_ops->ptl_iter((t), \ 90 ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (ap))) 91 92 #define PTL_GETREGS(t, tid, gregs) \ 93 (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_getregs((t), \ 94 ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (gregs))) 95 96 #define PTL_SETREGS(t, tid, gregs) \ 97 (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_setregs((t), \ 98 ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (gregs))) 99 100 #define PTL_GETXREGS(t, tid, xregs, size) \ 101 (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_getxregs((t), \ 102 ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (xregs), (size))) 103 104 #define PTL_FREEXREGS(t, xregs, size) \ 105 (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_freexregs((t), \ 106 ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (xregs), (size))) 107 108 #define PTL_SETXREGS(t, tid, xregs, size) \ 109 (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_setxregs((t), \ 110 ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (xregs), (size))) 111 112 #define PTL_GETFPREGS(t, tid, fpregs) \ 113 (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_getfpregs((t), \ 114 ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (fpregs))) 115 116 #define PTL_SETFPREGS(t, tid, fpregs) \ 117 (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_setfpregs((t), \ 118 ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (fpregs))) 119 120 /* 121 * When we are following children and a vfork(2) occurs, we append the libproc 122 * handle for the parent to a list of vfork parents. We need to keep track of 123 * this handle so that when the child subsequently execs or dies, we clear out 124 * our breakpoints before releasing the parent. 125 */ 126 typedef struct pt_vforkp { 127 mdb_list_t p_list; /* List forward/back pointers */ 128 struct ps_prochandle *p_pshandle; /* libproc handle */ 129 } pt_vforkp_t; 130 131 /* 132 * Private data structure for the proc target. Among other things, we keep 133 * pointers to the various symbol tables and the ELF file for the executable 134 * here, along with handles for our ops vector defined above. 135 */ 136 typedef struct pt_data { 137 struct ps_prochandle *p_idlehandle; /* idle libproc handle */ 138 mdb_gelf_symtab_t *p_symtab; /* Standard symbol table */ 139 mdb_gelf_symtab_t *p_dynsym; /* Dynamic symbol table */ 140 mdb_gelf_file_t *p_file; /* ELF file object */ 141 mdb_io_t *p_fio; /* Current file i/o backend */ 142 mdb_io_t *p_aout_fio; /* Original file i/o backend */ 143 char p_platform[MAXNAMELEN]; /* Platform string */ 144 char p_symname[MDB_TGT_SYM_NAMLEN]; /* Temporary buffer for syms */ 145 char p_objname[MDB_TGT_MAPSZ]; /* Temporary buffer for objs */ 146 mdb_map_t p_map; /* Persistent map for callers */ 147 mdb_list_t p_vforkp; /* List of vfork parents */ 148 mdb_nv_t p_regs; /* Register descriptions */ 149 const mdb_tdb_ops_t *p_tdb_ops; /* libthread_db ops */ 150 const pt_ptl_ops_t *p_ptl_ops; /* Proc thread layer ops */ 151 void *p_ptl_hdl; /* Proc thread layer handle */ 152 rd_agent_t *p_rtld; /* librtld_db agent handle */ 153 const char *p_stdin; /* File for stdin redirect */ 154 const char *p_stdout; /* File for stdout redirect */ 155 int p_oflags; /* Flags for open(2) */ 156 int p_gflags; /* Flags for Pgrab() */ 157 int p_rflags; /* Flags for Prelease() */ 158 int p_signal; /* Signal to post at next run */ 159 int p_rtld_finished; /* Has rtld init completed? */ 160 int p_rdstate; /* Dlopen state (see below) */ 161 int p_maxsig; /* Maximum valid signal */ 162 mdb_nv_t p_env; /* Current environment */ 163 } pt_data_t; 164 165 #define PT_RD_NONE 0 /* No update pending */ 166 #define PT_RD_ADD 1 /* Dlopen detected */ 167 #define PT_RD_CONSIST 2 /* Link maps consistent */ 168 169 /* 170 * The mdb_tgt_gregset type is opaque to callers of the target interface. 171 * Inside the target we define it explicitly to be a prgregset_t. 172 */ 173 struct mdb_tgt_gregset { 174 prgregset_t gregs; 175 }; 176 177 typedef struct pt_symarg { 178 mdb_tgt_t *psym_targ; /* Target pointer */ 179 uint_t psym_which; /* Type of symbol table */ 180 uint_t psym_type; /* Type of symbols to match */ 181 mdb_tgt_sym_f *psym_func; /* Callback function */ 182 void *psym_private; /* Callback data */ 183 mdb_syminfo_t psym_info; /* Symbol id and table id */ 184 const char *psym_obj; /* Containing object */ 185 } pt_symarg_t; 186 187 typedef struct pt_maparg { 188 mdb_tgt_t *pmap_targ; /* Target pointer */ 189 mdb_tgt_map_f *pmap_func; /* Callback function */ 190 void *pmap_private; /* Callback data */ 191 } pt_maparg_t; 192 193 typedef struct pt_stkarg { 194 mdb_tgt_stack_f *pstk_func; /* Callback function */ 195 void *pstk_private; /* Callback data */ 196 uint_t pstk_gotpc; /* Non-zero pc found */ 197 } pt_stkarg_t; 198 199 typedef struct pt_addarg_t { 200 pt_data_t *pa_pt; /* Proc target data */ 201 mdb_addrvec_t *pa_ap; /* Addrvec pointer */ 202 } pt_addarg_t; 203 204 typedef struct pt_brkpt { 205 uintptr_t ptb_addr; /* Breakpoint address */ 206 ulong_t ptb_instr; /* Saved instruction */ 207 } pt_brkpt_t; 208 209 typedef struct pt_bparg { 210 char *pta_symbol; /* Symbolic name */ 211 uintptr_t pta_addr; /* Explicit address */ 212 } pt_bparg_t; 213 214 /* 215 * The proc_isadep.c file is expected to define the following 216 * ISA-dependent pieces of the proc target: 217 */ 218 extern int pt_regs(uintptr_t, uint_t, int, const mdb_arg_t *); 219 extern int pt_fpregs(uintptr_t, uint_t, int, const mdb_arg_t *); 220 extern int pt_step_out(mdb_tgt_t *, uintptr_t *); 221 extern int pt_next(mdb_tgt_t *, uintptr_t *); 222 extern int pt_getfpreg(mdb_tgt_t *, mdb_tgt_tid_t, ushort_t, ushort_t, 223 mdb_tgt_reg_t *); 224 extern int pt_putfpreg(mdb_tgt_t *, mdb_tgt_tid_t, ushort_t, ushort_t, 225 mdb_tgt_reg_t); 226 extern void pt_addfpregs(mdb_tgt_t *); 227 extern const char *pt_disasm(const GElf_Ehdr *); 228 extern int pt_frameregs(void *, uintptr_t, uint_t, const long *, 229 const mdb_tgt_gregset_t *, boolean_t); 230 extern const mdb_tgt_regdesc_t pt_regdesc[]; 231 232 #endif /* _MDB */ 233 234 #ifdef __cplusplus 235 } 236 #endif 237 238 #endif /* _MDB_PROC_H */ 239