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 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright 2018 Joyent, Inc.
27  * Copyright 2024 Oxide Computer Company
28  */
29 
30 #ifndef	_MDB_TARGET_H
31 #define	_MDB_TARGET_H
32 
33 #include <sys/utsname.h>
34 #include <sys/types.h>
35 #include <gelf.h>
36 
37 #ifdef	__cplusplus
38 extern "C" {
39 #endif
40 
41 /*
42  * Forward declaration of the target structure: the target itself is defined in
43  * mdb_tgt_impl.h and is opaque with respect to callers of this interface.
44  */
45 
46 struct mdb_tgt;
47 struct mdb_arg;
48 struct ctf_file;
49 
50 typedef struct mdb_tgt mdb_tgt_t;
51 
52 extern void mdb_create_builtin_tgts(void);
53 extern void mdb_create_loadable_disasms(void);
54 
55 /*
56  * Target Constructors
57  *
58  * These functions are used to create a complete debugger target.  The
59  * constructor is passed as an argument to mdb_tgt_create().
60  */
61 
62 extern int mdb_value_tgt_create(mdb_tgt_t *, int, const char *[]);
63 #ifndef _KMDB
64 extern int mdb_kvm_tgt_create(mdb_tgt_t *, int, const char *[]);
65 extern int mdb_proc_tgt_create(mdb_tgt_t *, int, const char *[]);
66 extern int mdb_kproc_tgt_create(mdb_tgt_t *, int, const char *[]);
67 extern int mdb_rawfile_tgt_create(mdb_tgt_t *, int, const char *[]);
68 #ifdef __amd64
69 extern int mdb_bhyve_tgt_create(mdb_tgt_t *, int, const char *[]);
70 #endif
71 #else
72 extern int kmdb_kvm_create(mdb_tgt_t *, int, const char *[]);
73 #endif
74 
75 /*
76  * Targets are created by calling mdb_tgt_create() with an optional set of
77  * target flags, an argument list, and a target constructor (see above):
78  */
79 
80 #define	MDB_TGT_F_RDWR		0x0001	/* Open for writing (else read-only) */
81 #define	MDB_TGT_F_ALLOWIO	0x0002	/* Allow I/O mem access (live only) */
82 #define	MDB_TGT_F_FORCE		0x0004	/* Force open (even if non-exclusive) */
83 #define	MDB_TGT_F_PRELOAD	0x0008	/* Preload all symbol tables */
84 #define	MDB_TGT_F_NOLOAD	0x0010	/* Do not do load-object processing */
85 #define	MDB_TGT_F_NOSTOP	0x0020	/* Do not stop target on attach */
86 #define	MDB_TGT_F_STEP		0x0040	/* Single-step is pending */
87 #define	MDB_TGT_F_STEP_OUT	0x0080	/* Step-out is pending */
88 #define	MDB_TGT_F_NEXT		0x0100	/* Step-over is pending */
89 #define	MDB_TGT_F_CONT		0x0200	/* Continue is pending */
90 #define	MDB_TGT_F_BUSY		0x0400	/* Target is busy executing */
91 #define	MDB_TGT_F_ASIO		0x0800	/* Use t_aread and t_awrite for i/o */
92 #define	MDB_TGT_F_UNLOAD	0x1000	/* Unload has been requested */
93 #define	MDB_TGT_F_ALL		0x1fff	/* Mask of all valid flags */
94 
95 typedef int mdb_tgt_ctor_f(mdb_tgt_t *, int, const char *[]);
96 
97 extern mdb_tgt_t *mdb_tgt_create(mdb_tgt_ctor_f *, int, int, const char *[]);
98 extern void mdb_tgt_destroy(mdb_tgt_t *);
99 
100 extern int mdb_tgt_getflags(mdb_tgt_t *);
101 extern int mdb_tgt_setflags(mdb_tgt_t *, int);
102 extern int mdb_tgt_setcontext(mdb_tgt_t *, void *);
103 
104 /*
105  * Targets are activated and de-activated by the debugger framework.  An
106  * activation occurs after construction when the target becomes the current
107  * target in the debugger.  A target is de-activated prior to its destructor
108  * being called by mdb_tgt_destroy, or when another target is activated.
109  * These callbacks are suitable for loading support modules and other tasks.
110  */
111 extern void mdb_tgt_activate(mdb_tgt_t *);
112 
113 /*
114  * Prior to issuing a new command prompt, the debugger framework calls the
115  * target's periodic callback to allow it to load new modules or perform
116  * other background tasks.
117  */
118 extern void mdb_tgt_periodic(mdb_tgt_t *);
119 
120 /*
121  * Convenience functions for accessing miscellaneous target information.
122  */
123 extern const char *mdb_tgt_name(mdb_tgt_t *);
124 extern const char *mdb_tgt_isa(mdb_tgt_t *);
125 extern const char *mdb_tgt_platform(mdb_tgt_t *);
126 extern int mdb_tgt_uname(mdb_tgt_t *, struct utsname *);
127 extern int mdb_tgt_dmodel(mdb_tgt_t *);
128 
129 /*
130  * Address Space Interface
131  *
132  * Each target can provide access to a set of address spaces, which may include
133  * a primary virtual address space, a physical address space, an object file
134  * address space (where virtual addresses are converted to file offsets in an
135  * object file), and an I/O port address space.  Additionally, the target can
136  * provide access to alternate address spaces, which are identified by the
137  * opaque mdb_tgt_as_t type.  If the 'as' parameter to mdb_tgt_aread or
138  * mdb_tgt_awrite is one of the listed constants, these calls are equivalent
139  * to mdb_tgt_{v|p|f|io}read or write.
140  */
141 
142 typedef void *		mdb_tgt_as_t;		/* Opaque address space id */
143 typedef uint64_t	mdb_tgt_addr_t;		/* Generic unsigned address */
144 typedef uint64_t	physaddr_t;		/* Physical memory address */
145 
146 #define	MDB_TGT_AS_VIRT	((mdb_tgt_as_t)-1L)	/* Virtual address space: */
147 #define	MDB_TGT_AS_VIRT_I ((mdb_tgt_as_t)-2L)	/*   special case for code */
148 #define	MDB_TGT_AS_VIRT_S ((mdb_tgt_as_t)-3L)	/*   special case for stack */
149 #define	MDB_TGT_AS_PHYS	((mdb_tgt_as_t)-4L)	/* Physical address space */
150 #define	MDB_TGT_AS_FILE	((mdb_tgt_as_t)-5L)	/* Object file address space */
151 #define	MDB_TGT_AS_IO	((mdb_tgt_as_t)-6L)	/* I/o address space */
152 
153 extern ssize_t mdb_tgt_aread(mdb_tgt_t *, mdb_tgt_as_t,
154 	void *, size_t, mdb_tgt_addr_t);
155 
156 extern ssize_t mdb_tgt_awrite(mdb_tgt_t *, mdb_tgt_as_t,
157 	const void *, size_t, mdb_tgt_addr_t);
158 
159 extern ssize_t mdb_tgt_vread(mdb_tgt_t *, void *, size_t, uintptr_t);
160 extern ssize_t mdb_tgt_vwrite(mdb_tgt_t *, const void *, size_t, uintptr_t);
161 extern ssize_t mdb_tgt_pread(mdb_tgt_t *, void *, size_t, physaddr_t);
162 extern ssize_t mdb_tgt_pwrite(mdb_tgt_t *, const void *, size_t, physaddr_t);
163 extern ssize_t mdb_tgt_fread(mdb_tgt_t *, void *, size_t, uintptr_t);
164 extern ssize_t mdb_tgt_fwrite(mdb_tgt_t *, const void *, size_t, uintptr_t);
165 extern ssize_t mdb_tgt_ioread(mdb_tgt_t *, void *, size_t, uintptr_t);
166 extern ssize_t mdb_tgt_iowrite(mdb_tgt_t *, const void *, size_t, uintptr_t);
167 
168 /*
169  * Convert an address-space's virtual address to the corresponding
170  * physical address (only useful for kernel targets):
171  */
172 extern int mdb_tgt_vtop(mdb_tgt_t *, mdb_tgt_as_t, uintptr_t, physaddr_t *);
173 
174 /*
175  * Convenience functions for reading and writing null-terminated
176  * strings from any of the target address spaces:
177  */
178 extern ssize_t mdb_tgt_readstr(mdb_tgt_t *, mdb_tgt_as_t,
179 	char *, size_t, mdb_tgt_addr_t);
180 
181 extern ssize_t mdb_tgt_writestr(mdb_tgt_t *, mdb_tgt_as_t,
182 	const char *, mdb_tgt_addr_t);
183 
184 /*
185  * Symbol Table Interface
186  *
187  * Each target can provide access to one or more symbol tables, which can be
188  * iterated over, or used to lookup symbols by either name or address.  The
189  * target can support a primary executable and primary dynamic symbol table,
190  * a symbol table for its run-time link-editor, and symbol tables for one or
191  * more loaded objects.  A symbol is uniquely identified by an object name,
192  * a symbol table id, and a symbol id.  Symbols can be discovered by iterating
193  * over them, looking them up by name, or looking them up by address.
194  */
195 
196 typedef struct mdb_syminfo {
197 	uint_t sym_table;	/* Symbol table id (see symbol_iter, below) */
198 	uint_t sym_id;		/* Symbol identifier */
199 } mdb_syminfo_t;
200 
201 /*
202  * Reserved object names for mdb_tgt_lookup_by_name():
203  */
204 #define	MDB_TGT_OBJ_EXEC	((const char *)0L)	/* Executable symbols */
205 #define	MDB_TGT_OBJ_RTLD	((const char *)1L)	/* Ldso/krtld symbols */
206 #define	MDB_TGT_OBJ_EVERY	((const char *)-1L)	/* All known symbols */
207 
208 extern int mdb_tgt_lookup_by_scope(mdb_tgt_t *, const char *,
209 	GElf_Sym *, mdb_syminfo_t *);
210 
211 extern int mdb_tgt_lookup_by_name(mdb_tgt_t *, const char *,
212 	const char *, GElf_Sym *, mdb_syminfo_t *);
213 
214 /*
215  * Flag bit passed to mdb_tgt_lookup_by_addr():
216  */
217 #define	MDB_TGT_SYM_FUZZY	0	/* Match closest address */
218 #define	MDB_TGT_SYM_EXACT	1	/* Match exact address only */
219 
220 #define	MDB_TGT_SYM_NAMLEN	1024	/* Recommended max symbol name length */
221 
222 extern int mdb_tgt_lookup_by_addr(mdb_tgt_t *, uintptr_t, uint_t,
223 	char *, size_t, GElf_Sym *, mdb_syminfo_t *);
224 
225 /*
226  * Callback function prototype for mdb_tgt_symbol_iter():
227  */
228 typedef int mdb_tgt_sym_f(void *, const GElf_Sym *, const char *,
229 	const mdb_syminfo_t *sip, const char *);
230 
231 /*
232  * Values for selecting symbol tables with mdb_tgt_symbol_iter():
233  */
234 #define	MDB_TGT_PRVSYM		0	/* User's private symbol table */
235 #define	MDB_TGT_SYMTAB		1	/* Normal symbol table (.symtab) */
236 #define	MDB_TGT_DYNSYM		2	/* Dynamic symbol table (.dynsym) */
237 
238 /*
239  * Values for selecting symbols of interest by binding and type.  These flags
240  * can be used to construct a bitmask to pass to mdb_tgt_symbol_iter().  The
241  * module API has its own slightly different names for these values.  If you are
242  * adding a new flag here, you should consider exposing it in the module API.
243  * If you are changing these flags and their meanings, you will need to update
244  * the module API implementation to account for those changes.
245  */
246 #define	MDB_TGT_BIND_LOCAL	0x0001	/* Local (static-scope) symbols */
247 #define	MDB_TGT_BIND_GLOBAL	0x0002	/* Global symbols */
248 #define	MDB_TGT_BIND_WEAK	0x0004	/* Weak binding symbols */
249 
250 #define	MDB_TGT_BIND_ANY	0x0007	/* Any of the above */
251 
252 #define	MDB_TGT_TYPE_NOTYPE	0x0100	/* Symbol has no type */
253 #define	MDB_TGT_TYPE_OBJECT	0x0200	/* Symbol refers to data */
254 #define	MDB_TGT_TYPE_FUNC	0x0400	/* Symbol refers to text */
255 #define	MDB_TGT_TYPE_SECT	0x0800	/* Symbol refers to a section */
256 #define	MDB_TGT_TYPE_FILE	0x1000	/* Symbol refers to a source file */
257 #define	MDB_TGT_TYPE_COMMON	0x2000	/* Symbol refers to a common block */
258 #define	MDB_TGT_TYPE_TLS	0x4000	/* Symbol refers to TLS */
259 
260 #define	MDB_TGT_TYPE_ANY	0x7f00	/* Any of the above */
261 
262 extern int mdb_tgt_symbol_iter(mdb_tgt_t *, const char *, uint_t, uint_t,
263 	mdb_tgt_sym_f *, void *);
264 
265 /*
266  * Convenience functions for reading and writing at the address specified
267  * by a given object file and symbol name:
268  */
269 extern ssize_t mdb_tgt_readsym(mdb_tgt_t *, mdb_tgt_as_t, void *, size_t,
270 	const char *, const char *);
271 
272 extern ssize_t mdb_tgt_writesym(mdb_tgt_t *, mdb_tgt_as_t, const void *, size_t,
273 	const char *, const char *);
274 
275 /*
276  * Virtual Address Mapping and Load Object interface
277  *
278  * These interfaces allow the caller to iterate over the various virtual
279  * address space mappings, or only those mappings corresponding to load objects.
280  * The mapping name (MDB_TGT_MAPSZ) is defined to be large enough for a string
281  * of length MAXPATHLEN, plus space for "LM`<lmid>" where lmid is a hex number.
282  */
283 
284 #define	MDB_TGT_MAPSZ		1048	/* Maximum length of mapping name */
285 
286 #define	MDB_TGT_MAP_R		0x01	/* Mapping is readable */
287 #define	MDB_TGT_MAP_W		0x02	/* Mapping is writeable */
288 #define	MDB_TGT_MAP_X		0x04	/* Mapping is executable */
289 #define	MDB_TGT_MAP_SHMEM	0x08	/* Mapping is shared memory */
290 #define	MDB_TGT_MAP_STACK	0x10	/* Mapping is a stack of some kind */
291 #define	MDB_TGT_MAP_HEAP	0x20	/* Mapping is a heap of some kind */
292 #define	MDB_TGT_MAP_ANON	0x40	/* Mapping is anonymous memory */
293 
294 typedef struct mdb_map {
295 	char map_name[MDB_TGT_MAPSZ];	/* Name of mapped object */
296 	uintptr_t map_base;		/* Virtual address of base of mapping */
297 	size_t map_size;		/* Size of mapping in bytes */
298 	uint_t map_flags;		/* Flags (see above) */
299 } mdb_map_t;
300 
301 typedef int mdb_tgt_map_f(void *, const mdb_map_t *, const char *);
302 
303 extern int mdb_tgt_mapping_iter(mdb_tgt_t *, mdb_tgt_map_f *, void *);
304 extern int mdb_tgt_object_iter(mdb_tgt_t *, mdb_tgt_map_f *, void *);
305 
306 extern const mdb_map_t *mdb_tgt_addr_to_map(mdb_tgt_t *, uintptr_t);
307 extern const mdb_map_t *mdb_tgt_name_to_map(mdb_tgt_t *, const char *);
308 
309 extern struct ctf_file *mdb_tgt_addr_to_ctf(mdb_tgt_t *, uintptr_t);
310 extern struct ctf_file *mdb_tgt_name_to_ctf(mdb_tgt_t *, const char *);
311 
312 /*
313  * Execution Control Interface
314  *
315  * For in-situ debugging, we provide a relatively simple interface for target
316  * execution control.  The target can be continued, or the representative
317  * thread of control can be single-stepped.  Once the target has stopped, the
318  * status of the representative thread is returned (this status can also be
319  * obtained using mdb_tgt_status()).  Upon continue, the target's internal list
320  * of software event specifiers determines what types of events will cause the
321  * target to stop and transfer control back to the debugger.  The target
322  * allows any number of virtual event specifiers to be registered, along with
323  * an associated callback.  These virtual specifiers are layered on top of
324  * underlying software event specifiers that are private to the target.  The
325  * virtual event specifier list can be manipulated by the functions described
326  * below.  We currently support the following types of traced events:
327  * breakpoints, watchpoints, system call entry, system call exit, signals,
328  * and machine faults.
329  */
330 
331 typedef uintptr_t mdb_tgt_tid_t;	/* Opaque thread identifier */
332 
333 typedef struct mdb_tgt_status {
334 	mdb_tgt_tid_t st_tid;		/* Id of thread in question */
335 	uintptr_t st_pc;		/* Program counter, if stopped */
336 	uint_t st_state;		/* Program state (see below) */
337 	uint_t st_flags;		/* Status flags (see below) */
338 } mdb_tgt_status_t;
339 
340 /*
341  * Program state (st_state):
342  * (MDB_STATE_* definitions in the module API need to be in sync with these)
343  */
344 #define	MDB_TGT_IDLE		0	/* Target is idle (not running yet) */
345 #define	MDB_TGT_RUNNING		1	/* Target is currently executing */
346 #define	MDB_TGT_STOPPED		2	/* Target is stopped */
347 #define	MDB_TGT_UNDEAD		3	/* Target is undead (zombie) */
348 #define	MDB_TGT_DEAD		4	/* Target is dead (core dump) */
349 #define	MDB_TGT_LOST		5	/* Target lost by debugger */
350 
351 /*
352  * Status flags (st_flags):
353  */
354 #define	MDB_TGT_ISTOP		0x1	/* Stop on event of interest */
355 #define	MDB_TGT_DSTOP		0x2	/* Stop directive is pending */
356 #define	MDB_TGT_BUSY		0x4	/* Busy in debugger */
357 
358 extern int mdb_tgt_status(mdb_tgt_t *, mdb_tgt_status_t *);
359 extern int mdb_tgt_run(mdb_tgt_t *, int, const struct mdb_arg *);
360 extern int mdb_tgt_step(mdb_tgt_t *, mdb_tgt_status_t *);
361 extern int mdb_tgt_step_out(mdb_tgt_t *, mdb_tgt_status_t *);
362 extern int mdb_tgt_next(mdb_tgt_t *, mdb_tgt_status_t *);
363 extern int mdb_tgt_continue(mdb_tgt_t *, mdb_tgt_status_t *);
364 extern int mdb_tgt_signal(mdb_tgt_t *, int);
365 
366 /*
367  * Iterating through the specifier list yields the integer id (VID) and private
368  * data pointer for each specifier.
369  */
370 typedef int mdb_tgt_vespec_f(mdb_tgt_t *, void *, int, void *);
371 
372 /*
373  * Each event specifier is defined to be in one of the following states.  The
374  * state transitions are discussed in detail in the comments in mdb_target.c.
375  */
376 #define	MDB_TGT_SPEC_IDLE	1	/* Inactive (e.g. object not loaded) */
377 #define	MDB_TGT_SPEC_ACTIVE	2	/* Active but not armed in target */
378 #define	MDB_TGT_SPEC_ARMED	3	/* Active and armed (e.g. bkpt set) */
379 #define	MDB_TGT_SPEC_ERROR	4	/* Failed to arm event */
380 
381 /*
382  * Event specifiers may also have one or more of the following additional
383  * properties (spec_flags bits):
384  */
385 #define	MDB_TGT_SPEC_INTERNAL	0x0001	/* Internal to target implementation */
386 #define	MDB_TGT_SPEC_SILENT	0x0002	/* Do not describe when matched */
387 #define	MDB_TGT_SPEC_TEMPORARY	0x0004	/* Delete next time target stops */
388 #define	MDB_TGT_SPEC_MATCHED	0x0008	/* Specifier matched at last stop */
389 #define	MDB_TGT_SPEC_DISABLED	0x0010	/* Specifier cannot be armed */
390 #define	MDB_TGT_SPEC_DELETED	0x0020	/* Specifier has been deleted */
391 #define	MDB_TGT_SPEC_AUTODEL	0x0040	/* Delete when match limit reached */
392 #define	MDB_TGT_SPEC_AUTODIS	0x0080	/* Disable when match limit reached */
393 #define	MDB_TGT_SPEC_AUTOSTOP	0x0100	/* Stop when match limit reached */
394 #define	MDB_TGT_SPEC_STICKY	0x0200	/* Do not delete as part of :z */
395 
396 #define	MDB_TGT_SPEC_HIDDEN	(MDB_TGT_SPEC_INTERNAL | MDB_TGT_SPEC_SILENT)
397 
398 typedef struct mdb_tgt_spec_desc {
399 	int spec_id;			/* Event specifier id (VID) */
400 	uint_t spec_flags;		/* Flags (see above) */
401 	uint_t spec_hits;		/* Count of number of times matched */
402 	uint_t spec_limit;		/* Limit on number of times matched */
403 	int spec_state;			/* State (see above) */
404 	int spec_errno;			/* Last error code (if IDLE or ERROR) */
405 	uintptr_t spec_base;		/* Start of affected memory region */
406 	size_t spec_size;		/* Size of affected memory region */
407 	void *spec_data;		/* Callback private data */
408 } mdb_tgt_spec_desc_t;
409 
410 /*
411  * The target provides functions to convert a VID into the private data pointer,
412  * or a complete description of the event specifier and its state.
413  */
414 extern void *mdb_tgt_vespec_data(mdb_tgt_t *, int);
415 extern char *mdb_tgt_vespec_info(mdb_tgt_t *, int,
416     mdb_tgt_spec_desc_t *, char *, size_t);
417 
418 /*
419  * The common target layer provides functions to iterate over the list of
420  * registered event specifiers, modify or disable them, and delete them.
421  */
422 extern int mdb_tgt_vespec_iter(mdb_tgt_t *, mdb_tgt_vespec_f *, void *);
423 extern int mdb_tgt_vespec_modify(mdb_tgt_t *, int, uint_t, uint_t, void *);
424 extern int mdb_tgt_vespec_enable(mdb_tgt_t *, int);
425 extern int mdb_tgt_vespec_disable(mdb_tgt_t *, int);
426 extern int mdb_tgt_vespec_delete(mdb_tgt_t *, int);
427 
428 /*
429  * The mdb_tgt_add_* functions are used to add software event specifiers to the
430  * target.  The caller provides a bitmask of flags (spec_flags above), callback
431  * function pointer, and callback data as arguments.  Whenever a matching event
432  * is detected, a software event callback function is invoked.  The callback
433  * receives a pointer to the target, the VID of the corresponding event
434  * specifier, and a private data pointer as arguments.  If no callback is
435  * desired, the caller can specify a pointer to the no_se_f default callback.
436  * Unlike other target layer functions, the mdb_tgt_add_* interfaces return the
437  * VID of the new event (which may be positive or negative), or 0 if the new
438  * event could not be created.
439  */
440 typedef void mdb_tgt_se_f(mdb_tgt_t *, int, void *);
441 extern void no_se_f(mdb_tgt_t *, int, void *);
442 
443 /*
444  * Breakpoints can be set at a specified virtual address or using MDB's
445  * symbol notation:
446  */
447 extern int mdb_tgt_add_vbrkpt(mdb_tgt_t *, uintptr_t,
448     int, mdb_tgt_se_f *, void *);
449 
450 extern int mdb_tgt_add_sbrkpt(mdb_tgt_t *, const char *,
451     int, mdb_tgt_se_f *, void *);
452 
453 /*
454  * Watchpoints can be set at physical, virtual, or I/O port addresses for any
455  * combination of read, write, or execute operations.
456  */
457 #define	MDB_TGT_WA_R		0x1	/* Read watchpoint */
458 #define	MDB_TGT_WA_W		0x2	/* Write watchpoint */
459 #define	MDB_TGT_WA_X		0x4	/* Execute watchpoint */
460 
461 #define	MDB_TGT_WA_RWX	(MDB_TGT_WA_R | MDB_TGT_WA_W | MDB_TGT_WA_X)
462 
463 extern int mdb_tgt_add_pwapt(mdb_tgt_t *, physaddr_t, size_t, uint_t,
464     int, mdb_tgt_se_f *, void *);
465 
466 extern int mdb_tgt_add_vwapt(mdb_tgt_t *, uintptr_t, size_t, uint_t,
467     int, mdb_tgt_se_f *, void *);
468 
469 extern int mdb_tgt_add_iowapt(mdb_tgt_t *, uintptr_t, size_t, uint_t,
470     int, mdb_tgt_se_f *, void *);
471 
472 /*
473  * For user process debugging, tracepoints can be set on entry or exit from
474  * a system call, or on receipt of a software signal or fault.
475  */
476 extern int mdb_tgt_add_sysenter(mdb_tgt_t *, int, int, mdb_tgt_se_f *, void *);
477 extern int mdb_tgt_add_sysexit(mdb_tgt_t *, int, int, mdb_tgt_se_f *, void *);
478 extern int mdb_tgt_add_signal(mdb_tgt_t *, int, int, mdb_tgt_se_f *, void *);
479 extern int mdb_tgt_add_fault(mdb_tgt_t *, int, int, mdb_tgt_se_f *, void *);
480 
481 /*
482  * Machine Register Interface
483  *
484  * The machine registers for a given thread can be manipulated using the
485  * getareg and putareg interface; the caller must know the naming convention
486  * for registers for the given target architecture.  For the purposes of
487  * this interface, we declare the register container to be the largest
488  * current integer container.
489  */
490 
491 typedef uint64_t mdb_tgt_reg_t;
492 
493 extern int mdb_tgt_getareg(mdb_tgt_t *, mdb_tgt_tid_t,
494 	const char *, mdb_tgt_reg_t *);
495 
496 extern int mdb_tgt_putareg(mdb_tgt_t *, mdb_tgt_tid_t,
497 	const char *, mdb_tgt_reg_t);
498 
499 /*
500  * Thread name interface
501  *
502  * If the underlying target supports it, copy the thread name (if any) for the
503  * specified thread into the specified buffer.
504  */
505 
506 extern int mdb_tgt_thread_name(mdb_tgt_t *, mdb_tgt_tid_t, char *, size_t);
507 
508 /*
509  * Stack Interface
510  *
511  * The target stack interface provides the ability to iterate backward through
512  * the frames of an execution stack.  For the purposes of this interface, the
513  * mdb_tgt_gregset (general purpose register set) is an opaque type: there must
514  * be an implicit contract between the target implementation and any debugger
515  * modules that must interpret the contents of this structure.  The callback
516  * function is provided with the only elements of a stack frame which we can
517  * reasonably abstract: the virtual address corresponding to a program counter
518  * value, and an array of arguments passed to the function call represented by
519  * this frame.  The rest of the frame is presumed to be contained within the
520  * mdb_tgt_gregset_t, and is architecture-specific.
521  */
522 
523 typedef struct mdb_tgt_gregset mdb_tgt_gregset_t;
524 
525 typedef int mdb_tgt_stack_f(void *, uintptr_t, uint_t, const long *,
526 	const mdb_tgt_gregset_t *);
527 typedef int mdb_tgt_stack_iter_f(mdb_tgt_t *, const mdb_tgt_gregset_t *,
528 	mdb_tgt_stack_f *, void *);
529 
530 extern mdb_tgt_stack_iter_f mdb_tgt_stack_iter;
531 
532 /*
533  * External Data Interface
534  *
535  * The external data interface provides each target with the ability to export
536  * a set of named buffers that contain data which is associated with the
537  * target, but is somehow not accessible through one of its address spaces and
538  * does not correspond to a machine register.  A process credential is an
539  * example of such a buffer: the credential is associated with the given
540  * process, but is stored in the kernel (not the process's address space) and
541  * thus is not accessible through any other target interface.  Since it is
542  * exported via /proc, the user process target can export this information as a
543  * named buffer for target-specific dcmds to consume.
544  */
545 
546 typedef int mdb_tgt_xdata_f(void *, const char *, const char *, size_t);
547 
548 extern int mdb_tgt_xdata_iter(mdb_tgt_t *, mdb_tgt_xdata_f *, void *);
549 extern ssize_t mdb_tgt_getxdata(mdb_tgt_t *, const char *, void *, size_t);
550 
551 #ifdef	__cplusplus
552 }
553 #endif
554 
555 #endif	/* _MDB_TARGET_H */
556