proc lwpsinfo_t
Structure
Several proc
probes have arguments of type lwpsinfo_t
. The definition of the lwpsinfo_t
structure as available to DTrace consumers is as follows:
typedef struct lwpsinfo { int pr_flag; /* flags; see below */ id_t pr_lwpid; /* LWP id */ uintptr_t pr_addr; /* internal address of thread */ uintptr_t pr_wchan; /* wait addr for sleeping thread */ char pr_stype; /* synchronization event type */ char pr_state; /* numeric thread state */ char pr_sname; /* printable character for pr_state */ char pr_nice; /* nice for cpu usage */ short pr_syscall; /* system call number (if in syscall) */ int pr_pri; /* priority, high value = high priority */ char pr_clname[PRCLSZ]; /* scheduling class name */ processorid_t pr_onpro; /* processor which last ran this thread */ processorid_t pr_bindpro; /* processor to which thread is bound */ psetid_t pr_bindpset; /* processor set to which thread is bound */ } lwpsinfo_t;
The pr_flag
field is a bit-mask holding flags describing the process. These flags and their meanings are described in Table 11-25.
Table 11-25 proc pr_flag
Values
Flags | Descriptions |
---|---|
|
The process is a system process. |
|
The process is the parent of a |
|
The process has its inherit-on-fork mode set. |
|
The process has its run-on-last-close mode set. |
|
The process has its kill-on-last-close mode set. |
|
The process has its asynchronous-stop mode set. |
|
The process has microstate accounting enabled. |
|
The process microstate accounting is inherited on fork. |
|
The process has its breakpoint adjustment mode set. |
|
The process has its |
|
The thread is an LWP that is stopped. |
|
The thread is an LWP stopped on an event of interest. |
|
The thread is an LWP that has a stop directive in effect. |
|
The thread is an LWP that has a single-step directive in effect. |
|
The thread is an LWP in an interruptible sleep within a system call. |
|
The thread is a detached LWP. See the |
|
The thread is a daemon LWP. See the |
|
The thread is the agent LWP for the process. |
|
The thread is the idle thread for a CPU. Idle threads only run on a CPU when the run queues for the CPU are empty. |
The pr_addr
field is the address of a private, in-kernel data structure representing the thread. While the data structure is private, the pr_addr
field may be used as a token unique to a thread for the thread's lifetime.
The pr_wchan
field is set when the thread is sleeping on a synchronization object. The meaning of the pr_wchan
field is private to the kernel implementation, but the field may be used as a token unique to the synchronization object.
The pr_stype
field is set when the thread is sleeping on a synchronization object. The following table describes the possible values for the pr_stype
field.
Table 11-26 proc pr_stype
Values
Value | Description |
---|---|
|
Kernel mutex synchronization object. Used to serialize access to shared data regions in the kernel. For more information about kernel mutex synchronization objects, see lockstat Stability and the |
|
Kernel readers/writer synchronization object. Used to synchronize access to shared objects in the kernel that can allow multiple concurrent readers or a single writer. For more information about kernel readers/writer synchronization objects, see lockstat Stability and the |
|
Condition variable synchronization object. A condition variable is designed to wait indefinitely until some condition becomes true. Condition variables are typically used to synchronize for reasons other than access to a shared data region, and are the mechanism generally used when a process performs a program-directed indefinite wait. For example, blocking in |
|
Semaphore synchronization object. A general-purpose synchronization object that – like condition variable objects – does not track a notion of ownership. Because ownership is required to implement priority inheritance in the Oracle Solaris kernel, the lack of ownership inherent in semaphore objects inhibits their widespread use. See the |
|
A user-level synchronization object. All blocking on user-level synchronization objects is handled with |
|
A user-level synchronization object that implements priority inheritance. Some user-level synchronization objects that track ownership additionally allow for priority inheritance. For example, mutex objects created with |
|
A shuttle synchronization object. Shuttle objects are used to implement doors. See |
The pr_state
field is set to one of the values in Table 11-27. The pr_sname
field is set to a corresponding character shown in parentheses in the same table.
Table 11-27 proc pr_state
Values
Value | Description |
---|---|
|
The thread is sleeping. The |
|
The thread is runnable, but is not currently running. The |
|
The thread is a zombie LWP. |
|
The thread is stopped, either due to an explicit |
|
The thread is an intermediate state during process creation. |
|
The thread is running on a CPU. The |
|
The thread is waiting on wait queue. The |