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