pidin

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.
WAITPAGE	Virtual address of the page.

^aIf you specify the -v option, the value also includes the process name, coid, scoid, and channel.

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 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	Stop on exec.
_DEBUG_FLAG_THREAD_EV	0x00100000	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_SHR_MUTEX	0x00040000	This thread places no restrictions on which threads it will share mutexes with (see below).
_NTO_TF_SHR_MUTEX_EUID	0x00080000	This thread shares mutexes only with threads that have the same effective user ID as it does (see below).
_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	A stack has been allocated for the thread.
_NTO_TF_NOMULTISIG	0x08000000	Signals don't terminate all threads in the process.
_NTO_TF_IOPRIV	0x80000000	The thread has I/O privileges.

If neither _NTO_TF_SHR_MUTEX nor _NTO_TF_SHR_MUTEX_EUID is set, the thread doesn't share mutexes with any threads outside its process.

f

Show the processes' flags in hexadecimal, as follows:

Note:

There are gaps in the sequence of flag values listed here because some values are not used.

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 fork().
_NTO_PF_CRITICAL	0x00000040	The process is a critical process.
_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_NOISYNC	0x00000400	Used internally by the process manager.
_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_SLEADER	0x00010000	The process is a session leader.
_NTO_PF_WAITINFO	0x00020000	The process will produce wait information when it terminates.
_NTO_PF_DESTROYALL	0x00080000	The process is being destroyed.
_NTO_PF_NOCOREDUMP	0x00100000	The process is not permitted to create core files.
_NTO_PF_WAITDONE	0x00400000	The process's termination status has already been retrieved, so another wait won't succeed.
_NTO_PF_ASLR	0x01000000	The process is using address space layout randomization (ASLR).
_NTO_PF_EXECED	0x02000000	Used internally by the process manager.
_NTO_PF_APP_STOPPED	0x04000000	The process has been stopped.
_NTO_PF_NOEXEC_STACK	0x40000000	The process doesn't require an executable stack.
_NTO_PF_LOADER_PERMS	0x80000000	Used internally by the process manager.

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

Display the scheduling-specific information for each thread.

h

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

Display the runmask and inherit mask. For more information, see the Multicore Processing chapter of the QNX OS Programmer's Guide.

J

Display the state of the thread; see Thread lifecycle in the QNX OS Microkernel chapter of the System Architecture guide.

j

Display a hexadecimal number whose bits indicate which signals are blocked.

K

Display the last kernel call that was executed.

k

Display the process abilities.

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, followed by a slash (/) and then the total stack size of the process. For more information, see Stack allocation in the Processes chapter of the QNX OS Programmer's Guide.

N

Display the name of the process.

n

Display the process path.

O

Display the loaded shared libraries.

o

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 process 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 threads. For each thread, pidin shows:

• the interrupt ID returned by InterruptAttachThread() or InterruptAttachEvent()
• the interrupt vector passed to InterruptAttachThread() or InterruptAttachEvent()
• the mask level count
• the interrupt flags, as a letter (if set) or a hyphen (if not set):
  • E — _NTO_INTR_FLAGS_END
  • N — _NTO_INTR_FLAGS_NO_UNMASK
  • X — _NTO_INTR_FLAGS_EXCLUSIVE
  • C — _NTO_INTR_FLAGS_CPU_LOCAL
  • V — _NTO_INTR_FLAGS_EVENT_PRIORITY
• 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

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.

