pidin

Display information about the processes in the system (QNX Neutrino)

Syntax:

pidin [-hkl] [-d delay] [-F formats] [-f formats] [-M formats]
      [-n node] [-o prio] [-P pid] [-p pid] [shorthand ...]

Runs on:

QNX Neutrino

Options:

-d delay
The delay, in tenths of a second, to use when looping with the -l option. The default is 10.
-F formats
A combination of format codes, like the format string for printf(). Each code consists of a percent sign (%), an optional width for the field, and a format character (e.g., "%I %60N"). For more information, see "Format characters," below.

If you don't specify any format codes, the default is "%a %b %N %p %J %B".

-f formats
The same as the -F option, but the formats parameter is a contiguous string of format codes that gets expanded. For example, -f mbe is expanded to -F "%m %b %e".
-h
Display a brief usage message.
-k
Keep displaying data for PIDs and TIDs until an error occurs, for example, encountering a PID/TID in an unknown state (because the PID/TID is partially alive).
-l
Loop mode; display statistics every delay tenths of a second (specified with the -d option).
-M formats
A combination of format characters, each following a percent sign (%), like the format string for printf(), that controls the formatting of information about memory regions. For more information, see "Memory format characters," below.
-n node
The name of the remote node from which to get the information.
Note: The -n option isn't compatible with the o format or the extsched and fds shorthands. Instead, you can use on -f; for example:
on -f remote_node pidin fds
-o prio
Run at prio priority.
-P pid
Show only the process family you're interested in (pid may be a name or number).
-p pid
Show only the process you're interested in (pid may be a name or number).
Note: If the pid for the -P or -p option is a number, it's interpreted as a process ID; otherwise, it's interpreted as a name. To avoid confusion, don't assign a numerical name to a process.
shorthand
A name that represents a certain combination of format codes or a special command:
  • arguments
  • backtrace
  • channels
  • environment
  • extsched
  • family
  • fds
  • flags
  • info
  • irqs
  • libs
  • mapinfo
  • memory
  • net
  • pmem
  • rc
  • regs
  • rmasks
  • sched
  • session
  • signals
  • syspage
  • threads
  • timers
  • times
  • tolerance
  • ttimes
  • users

You need to type only as many characters of the name as are required to uniquely identify it. For more information, see "Shorthand forms," below.

Description:

The pidin utility displays information about the processes running on a QNX Neutrino system.

Note:
  • This utility goes through all of the processes in the system, one by one, and retrieves state information for each; it doesn't get the system state in a single snapshot. Thus pidin's output reflects what was happening at the instant in time when it queried each process, so you might see some anomalies, suchs as more threads running than there are processors in the system.
  • If you aren't logged in as root, pidin can't get full information about processes owned by other users.

By default, pidin displays the statistics once and then exits. If you specify the -l option, pidin loops forever, displaying statistics after the delay specified by the -d option.

If you specify the -l and -k options, pidin loops until a error occurs, displaying statistics after the given delay. The most common error encountered is a race condition: procnto indicates that a process exists, but the process is gone when pidin queries it.

Format characters

The format characters that you can specify with the -F or -f option include the following:

A
Display the arguments.
a
Display the process ID.
B
Display what you're blocked on. The output includes a Blocked column whose value depends on the thread's state:
State Value
CONDVAR Address of the condvar
JOIN Thread ID of the blocking thread
MUTEX The address of the mutex, or the IDs of the process and thread blocked on, followed by the number of times locked, in the form pid-tid #times
RECEIVE ID of the channel within the process that the thread is blocked on
REPLY Process IDa
SEM Address of the semaphore
SEND Process IDa
STACK Stack size
WAITPAGE Virtual address of the page
WAITTHREAD Thread ID of the blocking thread

a If the process is running on a remote node, the process ID is followed by @ and the node name.

