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  */
  28 
  29 #ifndef _MDB_TARGET_H
  30 #define _MDB_TARGET_H
  31 
  32 #include <sys/utsname.h>
  33 #include <sys/types.h>
  34 #include <gelf.h>
  35 
  36 #ifdef  __cplusplus
  37 extern "C" {
  38 #endif
  39 
  40 /*
  41  * Forward declaration of the target structure: the target itself is defined in
  42  * mdb_tgt_impl.h and is opaque with respect to callers of this interface.
  43  */
  44 
  45 struct mdb_tgt;
  46 struct mdb_arg;
  47 struct ctf_file;
  48 
  49 typedef struct mdb_tgt mdb_tgt_t;
  50 
  51 extern void mdb_create_builtin_tgts(void);
  52 extern void mdb_create_loadable_disasms(void);
  53 
  54 /*
  55  * Target Constructors
  56  *
  57  * These functions are used to create a complete debugger target.  The
  58  * constructor is passed as an argument to mdb_tgt_create().
  59  */
  60 
  61 extern int mdb_value_tgt_create(mdb_tgt_t *, int, const char *[]);
  62 #ifndef _KMDB
  63 extern int mdb_kvm_tgt_create(mdb_tgt_t *, int, const char *[]);
  64 extern int mdb_proc_tgt_create(mdb_tgt_t *, int, const char *[]);
  65 extern int mdb_kproc_tgt_create(mdb_tgt_t *, int, const char *[]);
  66 extern int mdb_rawfile_tgt_create(mdb_tgt_t *, int, const char *[]);
  67 #else
  68 extern int kmdb_kvm_create(mdb_tgt_t *, int, const char *[]);
  69 #endif
  70 
  71 /*
  72  * Targets are created by calling mdb_tgt_create() with an optional set of
  73  * target flags, an argument list, and a target constructor (see above):
  74  */
  75 
  76 #define MDB_TGT_F_RDWR          0x0001  /* Open for writing (else read-only) */
  77 #define MDB_TGT_F_ALLOWIO       0x0002  /* Allow I/O mem access (live only) */
  78 #define MDB_TGT_F_FORCE         0x0004  /* Force open (even if non-exclusive) */
  79 #define MDB_TGT_F_PRELOAD       0x0008  /* Preload all symbol tables */
  80 #define MDB_TGT_F_NOLOAD        0x0010  /* Do not do load-object processing */
  81 #define MDB_TGT_F_NOSTOP        0x0020  /* Do not stop target on attach */
  82 #define MDB_TGT_F_STEP          0x0040  /* Single-step is pending */
  83 #define MDB_TGT_F_STEP_OUT      0x0080  /* Step-out is pending */
  84 #define MDB_TGT_F_NEXT          0x0100  /* Step-over is pending */
  85 #define MDB_TGT_F_CONT          0x0200  /* Continue is pending */
  86 #define MDB_TGT_F_BUSY          0x0400  /* Target is busy executing */
  87 #define MDB_TGT_F_ASIO          0x0800  /* Use t_aread and t_awrite for i/o */
  88 #define MDB_TGT_F_UNLOAD        0x1000  /* Unload has been requested */
  89 #define MDB_TGT_F_ALL           0x1fff  /* Mask of all valid flags */
  90 
  91 typedef int mdb_tgt_ctor_f(mdb_tgt_t *, int, const char *[]);
  92 
  93 extern mdb_tgt_t *mdb_tgt_create(mdb_tgt_ctor_f *, int, int, const char *[]);
  94 extern void mdb_tgt_destroy(mdb_tgt_t *);
  95 
  96 extern int mdb_tgt_getflags(mdb_tgt_t *);
  97 extern int mdb_tgt_setflags(mdb_tgt_t *, int);
  98 extern int mdb_tgt_setcontext(mdb_tgt_t *, void *);
  99 
 100 /*
 101  * Targets are activated and de-activated by the debugger framework.  An
 102  * activation occurs after construction when the target becomes the current
 103  * target in the debugger.  A target is de-activated prior to its destructor
 104  * being called by mdb_tgt_destroy, or when another target is activated.
 105  * These callbacks are suitable for loading support modules and other tasks.
 106  */
 107 extern void mdb_tgt_activate(mdb_tgt_t *);
 108 
 109 /*
 110  * Prior to issuing a new command prompt, the debugger framework calls the
 111  * target's periodic callback to allow it to load new modules or perform
 112  * other background tasks.
 113  */
 114 extern void mdb_tgt_periodic(mdb_tgt_t *);
 115 
 116 /*
 117  * Convenience functions for accessing miscellaneous target information.
 118  */
 119 extern const char *mdb_tgt_name(mdb_tgt_t *);
 120 extern const char *mdb_tgt_isa(mdb_tgt_t *);
 121 extern const char *mdb_tgt_platform(mdb_tgt_t *);
 122 extern int mdb_tgt_uname(mdb_tgt_t *, struct utsname *);
 123 extern int mdb_tgt_dmodel(mdb_tgt_t *);
 124 
 125 /*
 126  * Address Space Interface
 127  *
 128  * Each target can provide access to a set of address spaces, which may include
 129  * a primary virtual address space, a physical address space, an object file
 130  * address space (where virtual addresses are converted to file offsets in an
 131  * object file), and an I/O port address space.  Additionally, the target can
 132  * provide access to alternate address spaces, which are identified by the
 133  * opaque mdb_tgt_as_t type.  If the 'as' parameter to mdb_tgt_aread or
 134  * mdb_tgt_awrite is one of the listed constants, these calls are equivalent
 135  * to mdb_tgt_{v|p|f|io}read or write.
 136  */
 137 
 138 typedef void *          mdb_tgt_as_t;           /* Opaque address space id */
 139 typedef uint64_t        mdb_tgt_addr_t;         /* Generic unsigned address */
 140 typedef uint64_t        physaddr_t;             /* Physical memory address */
 141 
 142 #define MDB_TGT_AS_VIRT ((mdb_tgt_as_t)-1L)     /* Virtual address space */
 143 #define MDB_TGT_AS_PHYS ((mdb_tgt_as_t)-2L)     /* Physical address space */
 144 #define MDB_TGT_AS_FILE ((mdb_tgt_as_t)-3L)     /* Object file address space */
 145 #define MDB_TGT_AS_IO   ((mdb_tgt_as_t)-4L)     /* I/o address space */
 146 
 147 extern ssize_t mdb_tgt_aread(mdb_tgt_t *, mdb_tgt_as_t,
 148         void *, size_t, mdb_tgt_addr_t);
 149 
 150 extern ssize_t mdb_tgt_awrite(mdb_tgt_t *, mdb_tgt_as_t,
 151         const void *, size_t, mdb_tgt_addr_t);
 152 
 153 extern ssize_t mdb_tgt_vread(mdb_tgt_t *, void *, size_t, uintptr_t);
 154 extern ssize_t mdb_tgt_vwrite(mdb_tgt_t *, const void *, size_t, uintptr_t);
 155 extern ssize_t mdb_tgt_pread(mdb_tgt_t *, void *, size_t, physaddr_t);
 156 extern ssize_t mdb_tgt_pwrite(mdb_tgt_t *, const void *, size_t, physaddr_t);
 157 extern ssize_t mdb_tgt_fread(mdb_tgt_t *, void *, size_t, uintptr_t);
 158 extern ssize_t mdb_tgt_fwrite(mdb_tgt_t *, const void *, size_t, uintptr_t);
 159 extern ssize_t mdb_tgt_ioread(mdb_tgt_t *, void *, size_t, uintptr_t);
 160 extern ssize_t mdb_tgt_iowrite(mdb_tgt_t *, const void *, size_t, uintptr_t);
 161 
 162 /*
 163  * Convert an address-space's virtual address to the corresponding
 164  * physical address (only useful for kernel targets):
 165  */
 166 extern int mdb_tgt_vtop(mdb_tgt_t *, mdb_tgt_as_t, uintptr_t, physaddr_t *);
 167 
 168 /*
 169  * Convenience functions for reading and writing null-terminated
 170  * strings from any of the target address spaces:
 171  */
 172 extern ssize_t mdb_tgt_readstr(mdb_tgt_t *, mdb_tgt_as_t,
 173         char *, size_t, mdb_tgt_addr_t);
 174 
 175 extern ssize_t mdb_tgt_writestr(mdb_tgt_t *, mdb_tgt_as_t,
 176         const char *, mdb_tgt_addr_t);
 177 
 178 /*
 179  * Symbol Table Interface
 180  *
 181  * Each target can provide access to one or more symbol tables, which can be
 182  * iterated over, or used to lookup symbols by either name or address.  The
 183  * target can support a primary executable and primary dynamic symbol table,
 184  * a symbol table for its run-time link-editor, and symbol tables for one or
 185  * more loaded objects.  A symbol is uniquely identified by an object name,
 186  * a symbol table id, and a symbol id.  Symbols can be discovered by iterating
 187  * over them, looking them up by name, or looking them up by address.
 188  */
 189 
 190 typedef struct mdb_syminfo {
 191         uint_t sym_table;       /* Symbol table id (see symbol_iter, below) */
 192         uint_t sym_id;          /* Symbol identifier */
 193 } mdb_syminfo_t;
 194 
 195 /*
 196  * Reserved object names for mdb_tgt_lookup_by_name():
 197  */
 198 #define MDB_TGT_OBJ_EXEC        ((const char *)0L)      /* Executable symbols */
 199 #define MDB_TGT_OBJ_RTLD        ((const char *)1L)      /* Ldso/krtld symbols */
 200 #define MDB_TGT_OBJ_EVERY       ((const char *)-1L)     /* All known symbols */
 201 
 202 extern int mdb_tgt_lookup_by_scope(mdb_tgt_t *, const char *,
 203         GElf_Sym *, mdb_syminfo_t *);
 204 
 205 extern int mdb_tgt_lookup_by_name(mdb_tgt_t *, const char *,
 206         const char *, GElf_Sym *, mdb_syminfo_t *);
 207 
 208 /*
 209  * Flag bit passed to mdb_tgt_lookup_by_addr():
 210  */
 211 #define MDB_TGT_SYM_FUZZY       0       /* Match closest address */
 212 #define MDB_TGT_SYM_EXACT       1       /* Match exact address only */
 213 
 214 #define MDB_TGT_SYM_NAMLEN      1024    /* Recommended max symbol name length */
 215 
 216 extern int mdb_tgt_lookup_by_addr(mdb_tgt_t *, uintptr_t, uint_t,
 217         char *, size_t, GElf_Sym *, mdb_syminfo_t *);
 218 
 219 /*
 220  * Callback function prototype for mdb_tgt_symbol_iter():
 221  */
 222 typedef int mdb_tgt_sym_f(void *, const GElf_Sym *, const char *,
 223         const mdb_syminfo_t *sip, const char *);
 224 
 225 /*
 226  * Values for selecting symbol tables with mdb_tgt_symbol_iter():
 227  */
 228 #define MDB_TGT_PRVSYM          0       /* User's private symbol table */
 229 #define MDB_TGT_SYMTAB          1       /* Normal symbol table (.symtab) */
 230 #define MDB_TGT_DYNSYM          2       /* Dynamic symbol table (.dynsym) */
 231 
 232 /*
 233  * Values for selecting symbols of interest by binding and type.  These flags
 234  * can be used to construct a bitmask to pass to mdb_tgt_symbol_iter().  The
 235  * module API has its own slightly different names for these values.  If you are
 236  * adding a new flag here, you should consider exposing it in the module API.
 237  * If you are changing these flags and their meanings, you will need to update
 238  * the module API implementation to account for those changes.
 239  */
 240 #define MDB_TGT_BIND_LOCAL      0x0001  /* Local (static-scope) symbols */
 241 #define MDB_TGT_BIND_GLOBAL     0x0002  /* Global symbols */
 242 #define MDB_TGT_BIND_WEAK       0x0004  /* Weak binding symbols */
 243 
 244 #define MDB_TGT_BIND_ANY        0x0007  /* Any of the above */
 245 
 246 #define MDB_TGT_TYPE_NOTYPE     0x0100  /* Symbol has no type */
 247 #define MDB_TGT_TYPE_OBJECT     0x0200  /* Symbol refers to data */
 248 #define MDB_TGT_TYPE_FUNC       0x0400  /* Symbol refers to text */
 249 #define MDB_TGT_TYPE_SECT       0x0800  /* Symbol refers to a section */
 250 #define MDB_TGT_TYPE_FILE       0x1000  /* Symbol refers to a source file */
 251 #define MDB_TGT_TYPE_COMMON     0x2000  /* Symbol refers to a common block */
 252 #define MDB_TGT_TYPE_TLS        0x4000  /* Symbol refers to TLS */
 253 
 254 #define MDB_TGT_TYPE_ANY        0x7f00  /* Any of the above */
 255 
 256 extern int mdb_tgt_symbol_iter(mdb_tgt_t *, const char *, uint_t, uint_t,
 257         mdb_tgt_sym_f *, void *);
 258 
 259 /*
 260  * Convenience functions for reading and writing at the address specified
 261  * by a given object file and symbol name:
 262  */
 263 extern ssize_t mdb_tgt_readsym(mdb_tgt_t *, mdb_tgt_as_t, void *, size_t,
 264         const char *, const char *);
 265 
 266 extern ssize_t mdb_tgt_writesym(mdb_tgt_t *, mdb_tgt_as_t, const void *, size_t,
 267         const char *, const char *);
 268 
 269 /*
 270  * Virtual Address Mapping and Load Object interface
 271  *
 272  * These interfaces allow the caller to iterate over the various virtual
 273  * address space mappings, or only those mappings corresponding to load objects.
 274  * The mapping name (MDB_TGT_MAPSZ) is defined to be large enough for a string
 275  * of length MAXPATHLEN, plus space for "LM`<lmid>" where lmid is a hex number.
 276  */
 277 
 278 #define MDB_TGT_MAPSZ           1048    /* Maximum length of mapping name */
 279 
 280 #define MDB_TGT_MAP_R           0x01    /* Mapping is readable */
 281 #define MDB_TGT_MAP_W           0x02    /* Mapping is writeable */
 282 #define MDB_TGT_MAP_X           0x04    /* Mapping is executable */
 283 #define MDB_TGT_MAP_SHMEM       0x08    /* Mapping is shared memory */
 284 #define MDB_TGT_MAP_STACK       0x10    /* Mapping is a stack of some kind */
 285 #define MDB_TGT_MAP_HEAP        0x20    /* Mapping is a heap of some kind */
 286 #define MDB_TGT_MAP_ANON        0x40    /* Mapping is anonymous memory */
 287 
 288 typedef struct mdb_map {
 289         char map_name[MDB_TGT_MAPSZ];   /* Name of mapped object */
 290         uintptr_t map_base;             /* Virtual address of base of mapping */
 291         size_t map_size;                /* Size of mapping in bytes */
 292         uint_t map_flags;               /* Flags (see above) */
 293 } mdb_map_t;
 294 
 295 typedef int mdb_tgt_map_f(void *, const mdb_map_t *, const char *);
 296 
 297 extern int mdb_tgt_mapping_iter(mdb_tgt_t *, mdb_tgt_map_f *, void *);
 298 extern int mdb_tgt_object_iter(mdb_tgt_t *, mdb_tgt_map_f *, void *);
 299 
 300 extern const mdb_map_t *mdb_tgt_addr_to_map(mdb_tgt_t *, uintptr_t);
 301 extern const mdb_map_t *mdb_tgt_name_to_map(mdb_tgt_t *, const char *);
 302 
 303 extern struct ctf_file *mdb_tgt_addr_to_ctf(mdb_tgt_t *, uintptr_t);
 304 extern struct ctf_file *mdb_tgt_name_to_ctf(mdb_tgt_t *, const char *);
 305 
 306 /*
 307  * Execution Control Interface
 308  *
 309  * For in-situ debugging, we provide a relatively simple interface for target
 310  * execution control.  The target can be continued, or the representative
 311  * thread of control can be single-stepped.  Once the target has stopped, the
 312  * status of the representative thread is returned (this status can also be
 313  * obtained using mdb_tgt_status()).  Upon continue, the target's internal list
 314  * of software event specifiers determines what types of events will cause the
 315  * target to stop and transfer control back to the debugger.  The target
 316  * allows any number of virtual event specifiers to be registered, along with
 317  * an associated callback.  These virtual specifiers are layered on top of
 318  * underlying software event specifiers that are private to the target.  The
 319  * virtual event specifier list can be manipulated by the functions described
 320  * below.  We currently support the following types of traced events:
 321  * breakpoints, watchpoints, system call entry, system call exit, signals,
 322  * and machine faults.
 323  */
 324 
 325 typedef uintptr_t mdb_tgt_tid_t;        /* Opaque thread identifier */
 326 
 327 typedef struct mdb_tgt_status {
 328         mdb_tgt_tid_t st_tid;           /* Id of thread in question */
 329         uintptr_t st_pc;                /* Program counter, if stopped */
 330         uint_t st_state;                /* Program state (see below) */
 331         uint_t st_flags;                /* Status flags (see below) */
 332 } mdb_tgt_status_t;
 333 
 334 /*
 335  * Program state (st_state):
 336  * (MDB_STATE_* definitions in the module API need to be in sync with these)
 337  */
 338 #define MDB_TGT_IDLE            0       /* Target is idle (not running yet) */
 339 #define MDB_TGT_RUNNING         1       /* Target is currently executing */
 340 #define MDB_TGT_STOPPED         2       /* Target is stopped */
 341 #define MDB_TGT_UNDEAD          3       /* Target is undead (zombie) */
 342 #define MDB_TGT_DEAD            4       /* Target is dead (core dump) */
 343 #define MDB_TGT_LOST            5       /* Target lost by debugger */
 344 
 345 /*
 346  * Status flags (st_flags):
 347  */
 348 #define MDB_TGT_ISTOP           0x1     /* Stop on event of interest */
 349 #define MDB_TGT_DSTOP           0x2     /* Stop directive is pending */
 350 #define MDB_TGT_BUSY            0x4     /* Busy in debugger */
 351 
 352 extern int mdb_tgt_status(mdb_tgt_t *, mdb_tgt_status_t *);
 353 extern int mdb_tgt_run(mdb_tgt_t *, int, const struct mdb_arg *);
 354 extern int mdb_tgt_step(mdb_tgt_t *, mdb_tgt_status_t *);
 355 extern int mdb_tgt_step_out(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 */