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