b
Display the thread ID.
C
Display the process ID of one of the process's children. If you specify the G format, other children are listed as siblings of this child. For more information about the relationships among processes, see "Process information" in the appendix on the /proc filesystem in The QNX Neutrino Cookbook.
c
Display the code size of the process.
D
Display the process's debug flags:
Flag Value Meaning
_DEBUG_FLAG_STOPPED 0x00000001 The thread isn't running
_DEBUG_FLAG_ISTOP 0x00000002 The thread is stopped at a point of interest
_DEBUG_FLAG_IPINVAL 0x00000010 The instruction pointer isn't valid
_DEBUG_FLAG_ISSYS 0x00000020 System process
_DEBUG_FLAG_SSTEP 0x00000040 Stopped because of single-stepping
_DEBUG_FLAG_CURTID 0x00000080 The thread is the current thread
_DEBUG_FLAG_TRACE_EXEC 0x00000100 Stopped because of a breakpoint
_DEBUG_FLAG_TRACE_RD 0x00000200 Stopped because of read access
_DEBUG_FLAG_TRACE_WR 0x00000400 Stopped because of write access
_DEBUG_FLAG_TRACE_MODIFY 0x00000800 Stopped because of modified memory
_DEBUG_FLAG_RLC 0x00010000 The Run-on-Last-Close flag is set
_DEBUG_FLAG_KLC 0x00020000 The Kill-on-Last-Close flag is set
_DEBUG_FLAG_FORK 0x00040000 The child inherits flags (stop on fork or spawn)
_DEBUG_FLAG_EXEC 0x00080000 (QNX Neutrino 6.6 or later) Stop on exec
_DEBUG_FLAG_THREAD_EV 0x00100000 (QNX Neutrino 6.6 or later) Stop when creating or destroying a thread
d
Display the data size of the process.
E
Display the environment.
e
Display the parent PID.
F
Show the threads' flags in hexadecimal, as follows:
Flag Value Meaning
_NTO_TF_INTR_PENDING 0x00010000 The thread has a pending interrupt
_NTO_TF_DETACHED 0x00020000 The thread is detached
_NTO_TF_THREADS_HOLD 0x00100000 Threads are being held
_NTO_TF_UNBLOCK_REQ 0x00400000 There's an unblock pending on the thread
_NTO_TF_ALIGN_FAULT 0x01000000 An alignment fault has occurred
_NTO_TF_SSTEP 0x02000000 Single-stepping is turned on
_NTO_TF_ALLOCED_STACK 0x04000000 Memory used in the stack isn't automatically returned to the system heap when the thread exits
_NTO_TF_NOMULTISIG 0x08000000 Signals don't terminate all threads in the process
_NTO_TF_FROZEN 0x10000000 The thread is frozen
_NTO_TF_IOPRIV 0x80000000 The thread has I/O privileges
f
Show the processes' flags in hexadecimal, as follows:
Flag Value Meaning
_NTO_PF_NOCLDSTOP 0x00000001 The process isn't sent a SIGCHILD signal when its children stop
_NTO_PF_LOADING 0x00000002 The process hasn't been fully loaded
_NTO_PF_TERMING 0x00000004 The process is terminating
_NTO_PF_ZOMBIE 0x00000008 The process is a zombie
_NTO_PF_NOZOMBIE 0x00000010 The process won't become a zombie on its death
_NTO_PF_FORKED 0x00000020 The process is a child by way of exec()
_NTO_PF_ORPHAN_PGRP 0x00000040 The process is an orphan
_NTO_PF_STOPPED 0x00000080 The process has been stopped
_NTO_PF_DEBUG_STOPPED 0x00000100 The process has been stopped by the debugger
_NTO_PF_BKGND_PGRP 0x00000200 The process is running in the background
_NTO_PF_NO_LIMITS 0x00000400 The process has no limits on its resources
_NTO_PF_CONTINUED 0x00000800 The process was stopped, but has now been made to continue
_NTO_PF_CHECK_INTR 0x00001000 The process is attached to some interrupts
_NTO_PF_COREDUMP 0x00002000 The process has written a coredump file
_NTO_PF_PTRACED 0x00004000 The process is being traced
_NTO_PF_RING0 0x00008000 The process is running in a privileged supervisor state (known as "ring 0" in some architectures)
_NTO_PF_SLEADER 0x00010000 The process is a session leader
_NTO_PF_WAITINFO 0x00020000 The process will produce wait information when it terminates
_NTO_PF_VFORKED 0x00040000 The process was created with vfork()
_NTO_PF_DESTROYALL 0x00080000 The process is being destroyed
_NTO_PF_NOCOREDUMP 0x00100000 The process is not permitted to create core files
_NTO_PF_NOCTTY 0x00200000 The process doesn't have a controlling TTY
_NTO_PF_WAITDONE 0x00400000 The process's termination status has already been retrieved, so another wait won't succeed
_NTO_PF_TERM_WAITING 0x00800000 The process is waiting to terminate
_NTO_PF_ASLR 0x01000000 (QNX Neutrino 6.6 or later) The process is using address space layout randomization (ASLR)
_NTO_PF_EXECED 0x02000000 (QNX Neutrino 6.6 or later) The process was created by a fork(), spawn*(), or exec*()
_NTO_PF_THREADWATCH 0x80000000 Not currently used
G
Display the process ID of one of the process's siblings. If you specify the C format, pidin displays the process ID of one of each process's children. You can use the child and sibling information to determine a process's children. For more information about the relationships among processes, see "Process information" in the appendix on the /proc filesystem in The QNX Neutrino Cookbook.
H
(QNX Neutrino Core OS 6.3.2 or later) Display the scheduling-specific information for each thread.

