Display information about the processes in the system (QNX Neutrino)
Syntax:
pidin [options] [shorthand ...]
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.
- -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.
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.
- 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 apoint 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). |
- 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_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.
- 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 process.
A * next to a stack size indicates that
memory used in the stack isn't automatically returned to the
system heap when the thread exits.
The memory is returned when the process exits.
- N
- Display the short name of the process.
- n
- Display the long name of the process.
- O
-
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.
- 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. Valid flags include:
- 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:
- REAL — CLOCK_REALTIME
- SOFT — CLOCK_SOFTTIME
- MONO — CLOCK_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.
- \
-
Display the process's supplementary group IDs.
- ]
-
Display the process's application ID.
- ^
-
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:
- ANON — MAP_PRIVATE, MAP_ANON
- E — MAP_ELF
- F — MAP_FIXED
- P — MAP_PRIVATE
- S — MAP_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.
- 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.
- 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")
-
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 brackets, the maximum allowed for that process.
A * next to a stack size indicates that
memory used in the stack isn't automatically returned to the
system heap when the thread exits. The memory is returned when
the process 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
- Show the syspage entry.
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.
For more information, see
"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 %^")
-
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