include/thread_db.h

   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 (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #ifndef _THREAD_DB_H
  28 #define _THREAD_DB_H
  29
  30 /*
  31  *
  32  *  Description:
  33  *      Types, global variables, and function definitions for users
  34  *      of libc_db (formerly libthread_db).
  35  *
  36  */
  37
  38
  39 #include <sys/lwp.h>
  40 #include <sys/procfs_isa.h>
  41 #include <thread.h>
  42 #include <proc_service.h>
  43
  44 #ifdef __cplusplus
  45 extern "C" {
  46 #endif
  47
  48 #define         TD_THR_ANY_USER_FLAGS   0xffffffff
  49 #define         TD_THR_LOWEST_PRIORITY  -128
  50 #define         TD_SIGNO_MASK 0
  51 #define         TD_EVENTSIZE 2
  52
  53 /*
  54  * Opaque handle types.
  55  */
  56
  57 /* Client's handle for a process */
  58 struct ps_prochandle;
  59
  60 /* libthread's handle for a process */
  61 typedef struct td_thragent td_thragent_t;
  62
  63 /* The thread handle. */
  64 typedef struct td_thrhandle {
  65         td_thragent_t   *th_ta_p;
  66         psaddr_t        th_unique;
  67 } td_thrhandle_t;
  68
  69 /* The handle for a synchronization object. */
  70 typedef struct td_synchandle {
  71         td_thragent_t   *sh_ta_p;
  72         psaddr_t        sh_unique;
  73 } td_synchandle_t;
  74
  75 /* ------------------------------------------------------------------ */
  76
  77 /*
  78  * The libc_db event facility.
  79  */
  80 #define BT_UISHIFT      5 /* log base 2 of BT_NBIPUI, to extract word index */
  81 #define BT_NBIPUI       (1 << BT_UISHIFT)       /* n bits per uint */
  82 #define BT_UIMASK       (BT_NBIPUI - 1)         /* to extract bit index */
  83
  84 /* Bitmask of enabled events. */
  85 typedef struct td_thr_events {
  86         uint_t  event_bits[TD_EVENTSIZE];
  87 } td_thr_events_t;
  88
  89 /* Event set manipulation macros. */
  90 #define __td_eventmask(n)       ((unsigned int)1 << (((n) - 1)  \
  91                                     & (BT_NBIPUI - 1)))
  92 #define __td_eventword(n)       (((unsigned int)((n) - 1))>>5)
  93
  94 #define td_event_emptyset(setp)                         \
  95         {                                                               \
  96                 int _i_;                                                \
  97                 _i_ = TD_EVENTSIZE;                                     \
  98                 while (_i_) (setp)->event_bits[--_i_] = 0;      \
  99         }
 100
 101 #define td_event_fillset(setp)                          \
 102         {                                                               \
 103                 int _i_;                                                \
 104                 _i_ = TD_EVENTSIZE;                                     \
 105                 while (_i_) (setp)->event_bits[--_i_] = \
 106                         0xffffffff;                             \
 107         }
 108
 109 #define td_event_addset(setp, n)                        \
 110         (((setp)->event_bits[__td_eventword(n)]) |= __td_eventmask(n))
 111 #define td_event_delset(setp, n)                        \
 112         (((setp)->event_bits[__td_eventword(n)]) &= ~__td_eventmask(n))
 113 #define td_eventismember(setp, n)               \
 114         (__td_eventmask(n) & ((setp)->event_bits[__td_eventword(n)]))
 115 #define td_eventisempty(setp)                   \
 116         (!((setp)->event_bits[0]) && !((setp)->event_bits[1]))
 117
 118 typedef enum {
 119         TD_ALL_EVENTS,  /* pseudo-event number */
 120         TD_EVENT_NONE = TD_ALL_EVENTS,  /* depends on context */
 121         TD_READY,
 122         TD_SLEEP,
 123         TD_SWITCHTO,
 124         TD_SWITCHFROM,
 125         TD_LOCK_TRY,
 126         TD_CATCHSIG,
 127         TD_IDLE,
 128         TD_CREATE,
 129         TD_DEATH,
 130         TD_PREEMPT,
 131         TD_PRI_INHERIT,
 132         TD_REAP,
 133         TD_CONCURRENCY,
 134         TD_TIMEOUT,
 135         TD_MIN_EVENT_NUM = TD_READY,
 136         TD_MAX_EVENT_NUM = TD_TIMEOUT,
 137         TD_EVENTS_ENABLE = 31           /* Event reporting enabled */
 138 } td_event_e;
 139
 140 /*
 141  *   Ways that an event type can be reported.
 142  */
 143 typedef enum {
 144         NOTIFY_BPT,
 145                                 /*
 146                                  * bpt to be inserted at u.bptaddr by
 147                                  * debugger
 148                                  */
 149         NOTIFY_AUTOBPT,         /* bpt inserted at u.bptaddr by application */
 150         NOTIFY_SYSCALL          /* syscall u.syscallno will be invoked */
 151 } td_notify_e;
 152
 153 /*
 154  * How an event type is reported.
 155  */
 156 typedef struct td_notify {
 157         td_notify_e     type;
 158         union {
 159                 psaddr_t        bptaddr;
 160                 int             syscallno;
 161         } u;
 162 } td_notify_t;
 163
 164 /*
 165  * An event message.
 166  */
 167 typedef struct td_event_msg {
 168         td_event_e event;               /* Event type being reported */
 169         const td_thrhandle_t *th_p;     /* Thread reporting the event */
 170         union {                         /* Type-dependent event data */
 171                 td_synchandle_t *sh;    /* historical rubbish; ignore */
 172                 uintptr_t       data;   /* valid, depending on event type */
 173         } msg;
 174 } td_event_msg_t;
 175
 176 /* --------------------------------------------------------------------- */
 177
 178 /*
 179  * Thread information structure as returned by td_thr_get_info(), and
 180  * related types.
 181  */
 182
 183 /*
 184  * Possible thread states.  TD_THR_ANY_STATE is a pseudo-state used
 185  * to select threads regardless of state in td_ta_thr_iter().
 186  */
 187 typedef enum {
 188         TD_THR_ANY_STATE,
 189         TD_THR_UNKNOWN,
 190         TD_THR_STOPPED,
 191         TD_THR_RUN,
 192         TD_THR_ACTIVE,
 193         TD_THR_ZOMBIE,
 194         TD_THR_SLEEP,
 195         TD_THR_STOPPED_ASLEEP
 196 } td_thr_state_e;
 197
 198 /*
 199  * Thread type: user or system.
 200  * As of Solaris 9, all threads are type TD_THR_USER.
 201  */
 202 typedef enum {
 203         TD_THR_ANY_TYPE,        /* not used */
 204         TD_THR_USER,
 205         TD_THR_SYSTEM
 206 } td_thr_type_e;
 207
 208 typedef struct td_thrinfo {
 209         td_thragent_t   *ti_ta_p;       /* process handle */
 210         unsigned        ti_user_flags;  /* flags passed to thr_create() */
 211         thread_t        ti_tid;         /* tid returned by thr_create() */
 212         void            *ti_exitval;    /* thread exit value (TD_THR_ZOMBIE) */
 213         psaddr_t        ti_startfunc;   /* startfunc passed to thr_create() */
 214         psaddr_t        ti_stkbase;     /* base of thread's stack */
 215         long            ti_stksize;     /* size of thread's stack */
 216         psaddr_t        ti_ro_area;     /* address of uthread_t struct */
 217         int             ti_ro_size;     /* size of uthread_t struct */
 218         td_thr_state_e  ti_state;       /* thread state */
 219         uchar_t         ti_db_suspended; /* boolean:  suspended by debugger? */
 220         td_thr_type_e   ti_type;        /* thread type */
 221         intptr_t        ti_pc;          /* resume PC when sleeping */
 222         intptr_t        ti_sp;          /* resume SP when sleeping */
 223         short           ti_flags;       /* flags used by libthread */
 224         int             ti_pri;         /* thread priority */
 225         lwpid_t         ti_lid;         /* last LWP assigned to this thread */
 226         sigset_t        ti_sigmask;     /* signal mask */
 227         uchar_t         ti_traceme;     /* event reporting enabled? */
 228         uchar_t         ti_preemptflag; /* was thread preemppted? */
 229         uchar_t         ti_pirecflag;   /* priority inheritance happened */
 230         sigset_t        ti_pending;     /* set of pending signals */
 231         td_thr_events_t ti_events;      /* set of enabled events */
 232 } td_thrinfo_t;
 233
 234 #define ti_tls  ti_exitval      /* for source compatibility */
 235
 236 typedef struct td_ta_stats {
 237         int     nthreads;       /* total number of threads in use */
 238         int     r_concurrency;  /* requested concurrency level */
 239         int     nrunnable_num;  /* numerator, avg. runnable threads */
 240         int     nrunnable_den;  /* denominator, avg. runnable threads */
 241         int     a_concurrency_num; /* numerator, achieved concurrency level */
 242         int     a_concurrency_den; /* denominator,  concurrency level */
 243         int     nlwps_num;      /* numerator, average number of LWP's in use */
 244         int     nlwps_den;      /* denom., average number of LWP's in use */
 245         int     nidle_num;      /* numerator, avg. number of idling LWP's */
 246         int     nidle_den;      /* denom., avg. number of idling LWP's */
 247 } td_ta_stats_t;
 248
 249 /*
 250  * Iterator callback function declarations.
 251  */
 252
 253 /* Callback function for td_ta_tsd_iter(). */
 254 typedef int     td_key_iter_f(thread_key_t, void (*destructor)(), void *);
 255
 256 /* Callback function for td_ta_thr_iter(). */
 257 typedef int     td_thr_iter_f(const td_thrhandle_t *, void *);
 258
 259 /* Callback function for td_ta_sync_iter(). */
 260 typedef int     td_sync_iter_f(const td_synchandle_t *, void *);
 261
 262 /* -------------------------------------------------------------------- */
 263
 264 /*
 265  * Synchronization Objects
 266  */
 267
 268 /* Enumeration of synchronization object types. */
 269 typedef enum td_sync_type_e {
 270         TD_SYNC_UNKNOWN,        /* Sync. variable of unknown type  */
 271         TD_SYNC_COND,           /* Condition variable  */
 272         TD_SYNC_MUTEX,          /* Mutex lock  */
 273         TD_SYNC_SEMA,           /* Semaphore  */
 274         TD_SYNC_RWLOCK          /* Reader/Writer lock  */
 275 } td_sync_type_e;
 276
 277 #define TD_SV_MAX_FLAGS 4
 278 typedef uint8_t td_sync_flags_t;
 279
 280 /*
 281  * Synchronization object information structure filled in by td_sync_get_info()
 282  */
 283 typedef struct td_syncinfo {
 284         td_thragent_t   *si_ta_p;       /* process handle */
 285         psaddr_t        si_sv_addr;     /* address of sync. object */
 286         td_sync_type_e  si_type;        /* object type */
 287         uint32_t        si_shared_type; /* process-shared or process-private */
 288         td_sync_flags_t si_flags[TD_SV_MAX_FLAGS];      /* flags (?) */
 289         pid_t           si_ownerpid;    /* owner's process-id (USYNC_PROCESS) */
 290         union _si_un_state {
 291                 int     sem_count;      /* semaphore count */
 292                 int     nreaders;       /* number of readers, -1 if writer */
 293                 int     mutex_locked;   /* non-zero iff locked */
 294         } si_state;
 295         int             si_size;        /* size in bytes of synch variable */
 296         uint8_t         si_has_waiters; /* non-zero iff at least one waiter */
 297         uint8_t         si_is_wlock;    /* non-zero iff rwlock write-locked */
 298         uint8_t         si_rcount;      /* count for locked recursive mutex */
 299         uint8_t         si_prioceiling; /* ceiling pri (PTHREAD_PRIO_PROTECT) */
 300         td_thrhandle_t  si_owner;       /* mutex holder or write-lock holder */
 301         psaddr_t        si_data;        /* optional data */
 302 } td_syncinfo_t;
 303
 304 /*
 305  * Statistics structures for the various synchronization objects, contained
 306  * within the td_syncstats structure returned by td_sync_get_stats().
 307  */
 308 typedef struct {
 309         uint_t          mutex_lock;
 310         uint_t          mutex_sleep;
 311         hrtime_t        mutex_sleep_time;
 312         hrtime_t        mutex_hold_time;
 313         uint_t          mutex_try;
 314         uint_t          mutex_try_fail;
 315         uint_t          mutex_internal;         /* internal to libthread */
 316 } td_mutex_stats_t;
 317
 318 typedef struct {
 319         uint_t          cond_wait;
 320         uint_t          cond_timedwait;
 321         hrtime_t        cond_wait_sleep_time;
 322         hrtime_t        cond_timedwait_sleep_time;
 323         uint_t          cond_timedwait_timeout;
 324         uint_t          cond_signal;
 325         uint_t          cond_broadcast;
 326         uint_t          cond_internal;          /* internal to libthread */
 327 } td_cond_stats_t;
 328
 329 typedef struct {
 330         uint_t          rw_rdlock;
 331         uint_t          rw_rdlock_sleep;
 332         hrtime_t        rw_rdlock_sleep_time;
 333         uint_t          rw_rdlock_try;
 334         uint_t          rw_rdlock_try_fail;
 335         uint_t          rw_wrlock;
 336         uint_t          rw_wrlock_sleep;
 337         hrtime_t        rw_wrlock_sleep_time;
 338         hrtime_t        rw_wrlock_hold_time;
 339         uint_t          rw_wrlock_try;
 340         uint_t          rw_wrlock_try_fail;
 341 } td_rwlock_stats_t;
 342
 343 typedef struct {
 344         uint_t          sema_wait;
 345         uint_t          sema_wait_sleep;
 346         hrtime_t        sema_wait_sleep_time;
 347         uint_t          sema_trywait;
 348         uint_t          sema_trywait_fail;
 349         uint_t          sema_post;
 350         uint_t          sema_max_count;
 351         uint_t          sema_min_count;
 352 } td_sema_stats_t;
 353
 354 /*
 355  * Synchronization object statistics structure filled in by td_sync_get_stats()
 356  */
 357 typedef struct td_syncstats {
 358         td_syncinfo_t   ss_info;        /* as returned by td_sync_get_info() */
 359         union {
 360                 td_mutex_stats_t        mutex;
 361                 td_cond_stats_t         cond;
 362                 td_rwlock_stats_t       rwlock;
 363                 td_sema_stats_t         sema;
 364                 uint_t                  pad[32];        /* for future growth */
 365         } ss_un;
 366 } td_syncstats_t;
 367
 368 /* The set of error codes. */
 369 typedef enum {
 370         TD_OK,          /* generic "call succeeded" */
 371         TD_ERR,         /* generic error. */
 372         TD_NOTHR,       /* no thread can be found to satisfy query */
 373         TD_NOSV,        /* no synch. handle can be found to satisfy query */
 374         TD_NOLWP,       /* no lwp can be found to satisfy query */
 375         TD_BADPH,       /* invalid process handle */
 376         TD_BADTH,       /* invalid thread handle */
 377         TD_BADSH,       /* invalid synchronization handle */
 378         TD_BADTA,       /* invalid thread agent */
 379         TD_BADKEY,      /* invalid key */
 380         TD_NOMSG,       /* no event message for td_thr_event_getmsg() */
 381         TD_NOFPREGS,    /* FPU register set not available */
 382         TD_NOLIBTHREAD, /* application not linked with libthread */
 383         TD_NOEVENT,     /* requested event is not supported */
 384         TD_NOCAPAB,     /* capability not available */
 385         TD_DBERR,       /* Debugger service failed */
 386         TD_NOAPLIC,     /* Operation not applicable to */
 387         TD_NOTSD,       /* No thread-specific data for this thread */
 388         TD_MALLOC,      /* Malloc failed */
 389         TD_PARTIALREG,  /* Only part of register set was writen/read */
 390         TD_NOXREGS,     /* X register set not available for given thread */
 391         TD_NOTLS,       /* There is no TLS in the specified module */
 392         TD_TLSDEFER     /* module's TLS not yet allocated by the thread */
 393 }       td_err_e;
 394
 395
 396 /* ----------------------------------------------------------------------- */
 397
 398 /*
 399  * Exported functions.
 400  */
 401
 402 /*
 403  * Initialize the threads debug interface.
 404  */
 405 td_err_e
 406 td_init(void);
 407
 408 /*
 409  * A no-op, left for historical reasons.
 410  */
 411 void
 412 td_log(void);
 413
 414 /*
 415  * Allocate a new process handle ("thread agent").
 416  */
 417 td_err_e
 418 td_ta_new(struct ps_prochandle *, td_thragent_t **);
 419
 420 /*
 421  * De-allocate a process handle, releasing all related resources.
 422  */
 423 td_err_e
 424 td_ta_delete(td_thragent_t *);
 425
 426 /*
 427  * Map a process handle to a client process handle.
 428  */
 429 td_err_e
 430 td_ta_get_ph(const td_thragent_t *, struct ps_prochandle **);
 431
 432 /*
 433  * Set the process's suggested concurrency level.
 434  */
 435 td_err_e
 436 td_ta_setconcurrency(const td_thragent_t *, int);
 437
 438 /*
 439  * Get the number of threads in the process, including zombie threads.
 440  */
 441 td_err_e
 442 td_ta_get_nthreads(const td_thragent_t *, int *);
 443
 444 /*
 445  * Map a tid, as returned by thr_create(), to a thread handle.
 446  */
 447 td_err_e
 448 td_ta_map_id2thr(const td_thragent_t *, thread_t,  td_thrhandle_t *);
 449
 450 /*
 451  * Map the address of a synchronization object to a sync. object handle.
 452  */
 453 td_err_e
 454 td_ta_map_addr2sync(const td_thragent_t *, psaddr_t, td_synchandle_t *);
 455
 456 /*
 457  * Iterate over a process's thread-specific data (TSD) keys.
 458  */
 459 td_err_e
 460 td_ta_tsd_iter(const td_thragent_t *, td_key_iter_f *, void *);
 461
 462 /*
 463  * Iterate over a process's threads, including zombie threads.
 464  */
 465 td_err_e
 466 td_ta_thr_iter(const td_thragent_t *, td_thr_iter_f *, void *,
 467     td_thr_state_e, int, sigset_t *, unsigned);
 468
 469 /*
 470  * Iterate over a process's known synchronization objects.
 471  */
 472 td_err_e
 473 td_ta_sync_iter(const td_thragent_t *, td_sync_iter_f *, void *);
 474
 475 /*
 476  * Enable/disable process statistics collection.
 477  */
 478 td_err_e
 479 td_ta_enable_stats(const td_thragent_t *, int);
 480
 481 /*
 482  * Reset process statistics.
 483  */
 484 td_err_e
 485 td_ta_reset_stats(const td_thragent_t *);
 486
 487 /*
 488  * Read process statistics.
 489  */
 490 td_err_e
 491 td_ta_get_stats(const td_thragent_t *, td_ta_stats_t *);
 492
 493 /*
 494  * Get thread information.
 495  */
 496 td_err_e
 497 td_thr_get_info(const td_thrhandle_t *, td_thrinfo_t *);
 498
 499 /*
 500  * Get the "event address" for an event type.
 501  */
 502 td_err_e
 503 td_ta_event_addr(const td_thragent_t *, td_event_e, td_notify_t *);
 504
 505 /*
 506  * Enable/disable event reporting for a thread.
 507  */
 508 td_err_e
 509 td_thr_event_enable(const td_thrhandle_t *, int);
 510
 511 /*
 512  * Enable a set of events for a thread.
 513  */
 514 td_err_e
 515 td_thr_set_event(const td_thrhandle_t *, td_thr_events_t *);
 516
 517 /*
 518  * Disable a set of events for a thread.
 519  */
 520 td_err_e
 521 td_thr_clear_event(const td_thrhandle_t *, td_thr_events_t *);
 522
 523 /*
 524  * Retrieve (and consume) an event message for a thread.
 525  */
 526 td_err_e
 527 td_thr_event_getmsg(const td_thrhandle_t *, td_event_msg_t *);
 528
 529 /*
 530  * Enable a set of events in the process.
 531  */
 532 td_err_e
 533 td_ta_set_event(const td_thragent_t *, td_thr_events_t *);
 534
 535 /*
 536  * Disable a set of events in the process.
 537  */
 538 td_err_e
 539 td_ta_clear_event(const td_thragent_t *, td_thr_events_t *);
 540
 541 /*
 542  * Retrieve (and consume) an event message for some thread in the process.
 543  */
 544 td_err_e
 545 td_ta_event_getmsg(const td_thragent_t *, td_event_msg_t *);
 546
 547 /*
 548  * Suspend a thread.
 549  */
 550 td_err_e
 551 td_thr_dbsuspend(const td_thrhandle_t *);
 552
 553 /*
 554  * Resume a suspended thread.
 555  */
 556 td_err_e
 557 td_thr_dbresume(const td_thrhandle_t *);
 558
 559 /*
 560  * Set a thread's signal mask.
 561  */
 562 td_err_e
 563 td_thr_sigsetmask(const td_thrhandle_t *, const sigset_t);
 564
 565 /*
 566  * Set a thread's "signals-pending" set.
 567  */
 568 td_err_e
 569 td_thr_setsigpending(const td_thrhandle_t *, uchar_t, const sigset_t);
 570
 571 /*
 572  * Get a thread's general register set.
 573  */
 574 td_err_e
 575 td_thr_getgregs(const td_thrhandle_t *, prgregset_t);
 576
 577 /*
 578  * Set a thread's general register set.
 579  */
 580 td_err_e
 581 td_thr_setgregs(const td_thrhandle_t *, const prgregset_t);
 582
 583 /*
 584  * Get a thread's floating-point register set.
 585  */
 586 td_err_e
 587 td_thr_getfpregs(const td_thrhandle_t *, prfpregset_t *);
 588
 589 /*
 590  * Set a thread's floating-point register set.
 591  */
 592 td_err_e
 593 td_thr_setfpregs(const td_thrhandle_t *, const prfpregset_t *);
 594
 595 /*
 596  * Get the size of the extra state register set for this architecture.
 597  */
 598 td_err_e
 599 td_thr_getxregsize(const td_thrhandle_t *th_p, int *xregsize);
 600
 601 /*
 602  * Get a thread's extra state register set.
 603  */
 604 td_err_e
 605 td_thr_getxregs(const td_thrhandle_t *th_p, void *xregs);
 606
 607 /*
 608  * Set a thread's extra state register set.
 609  */
 610 td_err_e
 611 td_thr_setxregs(const td_thrhandle_t *th_p, const void *xregs);
 612
 613 /*
 614  * Validate a thread handle.
 615  */
 616 td_err_e
 617 td_thr_validate(const td_thrhandle_t *);
 618
 619 /*
 620  * Get a thread-specific data pointer for a thread.
 621  */
 622 td_err_e
 623 td_thr_tsd(const td_thrhandle_t *, thread_key_t, void **);
 624
 625 /*
 626  * Get the base address of a thread's thread local storage (TLS) block
 627  * for the module (executable or shared object) identified by 'moduleid'.
 628  */
 629 td_err_e
 630 td_thr_tlsbase(const td_thrhandle_t *, ulong_t moduleid, psaddr_t *base);
 631
 632 /*
 633  * Set a thread's priority.
 634  */
 635 td_err_e
 636 td_thr_setprio(const td_thrhandle_t *, int);
 637
 638 /*
 639  * Iterate over the set of locks owned by a thread.
 640  */
 641 td_err_e
 642 td_thr_lockowner(const td_thrhandle_t *, td_sync_iter_f *, void *);
 643
 644 /*
 645  * Return the sync. handle of the object this thread is sleeping on.
 646  */
 647 td_err_e
 648 td_thr_sleepinfo(const td_thrhandle_t *, td_synchandle_t *);
 649
 650 /*
 651  * Map an lwpid, as returned by _lwp_create(), to a thread handle.
 652  */
 653 td_err_e
 654 td_ta_map_lwp2thr(const td_thragent_t *, lwpid_t, td_thrhandle_t *th_p);
 655
 656 /*
 657  * Enable/disable a process's synchronization object tracking.
 658  */
 659 td_err_e
 660 td_ta_sync_tracking_enable(const td_thragent_t *, int);
 661
 662 /*
 663  * Get information about a synchronization object.
 664  */
 665 td_err_e
 666 td_sync_get_info(const td_synchandle_t *, td_syncinfo_t *);
 667
 668 /*
 669  * Get statistics for a synchronization object.
 670  */
 671 td_err_e
 672 td_sync_get_stats(const td_synchandle_t *, td_syncstats_t *);
 673
 674 /*
 675  * Set the state of a synchronization object.
 676  */
 677 td_err_e
 678 td_sync_setstate(const td_synchandle_t *, int value);
 679
 680 /*
 681  * Iterate over all threads blocked on a synchronization object.
 682  */
 683 td_err_e
 684 td_sync_waiters(const td_synchandle_t *, td_thr_iter_f *, void *);
 685
 686 #ifdef __cplusplus
 687 }
 688 #endif
 689
 690 #endif  /* _THREAD_DB_H */