For adaptive partitioning scheduling, the information is the name of the partition that the thread is running in. For more information, see the Adaptive Partitioning User's Guide.

h
(QNX Neutrino Core OS 6.3.2 or later) Display the thread name; if a thread doesn't have a name, pidin displays the thread's ID (tid) instead.
I
Display the PID and TID, joined by a hyphen.
i
(QNX Neutrino Core OS 6.3.2 or later) Display the runmask and inherit mask. For more information, see the Multicore Processing User's Guide.
J
Display the state of the thread; see "Thread life cycle" in the QNX Neutrino Microkernel chapter of the System Architecture guide.
K
Display the last kernel call that was executed.
L
Display the session ID.
l
("el") Display the last CPU that the thread ran on.
M
Display the memory owned by the PID.
m
Display the stack size of the thread. The output includes the amount of stack currently mapped and, in parentheses, the maximum allowed for the thread. An asterisk (*) next to a stack size indicates that memory used in the stack isn't automatically returned to the system heap when the thread exits. For more information, see "Stack allocation" in the Processes chapter of the QNX Neutrino Programmer's Guide.
N
Display the short name of the process.
n
Display the long name of the process.
O
(QNX Neutrino 6.6 or later) Display the loaded shared libraries.
o
(QNX Neutrino Core OS 6.3.2 or later) Display the connection IDs and file descriptors associated with the process. If you don't have permission to access them, pidin provides only limited information.

The information for each connection and file descriptor includes the following:

  • the file descriptor, followed by s if it's a side channel
  • the ID of the process the connection is to
  • open flags (r or -, followed by w or -), or MP for a mountpoint
  • the offset
  • the name of the file or device, if available.
Note: The -n option isn't compatible with the o format; use on -f remote_node pidin -F "%o" instead.
P
(Uppercase "P") Display the parent group.
p
(Lowercase "p") Display the thread priority. The letter following the scheduling priority number stands for the scheduling policy used, as follows:
  • f — FIFO scheduling
  • r — round-robin scheduling
  • o — other (currently the same as round-robin scheduling)
  • s — sporadic scheduling

For more information on these scheduling policies, see "Thread scheduling" in the System Architecture guide.

Q
Display the interrupt handlers. For each handler, pidin shows:
  • the interrupt ID returned by InterruptAttach() or InterruptAttachEvent()
  • the interrupt vector passed to InterruptAttach() or InterruptAttachEvent()
  • the mask level count
  • the interrupt flags, as a letter (if set) or a hyphen (if not set):
    • T_NTO_INTR_FLAGS_TRK_MSK
    • P_NTO_INTR_FLAGS_PROCESS
    • E_NTO_INTR_FLAGS_END
  • the address of the interrupt handler and the interrupt handler area, separated by a colon
  • a description of the sigevent to be delivered. Valid descriptions include:
    • SIGNAL signo
    • SIGNAL_CODE signo code:value
    • SIGNAL_THREAD signo code:value
    • PULSE coid:priority code:value
    • UNBLOCK
    • INTR
    • THREAD code:value
