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