[

For each channel, display the channel ID, flags, the lengths of the pulse, send, receive, and reply queues, and the security type (see Using security policies in the System Security Guide).

Flag	Value	Meaning
_NTO_CHF_FIXED_PRIORITY	0x0001u	Suppress priority inheritance when receiving messages.
_NTO_CHF_UNBLOCK	0x0002u	Deliver a pulse when a thread that's REPLY-blocked on a channel attempts to unblock before its message is replied to.
_NTO_CHF_THREAD_DEATH	0x0004u	Deliver a pulse on the death of any thread in the process that owns the channel.
_NTO_CHF_DISCONNECT	0x0008u	Deliver a pulse when all connections from a process are detached.
_NTO_CHF_COID_DISCONNECT	0x0040u	Deliver a pulse to this channel for each connection that belongs to the calling process when the channel that the connection is attached to is destroyed.
_NTO_CHF_PULSE_POOL	0x0100u	The channel was created with ChannelCreatePulsePool() and the pulses are queued in a private pulse pool.
_NTO_CHF_PRIVATE	0x1000u	The channel is private.
_NTO_CHF_MSG_PAUSING	0x2000u	The kernel can pause a message that would otherwise cause a deadlock.
_NTO_CHF_INHERIT_RUNMASK	0x4000u	When a thread receives a message on the channel, the thread inherits the sender's runmask. In this case, the sender's runmask completely replaces the receiver's runmask—it does not restrict the processors that the receiver can run on to the intersection of the two runmasks. The new runmask remains until it is explicitly changed by a call to ThreadCtl() or the thread does another MsgReceive(). When a thread receives a pulse on the channel, the thread's runmask is set to its inherit mask; for information about inherit masks, see Processor affinity, clusters, runmasks, and inherit masks in the Programmer's Guide. If the receiving thread is running on a processor that the new runmask excludes, the thread is rescheduled.

For more information, see ChannelCreate() in the C Library Reference.

\

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.

_

(Underscore) Display the process's security type. For more information, see Using security policies in the System Security Guide.

#

Display the process's hard and soft resource limits.

!

Display whether a process is launched as critical or not.

<

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:

• 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 OS Library Reference.

abilities (equivalent to -F "%a %28n %k")

Display the abilities for each displayed process.

The information that follows the ability name has two parts: a four-character description of its properties (plus optional prefix), and a list of any subranges that are configured. The property description uses the following values:

R

Process has the ability when its effective user ID is 0.

N

Process has the ability when it has an effective user ID other than 0.

L

Ability is locked.

I

Ability is inherited by a spawn or exec.

D

Indicates a custom ability for which the default setting that determines whether the process is given or not given the ability is not known. The process will use the default after it is specified using a call to procmg_ability_create(). For example, DD-- indicates that the default will be used when the process has an effective user ID of either 0 or a value other than 0.

* (asterix)

Ability will always be denied because it has not yet been created by a call to procmgr_ability_create(), even if it has R or N.

The range list uses the following values:

R

The process is given the ability for the specified range when its effective user ID is 0.

N

The process is given the ability for the specified range when its effective user ID is a value other than 0.

(range)

Specifies either a single value or the start and end values of a range.

For example, in the following output excerpt, spawn_setuid is:

• given to the process when it has an effective user ID of 0
• not given to the process when it has an effective user ID other than 0
• locked
• not inherited by a spawn or exec
• not limited to a subrange

# pidin -p slogger2 abilities
    pid name
    4099 proc/boot/slogger2
    spawn_setuid  R-L-
    spawn_setgid  R-L-
    ...

In the following example output, the setuid ability is:

• given to the process when it has an effective user ID of 0
• given to the process when it has an effective user ID other than 0
• locked
• not inherited by a spawn or exec
• allowed for the subranges 0 and 21 (each range contains a single value) when the process has an effective user ID of either 0 or any other value

    setuid  RNL-  RN(0), RN(21)

In the following example output, smmu/attach is:

• always denied (indicated by *) because it has not yet been created by a call to procmgr_ability_create() and the properties specified by R and N are ignored; after procmgr_ability_create() is called, if the process has an effective user ID of 0, it is given the ability, and if it has an effective user ID value other than 0, whether or not it is given the ability is determined by the default specified by the call
• locked
• not inherited by a spawn or exec

    smmu/attach *RD--

The output ends with eol, the end-of-list item that indicates the properties of any future custom abilities. For example:

    eol  D-L-

arguments (equivalent to -F "%a %A")

Show the arguments of the displayed processes.

backtrace (equivalent to -F "%I %q")

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 %28n %[")

For each channel, display the channel ID, flags, the lengths of the pulse, send, receive, and reply queues, and the security type (see Using security policies in the System Security Guide).

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 %28n %E")

Show the environment of the displayed processes.

extsched

Display details of the active extended scheduler configuration.

Note:

The extsched shorthand is supported only for the local node.

family (equivalent to -F "%a %28n %L %P %e %G %C")

Show the sessions, process groups, parents, siblings, and children of the displayed processes.

fds (equivalent to -F "%a %28n %o")

Show information about the process's connections and file descriptors.

flags (equivalent to -F "%a %28n %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. For example:

CPU:X86_64 Release:7.1.0  FreeMem:906MB/1023MB BootTime:Aug 11 09:56:26 ETD 2020
 Actual resident free memory:907Mb
Processes: 31, Threads: 80
Processor1: 328366 Core i7/5/3 Stepping 3 2665MHz FPU
Processor2: 328366 Core i7/5/3 Stepping 3 2709MHz FPU

FreeMem is how much memory is available; the actual resident free memory can be higher than that if memory is reserved but hasn't yet been allocated. For example, when you're creating a new process, a certain amount of memory is reserved for the main thread's stack but the physical pages aren't allocated right away.

irqs (equivalent to -F "%a %b %28n %Q")

Show the interrupts attached by the process.

libs (equivalent to -F "%a %28n %O")

Show the shared libraries loaded by the process.

mapinfo (equivalent to -F "%a %b %28n %p %J %c %d %m" -M " %: @%> %; %< %= %@")

Show information about memory mappings.

The output looks like this:

4101   8 proc/boot/io-usb-otg 10o RECEIVE           80K  424K   4096(20K)
         libc.so.6          @b0300000             452K   16K
         devu-hcd-uhci.so   @b8200000              24K  4096
         devu-hcd-ohci.so   @b8207000              24K  4096
         devu-hcd-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 %28n %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.

Note:

For a more comprehensive method of determining how much memory a process uses, go to Calculating virtual memory reserved by a process in the Process Manager chapter of the System Architecture guide.

The stack numbers represent the amount of stack currently mapped and, in parentheses, the maximum allowed for that thread. An asterisk (*) is printed if the thread creator is responsible for reclaiming the memory used for the stack.

• If you create a thread (e.g., pthread_create()), and let QNX OS kernel allocate the stack, there is no *. QNX OS kernel reclaims the stack memory automatically.
• If you create a thread and provide your own stack (e.g., pthread_attr_setstack()), there is an *. You need to reclaim the stack memory.
• For the main thread, QNX OS kernel creates a thread and provides memory for the stack, therefore an * is printed. QNX OS kernel reclaims the stack memory.

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.

pmem (equivalent to -F "%a %b %28n %p %J %c %d %m")

Display process memory only.

regs (equivalent to -F "%a %b %28n %r")

Show the values of the registers.

rlimits (equivalent to -F "%#")

Display the hard and soft resource limits. For example:

$ pidin -p$$ rlim
Resource limits:                        soft : hard
CPU (seconds)                       infinity : infinity
File size (blocks)                  infinity : infinity
Core dump (blocks)                  infinity : infinity
Data segment size (kB)              infinity : infinity
Stack size (kB)                     infinity : infinity
Locked memory (kB)                  infinity : infinity
Virtual memory (kB)                 infinity : infinity
Open file descriptors                   1000 : 1000
Processes                           infinity : infinity
Threads                             infinity : infinity
Memory usage (.1% RAM)              infinity : infinity
Open connections                    infinity : infinity
Registered events                        256 : 256
Timers created                      infinity : infinity

rmasks (equivalent to -F "%a %b %28n %i")

Display runmasks and inherit masks.

sched (equivalent to -F "%a %b %28n %p %J %l %H")

Display useful scheduling parameters for each thread.

session (equivalent to -F "%L %a %P %e %28n")

Sort by session ID, then process ID. By default, pidin sorts the output by process ID.

signals (equivalent to -F "%a %b %28n %S %s %j")

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 to show all sections.

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. For more details, see the sample output 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
• cluster
• cpuinfo
• hwinfo
• hypinfo
• intrinfo
• 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 System Page chapter of Building Embedded Systems. See also the Working with Memory chapter of the QNX OS Programmer's Guide.

threads (equivalent to -F "%a %b %28n %h %J %B")

Show the process ID, thread ID, short process name, thread name, thread state, and what the thread is blocked on. If a thread doesn't have a name, pidin displays the thread ID (tid) again.

timers (equivalent to -F "%a %b %28n %R")

Show the timers owned by the process.

times (equivalent to -F "%a %28n %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). For information about determining more accurate times, refer to the System Analysis Toolkit User's Guide or the Analyzing Performance chapter of the IDE User's Guide.

tolerance (equivalent to -F "%a %28n %^")

Show the process's default timer tolerance.

ttimes (equivalent to -F "%a %b %28n %J %t %y %z")

Show thread times.

users (equivalent to -F "%a %28n %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.

...
  376856   1 bin/bash            10r REPLY       1
 1830937   1 ./ps_zombie         10r REPLY       1
 1835034     (Zombie)
 1847323   1 bin/sh              10r SIGSUSPEND
...