q
(QNX Neutrino 6.4.0 or later) Display the backtrace of the addresses of calling routines. For best results, use this format with the I format (as in the backtrace shorthand form).
R
Display information about the timers:
  • the timer ID returned by TimerCreate()
  • the thread ID associated with this timer (0 for the entire process)
  • the number of overruns
  • the type of clock used:
    • REALCLOCK_REALTIME
    • SOFTCLOCK_SOFTTIME
    • MONOCLOCK_MONOTONIC
  • the timer flags:
    • X_NTO_TI_EXPIRED
    • A_NTO_TI_ABSOLUTE
    • a_NTO_TI_ACTIVE
    • P_NTO_TI_PRECISE
  • the time left before expiry, in microseconds, followed by a slash (/), and then by the timer interval, in microseconds
  • the timer tolerance, in microseconds, or INF for infinitely tolerant timers
  • the description of the sigevent to be delivered when the timer expires:
    • SIGNAL signo
    • SIGNAL_CODE signo code:value
    • SIGNAL_THREAD signo code:value
    • PULSE coid:priority code:value
    • UNBLOCK
    • INTR
    • THREAD code:value
r
Show the values of the registers.
S
Display the signal-ignore mask.
s
Display the signal-queued mask.
T
Display the number of threads.
t
Display the time at which the process was started.
U
Display the process's user ID, as a number.
u
Display the number of nanoseconds spent running in user space.
V
Display the process's group ID, as a number.
v
Display the number of nanoseconds spent running in system space.
W
Display the process's effective user ID, as a number.
w
Display the number of nanoseconds that the process's terminated children spent running in user space.
X
Display the process's effective group ID, as a number.
x
Display the number of nanoseconds that the process's terminated children spent running in system space.
Y
Display the process's set user ID, as a number.
y
Display the time at which the thread was started.
Z
Display the process's set group ID, as a number.
z
Display the number of nanoseconds that the thread spent running in user and system space.
[
(QNX Neutrino 6.4.0 or later) Display the lengths of the send, receive, reply and pulse queues.
\
(QNX Neutrino 6.6 or later) Display the process's supplementary group IDs.
]
(QNX Neutrino 6.6 or later) Display the process's application ID.
^
(QNX Neutrino 6.6 or later) Display the process's default timer tolerance in nanoseconds, or infinite if the timers are infinitely tolerant.

Memory format characters

The memory format characters that you can specify with the -M options include the following:

<
Display the memory object's code size.
=
Display the memory object's data size.
>
Display the memory object's address.
?
Display the memory object's offset.
M
Display the memory owned by the process.
: (colon)
Display the memory object's name, or Mapped Phys Memory for mapped physical memory.
; (semicolon)
Display the offset that was used in the mmap() call when physical memory was mapped.
@
Display the memory object's flags, which can include:
  • ANONMAP_PRIVATE, MAP_ANON
  • EMAP_ELF
  • FMAP_FIXED
  • PMAP_PRIVATE
  • SMAP_SHARED

For more information about these flags, see the entry for mmap() in the QNX Neutrino Library Reference.

Shorthand forms

Each shorthand form represents a certain combination of format codes or a special command. You need to type only as many characters of the name as are required to uniquely identify it. The shorthand forms include the following:

arguments (equivalent to -F "%a %A")
Show the arguments of the displayed processes.
backtrace (equivalent to -F "%I %q")
(QNX Neutrino 6.4.0 or later) Display backtrace information for each thread in the displayed processes. For example:
$ pidin -p devc-con-hid back
pid-tid     backtrace
    4103-01 b033ab5b:b03323cb:b03324f3:804f6ed:804c120:804a285
    4103-02 b033af63:805ca60:b031f0ad

The output includes the process ID hyphenated to the thread ID, followed by a backtrace of the addresses of the calling routines.

