| /* |
| * CDDL HEADER START |
| * |
| * The contents of this file are subject to the terms of the |
| * Common Development and Distribution License, Version 1.0 only |
| * (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 2004 Sun Microsystems, Inc. All rights reserved. |
| * Use is subject to license terms. |
| */ |
| |
| #ifndef _MDB_PROC_H |
| #define _MDB_PROC_H |
| |
| #pragma ident "%Z%%M% %I% %E% SMI" |
| |
| #include <mdb/mdb_target_impl.h> |
| #include <mdb/mdb_io_impl.h> |
| #include <mdb/mdb_addrvec.h> |
| #include <mdb/mdb_modapi.h> |
| #include <mdb/mdb_gelf.h> |
| #include <mdb/mdb_tdb.h> |
| |
| #include <sys/param.h> |
| #include <libproc.h> |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #ifdef _MDB |
| |
| /* |
| * The proc target must provide support for examining multi-threaded processes |
| * that use the raw LWP interface, as well as those that use either of the |
| * existing libthread.so implementations. We must also support multiple active |
| * instances of the proc target, as well as the notion that a clean process |
| * can dlopen() libthread after startup, at which point we need to switch to |
| * using libthread_db interfaces to properly debug it. To satisfy these |
| * constraints, we declare an ops vector of functions for obtaining the |
| * register sets of each thread. The proc target will define two versions |
| * of this vector, one for the LWP mode and one for the libthread_db mode, |
| * and then switch the ops vector pointer as appropriate during debugging. |
| * The macros defined below expand to calls to the appropriate entry point. |
| */ |
| typedef struct pt_ptl_ops { |
| int (*ptl_ctor)(mdb_tgt_t *); |
| void (*ptl_dtor)(mdb_tgt_t *, void *); |
| mdb_tgt_tid_t (*ptl_tid)(mdb_tgt_t *, void *); |
| int (*ptl_iter)(mdb_tgt_t *, void *, mdb_addrvec_t *); |
| int (*ptl_getregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, prgregset_t); |
| int (*ptl_setregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, prgregset_t); |
| #ifdef __sparc |
| int (*ptl_getxregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, |
| prxregset_t *); |
| int (*ptl_setxregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, |
| const prxregset_t *); |
| #endif |
| int (*ptl_getfpregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, |
| prfpregset_t *); |
| int (*ptl_setfpregs)(mdb_tgt_t *, void *, mdb_tgt_tid_t, |
| const prfpregset_t *); |
| } pt_ptl_ops_t; |
| |
| #define PTL_CTOR(t) \ |
| (((pt_data_t *)(t)->t_data)->p_ptl_ops->ptl_ctor(t)) |
| |
| #define PTL_DTOR(t) \ |
| (((pt_data_t *)(t)->t_data)->p_ptl_ops->ptl_dtor((t), \ |
| ((pt_data_t *)((t)->t_data))->p_ptl_hdl)) |
| |
| #define PTL_TID(t) \ |
| (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_tid((t), \ |
| ((pt_data_t *)(t)->t_data)->p_ptl_hdl)) |
| |
| #define PTL_ITER(t, ap) \ |
| (((pt_data_t *)(t)->t_data)->p_ptl_ops->ptl_iter((t), \ |
| ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (ap))) |
| |
| #define PTL_GETREGS(t, tid, gregs) \ |
| (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_getregs((t), \ |
| ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (gregs))) |
| |
| #define PTL_SETREGS(t, tid, gregs) \ |
| (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_setregs((t), \ |
| ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (gregs))) |
| |
| #ifdef __sparc |
| |
| #define PTL_GETXREGS(t, tid, xregs) \ |
| (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_getxregs((t), \ |
| ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (xregs))) |
| |
| #define PTL_SETXREGS(t, tid, xregs) \ |
| (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_setxregs((t), \ |
| ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (xregs))) |
| |
| #endif /* __sparc */ |
| |
| #define PTL_GETFPREGS(t, tid, fpregs) \ |
| (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_getfpregs((t), \ |
| ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (fpregs))) |
| |
| #define PTL_SETFPREGS(t, tid, fpregs) \ |
| (((pt_data_t *)((t)->t_data))->p_ptl_ops->ptl_setfpregs((t), \ |
| ((pt_data_t *)((t)->t_data))->p_ptl_hdl, (tid), (fpregs))) |
| |
| /* |
| * When we are following children and a vfork(2) occurs, we append the libproc |
| * handle for the parent to a list of vfork parents. We need to keep track of |
| * this handle so that when the child subsequently execs or dies, we clear out |
| * our breakpoints before releasing the parent. |
| */ |
| typedef struct pt_vforkp { |
| mdb_list_t p_list; /* List forward/back pointers */ |
| struct ps_prochandle *p_pshandle; /* libproc handle */ |
| } pt_vforkp_t; |
| |
| /* |
| * Private data structure for the proc target. Among other things, we keep |
| * pointers to the various symbol tables and the ELF file for the executable |
| * here, along with handles for our ops vector defined above. |
| */ |
| typedef struct pt_data { |
| struct ps_prochandle *p_idlehandle; /* idle libproc handle */ |
| mdb_gelf_symtab_t *p_symtab; /* Standard symbol table */ |
| mdb_gelf_symtab_t *p_dynsym; /* Dynamic symbol table */ |
| mdb_gelf_file_t *p_file; /* ELF file object */ |
| mdb_io_t *p_fio; /* Current file i/o backend */ |
| mdb_io_t *p_aout_fio; /* Original file i/o backend */ |
| char p_platform[MAXNAMELEN]; /* Platform string */ |
| char p_symname[MDB_TGT_SYM_NAMLEN]; /* Temporary buffer for syms */ |
| char p_objname[MDB_TGT_MAPSZ]; /* Temporary buffer for objs */ |
| mdb_map_t p_map; /* Persistent map for callers */ |
| mdb_list_t p_vforkp; /* List of vfork parents */ |
| mdb_nv_t p_regs; /* Register descriptions */ |
| const mdb_tdb_ops_t *p_tdb_ops; /* libthread_db ops */ |
| const pt_ptl_ops_t *p_ptl_ops; /* Proc thread layer ops */ |
| void *p_ptl_hdl; /* Proc thread layer handle */ |
| rd_agent_t *p_rtld; /* librtld_db agent handle */ |
| const char *p_stdin; /* File for stdin redirect */ |
| const char *p_stdout; /* File for stdout redirect */ |
| int p_oflags; /* Flags for open(2) */ |
| int p_gflags; /* Flags for Pgrab() */ |
| int p_rflags; /* Flags for Prelease() */ |
| int p_signal; /* Signal to post at next run */ |
| int p_rtld_finished; /* Has rtld init completed? */ |
| int p_rdstate; /* Dlopen state (see below) */ |
| int p_maxsig; /* Maximum valid signal */ |
| mdb_nv_t p_env; /* Current environment */ |
| } pt_data_t; |
| |
| #define PT_RD_NONE 0 /* No update pending */ |
| #define PT_RD_ADD 1 /* Dlopen detected */ |
| #define PT_RD_CONSIST 2 /* Link maps consistent */ |
| |
| /* |
| * The mdb_tgt_gregset type is opaque to callers of the target interface. |
| * Inside the target we define it explicitly to be a prgregset_t. |
| */ |
| struct mdb_tgt_gregset { |
| prgregset_t gregs; |
| }; |
| |
| typedef struct pt_symarg { |
| mdb_tgt_t *psym_targ; /* Target pointer */ |
| uint_t psym_which; /* Type of symbol table */ |
| uint_t psym_type; /* Type of symbols to match */ |
| mdb_tgt_sym_f *psym_func; /* Callback function */ |
| void *psym_private; /* Callback data */ |
| mdb_syminfo_t psym_info; /* Symbol id and table id */ |
| const char *psym_obj; /* Containing object */ |
| } pt_symarg_t; |
| |
| typedef struct pt_maparg { |
| mdb_tgt_t *pmap_targ; /* Target pointer */ |
| mdb_tgt_map_f *pmap_func; /* Callback function */ |
| void *pmap_private; /* Callback data */ |
| } pt_maparg_t; |
| |
| typedef struct pt_stkarg { |
| mdb_tgt_stack_f *pstk_func; /* Callback function */ |
| void *pstk_private; /* Callback data */ |
| uint_t pstk_gotpc; /* Non-zero pc found */ |
| } pt_stkarg_t; |
| |
| typedef struct pt_addarg_t { |
| pt_data_t *pa_pt; /* Proc target data */ |
| mdb_addrvec_t *pa_ap; /* Addrvec pointer */ |
| } pt_addarg_t; |
| |
| typedef struct pt_brkpt { |
| uintptr_t ptb_addr; /* Breakpoint address */ |
| ulong_t ptb_instr; /* Saved instruction */ |
| } pt_brkpt_t; |
| |
| typedef struct pt_bparg { |
| char *pta_symbol; /* Symbolic name */ |
| uintptr_t pta_addr; /* Explicit address */ |
| } pt_bparg_t; |
| |
| /* |
| * The proc_isadep.c file is expected to define the following |
| * ISA-dependent pieces of the proc target: |
| */ |
| extern int pt_regs(uintptr_t, uint_t, int, const mdb_arg_t *); |
| extern int pt_fpregs(uintptr_t, uint_t, int, const mdb_arg_t *); |
| extern int pt_step_out(mdb_tgt_t *, uintptr_t *); |
| extern int pt_next(mdb_tgt_t *, uintptr_t *); |
| extern int pt_getfpreg(mdb_tgt_t *, mdb_tgt_tid_t, ushort_t, ushort_t, |
| mdb_tgt_reg_t *); |
| extern int pt_putfpreg(mdb_tgt_t *, mdb_tgt_tid_t, ushort_t, ushort_t, |
| mdb_tgt_reg_t); |
| extern void pt_addfpregs(mdb_tgt_t *); |
| extern const char *pt_disasm(const GElf_Ehdr *); |
| extern int pt_frameregs(void *, uintptr_t, uint_t, const long *, |
| const mdb_tgt_gregset_t *, boolean_t); |
| extern const mdb_tgt_regdesc_t pt_regdesc[]; |
| |
| #endif /* _MDB */ |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* _MDB_PROC_H */ |