vt (SDM)

Displays information about an INtime kernel object.

vt handle

Parameters

handle: The handle of the object for which you want to display information.

Remarks

The vt command determines the type of INtime kernel object represented by the handle and displays information about that object. The information and the format in which SDM displays the information depends on the type of object.

These sections are divided into display groups illustrating the display format for these INtime kernel objects:

Processes
Threads
Mailboxes
Semaphores
Regions

Process display

If the parameter you specify is a valid process handle, SDM displays information about the process having that handle, as the sample display shows:

Object type = 1  Process
Current_threads xxxx           Max_threads  xxxx      Max_priority    xx
Current_objects xxxx           Max_objects  xxxx      Parameter_obj   xxxx
Directory_size  xxxx           Entries_used xxxx      Process_flags   xxxx
Except_handler  xxxx:xxxxxxxx  Except_mode  xx        Parent_process  xxxx
Pool_min        xxxxxxxx       Pool_max     xxxxxxxx  Initial_size    xxxxxxxx
Borrowed        xxxxxxxx       Allocated    xxxxxxxx
CR3             xxxxxxxx       Page Dir     xxxx:xxxxxxxx
Flat DS/CS      xxxx/xxxx
Process Name    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

RSLs: Act RVA  Entry    Name
1d78: 00072000 00082e40 RtRsl.rsl
1d68: 00020000 0003fd30 clib.rsl

The table in the lower half of the display is the Free Space Table.

The display fields from left to right are:

Current_threads

The number of threads currently existing in the process. If the Max threads is not 0FFFFH (no limit), the number of Current threads is equal to the Current threads of this process plus all its children Max threads.

Max_threads

The maximum number of threads that can exist in the process simultaneously. This value was set when the process was created.

Max_priority

The maximum (numerically lowest) priority allowed for any one thread in the process. This value was set when the process was created.

Current_objects

The number of objects currently existing in the process.

Max_objects

The maximum number of objects that can exist in the process simultaneously. This value was set when the process was created.

Parameter_obj

The handle for the object that the parent process passed to this process. This value was set when the process was created.

Directory_size

The maximum number of entries the process can have in its object directory. This value was set when the process was created via the INtime RT Loader.

Entries_used

The number of objects now cataloged in the process's object directory.

Process_flags

The Process flags parameter value that was set when the process was created. A value of 0 (zero) indicates the kernel does parameter checking for system calls made from the process. The value 2H indicates parameter checking is not done unless a parent process has parameter checking set.

Except_handler

The start address of the process's exception handler. This address was set when the process was created.

Except_mode

Indicates when control is to be passed to the new process's exception handler. This value was set when the process was created.

Vaue	When control passes
0	Never
1	On programmer errors
2	On environmental conditions
3	On all exceptions

Parent_process

The handle for the specified process's parent.

Pool_min

The minimum size of the process's memory pool, in 16-byte paragraphs. This value was set when the process was created.

Pool_max

The maximum size of the process's memory pool, in 16-byte paragraphs. This value was set when the process was created.

Initial_size

The initial size of the process's memory pool, in 16-byte paragraphs.

Borrowed

The current amount of memory that the process has borrowed from its ancestor(s), in 16-byte paragraphs.

Allocated

The current amount of memory that the process has allocated form its own local pool (pool min). The total memory allocated to the process is Allocated+Borrowed.

Process Name

The name of the process as contained in the processes object directory cataloged as R?H$C$NAME. If the object does not exist, has a length of zero, or is a null handle, this field does not display.

RSLs

List of RSLs currently linked to process. Each entry shows the RSL's handle, the actual RVA (offset in the process VSEG) where it is loaded, its entry point and name.

Thread display

SDM displays information about threads in different ways for interrupt threads and for non-interrupt threads.

This sample shows the display for non-interrupt threads:

Object type = 2  Thread
  Static pri     xx             Dynamic pri    xx       Thread state   xxxxxxxxx
  Suspend depth  xx             Delay req      xxxx     Last exchange    xxxx
  Except handler xxxx:xxxxxxxx  Except mode    xx       Thread flags     xx
  SEH Start      xxxxxxxx       SEH active     xx       SEH trans      xxxxxxxx
  K-saved SS:SP  xxxx:xxxxxxxx  Container proc xxxx     Interrupt thread no
  K-Delay        xxxxxxxx       K-Last exch.   xxxxxxxx LastRtError      xxxx
  SEH_Lin        xxxxxxxx       TLS array      xxxxxxxx

The display for interrupt threads is the same as for non-interrupt threads but with this added:

  Int level      xx              Master mask    xx    Slave mask     xx
  Pending int    xx              Max interrupts xx

These are the fields for both interrupt and non-interrupt displays, from left to right:

Static pri

The maximum priority value of the thread. This value was set by the max priority parameter when the thread's containing process was created with CreateRtThread.

Dynamic pri

A temporary priority that the kernel assigns to the thread when it controls a region and a higher priority thread wants control.

Thread state

The state of the thread. These are the twelve possible states, as they are displayed:

State	Description
ready	Thread is ready for execution
asleep	Thread is asleep
susp	Thread is suspended
aslp/susp	Thread is asleep and suspended
deleted	Thread is being deleted
on exch Q	Thread is waiting at an exchange
aslp/exch	Thread is asleep waiting at an exchange
sl/xc/susp	Thread is asleep and suspended waiting at an exchange
on port Q	Thread is queued at a port
aslp/port	Thread is asleep waiting at a port
on trans Q	Thread is queued at a port on transaction queue
aslp/trans	Thread is asleep and queued at a port on the transaction queue

Suspend depth

The number of SuspendRtThread. Kernel system calls that have been applied to this thread without a corresponding ResumeRtThread.

Delay req