channels (equivalent to -F "%a %b %N %[")
(QNX Neutrino 6.4.0 or later) Display the lengths of the send, receive, reply and pulse queues.

This shorthand is useful if you're trying to track pulse leaks—that is, a process not receiving pulses. This can cause a growth in kernel memory usage, since pulse structures are allocated in the kernel.

environment (equivalent to -F "%a %N %E")
Show the environment of the displayed processes.
extsched
(QNX Neutrino Core OS 6.3.2 or later) Display details of the active extended scheduler configuration.

For the adaptive partitioning scheduler, this is one line of global configuration and then one line for each defined partition (showing the name, budget, critical budget, and overload notifications). For more information, see the Adaptive Partitioning User's Guide.

Note: The extsched shorthand is supported only for the local node. To get this information from a remote node, use:
on -f remote_node pidin extsched
family (equivalent to -F "%a %N %L %P %e %G %C")
Show the sessions, process groups, parents, siblings, and children of the displayed processes.
fds (equivalent to -F "%a %N %o")
(QNX Neutrino Core OS 6.3.2 or later) Show information about the process's connections and file descriptors.
Note: The -n option isn't compatible with the fds shorthand; use on -f remote_node pidin fds instead.
flags (equivalent to -F "%a %N %f")
Show the processes' flags in hexadecimal.
info
Display information about the system, such as the type of processor(s) and the amount of free memory.
irqs (equivalent to -F "%a %b %N %Q")
Show the IRQ handlers owned by the process.
libs (equivalent to -F "%a %N %O")
(QNX Neutrino 6.6 or later) Show the shared libraries loaded by the process.
mapinfo (equivalent to -F "%a %b %N %p %J %c %d %m" -M " %: @%> %; %< %= %@")
(QNX Neutrino 6.4.0 or later) Show information about memory mappings.

The output looks like this:

4101   8 proc/boot/io-usb    10o RECEIVE           80K  424K   4096(20K)
         libc.so.3          @b0300000             452K   16K
         devu-uhci.so       @b8200000              24K  4096
         devu-ohci.so       @b8207000              24K  4096
         devu-ehci.so       @b820e000              28K  4096
         Mapped Phys Memory @40100000 (ee000000)         12K  S

It includes:

  • the memory object's name, or Mapped Phys Memory for mapped physical memory
  • the memory object's address, followed by the offset if applicable
  • the object's code and data sizes
  • the memory object's flags
memory (equivalent to -F "%a %b %N %p %J %c %d %m" -M " %M @%> %? %< %=")
Show the memory used by the displayed processes; pidin displays the shared memory regions, including shared objects, and stack usage for each thread. Shared code and data regions are removed from the size of the process.

The stack numbers represent the amount of stack currently mapped and, in parentheses, the maximum allowed for that thread. An asterisk (*) next to a stack size indicates that memory used in the stack isn't automatically returned to the system heap when the thread exits.

Entries for /dev/mem indicate shared memory that's mapped into the process address space. For example:

/dev/mem           @38100000 (       0)        172K

If the entries for different processes show the same object (@38100000 in this example), they all reference the same shared memory object. The processes can map that shared memory differently; the number in parentheses is the offset that was used in the mmap() call, and the last number is the size of the mapping.

If a shared object that contains text relocations is remapped as private, pidin mem displays an exclamation mark (!) beside the name.

net
Display system information about all the nodes on the Qnet network.
pmem (equivalent to -F "%a %b %N %p %J %c %d %m")
Display process memory only.
rc
Show the process name and arguments of all remote nodes connected to your machine.
regs (equivalent to -F "%a %b %N %r")
Show the values of the registers.
rmasks (equivalent to -F "%a %b %N %i")
(QNX Neutrino Core OS 6.3.2 or later) Display runmasks and inherit masks.
sched (equivalent to -F "%a %b %N %p %l %H %J")
(QNX Neutrino Core OS 6.3.2 or later) Display useful scheduling parameters for each thread.
session (equivalent to -F "%L %a %P %e %N")
Sort by session ID, then process ID. By default, pidin sorts the output by process ID.
signals (equivalent to -F "%a %b %N %S %s")
Show the signal state of the displayed processes.
syspage[=section]
Show the contents of the system page. You can specify which section to print by indicating a name (e.g. the command pidin syspage=asinfo displays the asinfo section). The default is all.

