Debugging a Program With dbx

dbx can debug multithreaded applications that use either Solaris threads or POSIX threads. With dbx, you can examine stack traces of each thread, resume all threads, step or next a specific thread, and navigate between threads.

dbx recognizes a multithreaded program by detecting whether it utilizes libthread.so. The program uses libthread.so either by explicitly being compiled with -lthread or -mt, or implicitly by being compiled with -lpthread.

This chapter describes how to find information about and debug threads using the dbx thread commands.

This chapter is organized into the following sections:

• Understanding Multithreaded Debugging
• Understanding LWP Information

---

Understanding Multithreaded Debugging

When it detects a multithreaded program, dbx tries to load libthread_db.so, a special system library for thread debugging located in /usr/lib.

dbx is synchronous; when any thread or lightweight process (LWP) stops, all other threads and LWPs sympathetically stop. This behavior is sometimes referred to as the "stop the world" model.

Thread Information

The following thread information is available in dbx:

(dbx) threads

    t@1 a l@1  ?()  running   in main()

    t@2      ?() asleep on 0xef751450  in_swtch()

    t@3 b l@2  ?()  running in sigwait()

    t@4     consumer()  asleep on 0x22bb0 in _lwp_sema_wait()

  *>t@5 b l@4 consumer()  breakpoint     in Queue_dequeue()

    t@6 b l@5 producer()     running       in _thread_start()

(dbx)

For native code, each line of information is composed of the following:

• The * (asterisk) indicates that an event requiring user attention has occurred in this thread. Usually this is a breakpoint.

An 'o' instead of an asterisk indicates that a dbx internal event has occurred.

• The > (arrow) denotes the current thread.
• t@number, the thread id, refers to a particular thread. The number is the thread_t value passed back by thr_create.
• b l@number or a l@number means the thread is bound to or active on the designated LWP, meaning the thread is actually runnable by the operating system.
• The "Start function" of the thread as passed to thr_create. A ?() means that the start function is not known.
• The thread state (See TABLE 11-1 for descriptions of the thread states.)
• The function that the thread is currently executing.

For Java code, each line of information is composed of the following:

• t@number, a dbx-style thread ID
• The thread state (See TABLE 11-1 for descriptions of the thread states.)
• The thread name in single quotation marks
• A number indicating the thread priority

Viewing the Context of Another Thread

To switch the viewing context to another thread, use the thread command. The syntax is:

thread [-blocks] [-blockedby] [-info] [-hide] [-unhide] [-suspend] [-resume] thread_id

To display the current thread, type:

thread

To switch to thread thread_id, type:

thread thread_id

For more information on the thread command, see thread Command.

Viewing the Threads List

To view the threads list, use the threads command. The syntax is:

threads [-all} [-mode [all|filter] [auto|manual]]

To print the list of all known threads, type:

threads

To print threads normally not printed (zombies), type:

threads -all

For an explanation of the threads list, see Thread Information.

For more information on the threads command, see threads Command.

Resuming Execution

Use the cont command to resume program execution. Currently, threads use synchronous breakpoints, so all threads resume execution.

---

Understanding Thread Creation Activity

You can get an idea of how often your application creates and destroys threads by using the thr_create event and thr_exit event as in the following example:

(dbx) trace thr_create

(dbx) trace thr_exit

(dbx) run

trace: thread created t@2 on l@2

trace: thread created t@3 on l@3

trace: thread created t@4 on l@4

trace: thr_exit t@4

trace: thr_exit t@3

trace: thr_exit t@2

Here the application created three threads. Note how the threads exited in reverse order from their creation, which might indicate that had the application had more threads, the threads would accumulate and consume resources.

To get more interesting information, you could try the following in a different session:

(dbx) when thr_create { echo "XXX thread $newthread created by $thread"; }

XXX thread t@2 created by t@1

XXX thread t@3 created by t@1

XXX thread t@4 created by t@1

The output shows that all three threads were created by thread t@1, which is a common multi-threading pattern.

Suppose you want to debug thread t@3 from its outset. You could stop the application at the point that thread t@3 is created as follows:

(dbx) stop thr_create t@3

(dbx) run

t@1 (l@1) stopped in tdb_event_create at 0xff38409c

0xff38409c: tdb_event_create       :    retl     

Current function is main

216       stat = (int) thr_create(NULL, 0, consumer, q, tflags, &tid_cons2);

(dbx)

If your application occasionally spawns a new thread but from thread t@5 instead of thread t@1, you could capture that event as follows:

(dbx) stop thr_create -thread t@5

---

Understanding LWP Information

Normally, you need not be aware of LWPs. There are times, however, when thread level queries cannot be completed. In these cases, use the lwps command to show information about LWPs.

(dbx) lwps

    l@1 running in main()

    l@2 running in sigwait()

    l@3 running in _lwp_sema_wait()

  *>l@4 breakpoint in Queue_dequeue()

    l@5 running in _thread_start()

(dbx)

Each line of the LWP list contains the following:

• The * (asterisk) indicates that an event requiring user attention has occurred in this LWP.
• The arrow denotes the current LWP.
• l@number refers to a particular LWP.
• The next item represents the LWP state.
• in function_name() identifies the function that the LWP is currently executing.

Debugging a Program With dbx

819-3683-10

Copyright © 2005, Sun Microsystems, Inc. All Rights Reserved.