The number of sleep units the thread requested when it last specified a delay at a mailbox or semaphore, or when it last called the RtSleep. If the thread has not done any of these, this field contains zeros.

Last exchange

The handle for the mailbox, region, or semaphore at which the thread most recently began to wait.

Except handler

The start address of the process's default exception handler. This value was set with either CreateRtThread or SetRtExceptionHandler.

Except mode

The value that indicates the exceptional conditions under which control is to be passed to the new thread's exception handler. This value was set with CreateRtThread or SetRtExceptionHandler.

Thread flags

The thread flags parameter used when the thread was created with CreateRtThread. The value 1H indicates the thread contains floating-point instructions; the value 0 indicates it does not.

K-saved SS:SP

The contents of the SS:SP registers when the thread last left the ready state.

Containing process

The handle of the process to which this thread belongs.

Interrupt thread

Indicates whether this thread is an interrupt thread.

No signifies that the thread is not an interrupt thread. If so, this is the last field in the display. See the sample display for non-interrupt threads.

Yes signifies that the thread is an interrupt thread. In this case, additional fields appear in the display. See the sample display for interrupt threads.

Int level

The level that the interrupt thread services. This level was set when this thread called SignalEndOfRtInterrupt.

SEH Lin

Linear address of this thread's SEH area

TLS array

Linear address of this thread's TLS array

Pending int

The number of WaitForRtInterrupt calls pending for the interrupt level.

Max interrupts

The maximum number of WaitForRtInterrupt calls that can be pending for the interrupt level.

Mailbox display

SDM displays information about mailboxes in these ways:

When nothing is queued at the mailbox
When threads are queued at the mailbox
When objects are queued at the mailbox
When data messages are queued at the mailbox

This is the format of the display when nothing is queued at the mailbox:

Object type = 3  Mailbox

Mailbox type        xxxxxx    Thread queue head     xxxx
        Queue discipline    xxxx      Object queue head   0000
        Containing process      xxxx      Object cache depth  xx

When there are threads queued at the mailbox, this line is added:

Thread queue      zzzz  xxxx  ...

When there are objects queued at the mailbox, this line is added:

Object cache queue      zzzz  xxxx  ...
Object overflow queue   xxxx  xxxx  ...

When there are data messages queued at the mailbox, this line is added:

Data message queue xxxx:xxxxxxxx  xxxx:xxxxxxxx  xxxx:xxxxxxxx
                   xxxx:xxxxxxxx  xxxx:xxxxxxxx   ...

The field descriptions follow:

Mailbox type: The type of mailbox: object or data. This is defined when the mailbox is created.
Thread queue head: The handle for the thread at the head of the queue. If the thread queue for this mailbox is empty, this field contains the mailbox handle.
Object queue head: The handle for the object at the head of the queue. If the object queue for this mailbox is empty, this field contains 0000. If the mailbox type is Data, this field contains N/A.
Data queue head: The pointer for the first data message at the head of the message queue.
Queue discipline: Indicates how threads are queued at the mailbox. Threads are queued as FIFO (first-in-first-out) or by PRI (priority). This is specified when a mailbox is created with CreateRtMailbox. If the field cannot be interpreted, the actual value is displayed followed by a space and two question marks.
Containing process: The handle for the process that contains this mailbox.
Object cache depth: The size of the high-performance cache portion of the object queue associated with the mailbox. This size was specified when the mailbox was created. If the mailbox type is Data, this field contains N/A.
Data message queue: Pointers for the data messages residing at the mailbox.
Thread queue: A list of handles for the threads queued at the mailbox in the order they are queued. If there are no threads in the thread queue, this field does not display.
Object cache queue: A list of handles for the objects queued in the object cache queue. The handles are listed in the order they are queued. If there are no objects in the object cache queue or the mailbox type is Data, this field does not display.
Object overflow queue: A list of handles for the objects queued in the object overflow queue. The handles are listed in the order they are queued. If there are no objects in the object overflow queue or the mailbox type is Data, this field does not display.

Semaphore display

Semaphore information is displayed either when no threads are queued or when threads are queued.

This is the format of the display when no threads are queued:

Object type = 4 Semaphore
Thread queue head     xxxx     Queue discipline    xxxx
Current value         xxxx     Maximum value       xxxx
Containing process    xxxx

When no threads are queued, this line is added:

Thread queue    xxxx  xxxx  ...

The field descriptions follow:

Thread queue head: The handle for the thread at the head of the queue. If the thread queue is empty, this field contains zeros.
Queue discipline: Indicates how threads are queued at the semaphore. Threads are queued as FIFO (first-in-first-out) or by PRI (priority), depending on how the semaphore was specified when it was created with CreateRtSemaphore.
Current value: The number of units currently held by the semaphore.
Maximum value: The maximum number of units the semaphore can hold. This number was specified when the semaphore was created.
Containing process: The handle for the process to which the semaphore belongs.
Thread queue: A list of handles for the threads queued at the semaphore, in the order they are queued. If no threads are queued, this list does not display.

Region display

If the handle parameter is a valid handle for a region, information about the region displays with or without a thread queue.

This is the format for the display of a region with no thread queue:

Object type = 5 Region
Entered thread        xxxx     Queue discipline    xxxx
Containing process      xxxx

When a region that has a thread queue, this line is added:

Thread queue    xxxx  xxxx  ...

The field descriptions follow:

Entered thread: The handle for the thread currently accessing information guarded by the region.
Queue discipline: Indicates how threads are queued at the region. Threads are queued as FIFO (first-in-first-out) or by PRI (priority), depending on how the region was specified when it was created with CreateRtRegion.
Containing process: The handle for the process to which the region belongs.
Thread queue: Handles for the threads waiting to gain access to data guarded by the region. This line displays only if a thread is already in the region and another thread is waiting.