For example, if you want to find out how much space the image file system (IFS) occupies in the memory, run the following command:

pidin syspage=asinfo

and look for the lines with imagefs. See the output in the display as shown in the "Examples" section below.

The information always includes the system page's header, which consists of the size, total_size, type, and num_cpu members. You can get additional information for the following sections:

  • asinfo
  • cacheattr
  • callout
  • cpuinfo
  • hwinfo
  • intrinfo
  • mdriver
  • pminfo
  • qtime
  • smp
  • strings
  • system_private
  • typed_strings

If the section doesn't have any additional information, or the section you specify doesn't exist, pidin displays the system page's header anyway. For more information about the contents of the system page, see the "Structure of the system page" in the Customizing Image Startup Programs chapter of Building Embedded Systems.

threads (equivalent to -F "%a %N %h %J %B")
Show the thread name; if a thread doesn't have a name, pidin displays the thread's ID (tid) instead.
timers (equivalent to -F "%a %b %N %R")
Show the timers owned by the process.
times (equivalent to -F "%a %N %L %t %u %v %w %x")
Display times for the process.

For each process displayed, show:

  • start time—the time and date that the process was started
  • utime—the number of CPU seconds consumed by the process
  • stime—the number of CPU seconds consumed by the kernel on behalf of the process
  • cutime—the number of CPU seconds consumed by the children of the process
  • cstime—the number of CPU seconds consumed by the kernel on behalf of the children of the process

The times for the child processes are added to cutime and cstime only after the children terminate.

Note: CPU usage is calculated by sampling. When the timer interrupt occurs, the kernel determines which process is running, and adds the time to the total running times of the active thread and its process. If the kernel itself is active, it also adds the time to the system times (stime) of the active thread and its process. The utime is the total running time minus the system time.

As a result, these times are approximate, and can be inaccurate (e.g., if a process is driven by the timer interrupt). To determine more accurate times, use the system profiler. For more information, see the System Analysis Toolkit User's Guide, or the Analyzing Your System with Kernel Tracing chapter of the IDE User's Guide.

tolerance (equivalent to -F "%a %N %^")
(QNX Neutrino 6.6 or later) Show the process's default timer tolerance.
ttimes (equivalent to -F "%a %b %N %J %t %y %z")
Show thread times.
users (equivalent to -F "%a %N %U %V %W %X %Y %Z %\\")
Display the real, effective, and saved user IDs and group IDs, and the supplemental group IDs for the user who launched the processes.

This option doesn't display the users' or groups' names, just the numerical IDs.

Examples:

The pidin command prints a listing similar to this:

     pid tid name               prio STATE       Blocked
       1   1 /sys/procnto-instr   0f READY
       1   3 /sys/procnto-instr  10r RUNNING
       1   4 /sys/procnto-instr  12r RECEIVE     1
       1   5 /sys/procnto-instr  12r RECEIVE     1
       1   6 /sys/procnto-instr  12r RECEIVE     1
       1  11 /sys/procnto-instr  12r RECEIVE     1
       1  12 /sys/procnto-instr  10r RECEIVE     1
       1  13 /sys/procnto-instr  10r RECEIVE     1
       1  15 /sys/procnto-instr 255r RECEIVE     1
       1  16 /sys/procnto-instr  10r RECEIVE     1
       1  17 /sys/procnto-instr  10r RECEIVE     1
       2   1 sbin/tinit          10o REPLY       1
       3   1 proc/boot/slogger   10o RECEIVE     1
       5   1 proc/boot/pci-bios  10o RECEIVE     1
       6   1 roc/boot/devb-eide  10o SIGWAITINFO
       6   2 roc/boot/devb-eide  21r RECEIVE     1
       ...

Using pidin -F "%I %60N" displays the PID and TID, along with up to 60 characters of the processes' short name:

pid-tid     name
       1-01 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-03 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-04 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-05 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-06 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-11 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-12 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-13 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-15 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-16 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       1-17 rldbuild/cdr/qnx6/tmp/target/qnx6/x86/boot/sys/procnto-instr
       2-01 sbin/tinit
       3-01 proc/boot/slogger
       5-01 proc/boot/pci-bios
       6-01 proc/boot/devb-eide
       ...

The pidin mem command displays:

     pid tid name               prio STATE           code  data         stack
       1   1 /sys/procnto-instr   0f READY           1812K   12K      0(320)*
       1   3 /sys/procnto-instr  10r RUNNING         1812K   12K     0(8192)
       1   4 /sys/procnto-instr  12r RECEIVE         1812K   12K     0(8192)
       1   5 /sys/procnto-instr  12r RECEIVE         1812K   12K     0(8192)
       1   6 /sys/procnto-instr  12r RECEIVE         1812K   12K     0(8192)
       1  11 /sys/procnto-instr  12r RECEIVE         1812K   12K     0(8192)
       1  12 /sys/procnto-instr  10r RECEIVE         1812K   12K     0(8192)
       1  13 /sys/procnto-instr  10r RECEIVE         1812K   12K     0(8192)
       1  15 /sys/procnto-instr 255r RECEIVE         1812K   12K     0(8192)
       1  16 /sys/procnto-instr  10r RECEIVE         1812K   12K     0(8192)
       1  17 /sys/procnto-instr  10r RECEIVE         1812K   12K     0(8192)
            procnto-instr      @cfbe5000              12K   12K
       2   1 sbin/tinit          10o REPLY            8192   36K  4096(516K)*
            ldqnx.so.2         @b0300000             344K   16K
       3   1 proc/boot/slogger   10o RECEIVE          8192  104K  4096(516K)*
            ldqnx.so.2         @b0300000             344K   16K
       5   1 proc/boot/pci-bios  10o RECEIVE           36K   40K  8192(516K)*
            ldqnx.so.2         @b0300000             344K   16K
       6   1 roc/boot/devb-eide  10o SIGWAITINFO       52K   91M  8192(516K)*
       6   2 roc/boot/devb-eide  21r RECEIVE           52K   91M   4096(12K)
       ...

The pidin syspage=asinfo command displays:

Section:asinfo offset:0x00000568 size:0x00000240
    0)                0-ffff             o:ffff a:0000 p:100 n:io
   20)                0-ffffffff         o:ffff a:0010 p:100 n:memory
   40)                0-ffffff           o:0020 a:0010 p:100 n:memory/isa
   a0)                0-9fbff            o:0040 a:0017 p:100 n:memory/isa/ram
  180)             1000-cfff             o:00a0 a:0007 p:100 n:memory/isa/ram/sysram
  1a0)            20f98-9fbff            o:00a0 a:0007 p:100 n:memory/isa/ram/sysram
   c0)           100000-ffffff           o:0040 a:0037 p:100 n:memory/isa/ram
  1c0)           100000-40e507           o:00c0 a:0007 p:100 n:memory/isa/ram/sysram
  1e0)           5e533c-ffffff           o:00c0 a:0027 p:100 n:memory/isa/ram/sysram
   60)          6000000-ffefffff         o:0020 a:0013 p:100 n:memory/device
  100)          6000000-ffeafff          o:0060 a:0017 p:100 n:memory/device/ram
  220)          6000000-ffeafff          o:0100 a:0007 p:100 n:memory/device/ram/sysram
   80)         fff00000-ffffffff         o:0020 a:0005 p:100 n:memory/rom
   e0)          1000000-5ffffff          o:0020 a:0037 p:100 n:memory/ram
  200)          1000000-5ffffff          o:00e0 a:0027 p:100 n:memory/ram/sysram
  120)           40e508-5e533b           o:0020 a:0005 p:100 n:memory/imagefs
  140)           400400-40e507           o:0020 a:0007 p:100 n:memory/startup
  160)           40e508-5e533b           o:0020 a:0007 p:100 n:memory/bootram