ps Command 参考

ps Command

Purpose

       Shows current status of processes. This document describes the standard AIX ps command as well as the System V version of the ps command.

Syntax

X/Open Standards

       ps [ -A ] [ -M ] [ -N ] [ -Z ] [ -a ] [ -d ] [ -e ] [ -f ] [ -k ] [ -l ] [ -F format] [ -o Format ] [ -c Clist ] [ -G Glist ] [ -g Glist ] [ -m ] [ -n
       NameList ] [ -p Plist ] [ -P ] [ -t Tlist ] [ -U Ulist ] [ -u Ulist ] [ -T pid ] [ -L pidlist ] [ -X ]

Berkeley Standards

       ps [ a ] [ c ] [ e ] [ ew ] [ eww ] [ g ] [ n ] [ U ] [ w ] [ x ] [ l | s | u | v ] [ t Tty ] [ X ] [ ProcessNumber ]

Description

       The ps command writes the current status of active processes and (if the -m flag is given) associated kernel threads to standard output. Note that while the
       -m flag displays threads associated with processes using extra lines, you must use the -o flag with the THREAD field specifier to display extra thread-related
       columns.

       Without flags, the ps command displays information about the current workstation. The -f, -o, l, -l, s, u, and v flags only determine how much information is
       provided about a process; they do not determine which processes are listed. The l, s, u, and v flags are mutually exclusive.

       With the -o flag, the ps command examines memory or the paging area and determines what the command name and parameters were when the process was created. If
       the ps command cannot find this information, the command name stored in the kernel is displayed in square brackets.

       The COLUMNS environment variable overrides the system-selected, horizontal screen size.

       The command-line flags that accept a list of parameters (the -o, -G, -g, -p, -t, -U, and -u flags) are limited to 128 items. For example, the -u Ulist flag
       can specify no more than 128 users.

       Depending on the flags used with the ps command, column headings are displayed above the information displayed to standard output. The headings are defined in
       the following list (flags that cause these headings to be displayed are shown in parentheses):
       ADDR
            (-l and l flags) Contains the segment number of the process stack, if normal; if a kernel process, the address of the preprocess data area.
       BND
            (-o THREAD flag) The logical processor number of the processor to which the kernel thread is bound (if any). For a process, this field is shown if all
            its threads are bound to the same processor.
       C
            (-f, l, and -l flags) CPU utilization of process or thread, incremented each time the system clock ticks and the process or thread is found to be
            running. The value is decayed by the scheduler by dividing it by 2 once per second. For the sched_other policy, CPU utilization is used in determining
            process scheduling priority. Large values indicate a CPU intensive process and result in lower process priority whereas small values indicate an I/O
            intensive process and result in a more favorable priority.
       CMD
            (-f, -l, and l flags) Contains the command name. Under the -f flag, ps tries to determine the current command name and arguments both of which may be
            changed asynchronously by the process. These are then displayed. Failing this, the command name as it would appear without the option -f, is written in
            square brackets.
       COMMAND
            (s, u, and v) Contains the command name. The full command name and its parameters are displayed with the -f flag.

            F                                                   Field                                               Table
            Flags                                               Hexadecimal Value                                   Definition
            SLOAD                                               0x00000001                                          Indicates that the process is operating in core
                                                                                                                    memory.
            SNOSWAP                                             0x00000002                                          Indicates that the process cannot be swapped out.
            STRC                                                0x00000008                                          Indicates that the process is being traced.
            SWTED                                               0x00000010                                          Indicates that the process stopped while being
                                                                                                                    traced.
            SFWTED                                              0x00000020                                          Indicates that the process stopped after a call
                                                                                                                    to the fork subroutine, while being traced.
            SEWTED                                              0x00000040                                          Indicates that the process stopped after a call
                                                                                                                    to the exec subroutine, while being traced.
            SLWTED                                              0x00000080                                          Indicates that the process stopped after a call
                                                                                                                    to the load or unload subroutine, while being
                                                                                                                    traced.
            SFIXPRI                                             0x00000100                                          Indicates that the process has a fixed priority,
                                                                                                                    ignoring the pcpu field descriptor.
            SKPROC                                              0x00000200                                          Indicates a Kernel process.
            SOMASK                                              0x00000400                                          Indicates restoration of the old mask after a
                                                                                                                    signal is received.
            SWAKEONSIG                                          0x00000800                                          Indicates that the signal will abort the sleep
                                                                                                                    subroutine. The contents must not be equal to
                                                                                                                    those of the PCATCH flag. The contents of both
                                                                                                                    PCATCH and SWAKEONSIG must be greater than those
                                                                                                                    of PMASK.
            SUSER                                               0x00001000                                          Indicates that the process is in user mode.
            SLKDONE                                             0x00002000                                          Indicates that the process has done locks.
            STRACING                                            0x00004000                                          Indicates that the process is a debugging pro-
                                                                                                                    cess.
            SMPTRACE                                            0x00008000                                          Indicates multi-process debugging.
            SEXIT                                               0x00010000                                          Indicates that the process is exiting.
            SSEL                                                0x00020000                                          Indicates that the processor is selecting:
                                                                                                                    wakeup/waiting danger.
            SORPHANPGRP                                         0x00040000                                          Indicates an orphaned process group.
            SNOCNTLPROC                                         0x00080000                                          Indicates that the session leader relinquished
                                                                                                                    the controlling terminal.
            SPPNOCLDSTOP                                        0x00100000                                          Indicates that the SIGHLD signal is not sent to
                                                                                                                    the parent process when a child stops.
            SEXECED                                             0x00200000                                          Indicates that process has been run.
            SJOBSESS                                            0x00400000                                          Indicates that job control was used in the
                                                                                                                    current session.
            SJOBOFF                                             0x00800000                                          Indicates that the process is free from job con-
                                                                                                                    trol.
            PSIGDELIVERY                                        0x01000000                                          Indicates that the process is used by the
                                                                                                                    program-check handler.
            SRMSHM                                              0x02000000                                          Indicates that the process removed shared memory
                                                                                                                    during a call to the exit subroutine.
            SSLOTFREE                                           0x04000000                                          Indicates that the process slot is free.
            SNOMSG                                              0x08000000                                          Indicates that there are no more uprintf subrou-
                                                                                                                    tine messages.

       DPGSZ
            (Z flag) The data page size of the process.
       F
            (-l and l flags) Some of the more important F field flags (hexadecimal and additive) associated with processes and threads are shown in the following
            table:

            F                                                   Field                                               Table
            Flags                                               Hexadecimal Value                                   Definition
            SLOAD                                               0x00000001                                          Indicates that the process is operating in core
                                                                                                                    memory.
            SNOSWAP                                             0x00000002                                          Indicates that the process cannot be swapped out.
            STRC                                                0x00000008                                          Indicates that the process is being traced.
            SKPROC                                              0x00000200                                          Indicates a kernel process.
            SEXIT                                               0x00010000                                          Indicates that the process is exiting.
            SLPDATA                                             0x00020000                                          Indicates that the process uses large pages.
            SEXECED                                             0x00200000                                          Indicates that the process has been run.
            SEXECING                                            0x01000000                                          Indicates that the process is execing (performing
                                                                                                                    an exec).
            SPSEARLYALLOC                                       0x04000000                                          Indicates that paging space for this process is
                                                                                                                    allocated early.
            TKTHREAD                                            0x00001000                                          Indicates that the thread is a kernel-only
                                                                                                                    thread.

            Note: You can see the definitions of all process and thread flags by consulting the p_flags and t_flags fields in the /usr/include/sys/proc.h and
            /usr/include/sys/thread.h files respectively.
       LIM
            (v flag) The soft limit on memory used, specified via a call to the setrlimit subroutine. If no limit has been specified, then shown as xx. If the limit
            is set to the system limit, (unlimited), a value of UNLIM is displayed.
       NI
            (-l and l flags) The nice value; used in calculating priority for the sched other policy.
       PID
            (all flags) The process ID of the process.
       PGIN
            (v flag) The number of disk I/Os resulting from references by the process to pages not loaded in core.
       PPID
            (-f, l, and -l flags) The process ID of the parent process.
       PRI
            (-l and l flags) The priority of the process or kernel thread; higher numbers mean lower priority.
       PROJECT
            (-P flag) Project name assigned to the process.
       RSS
            (v flag) The real-memory (resident set) size of the process (in 1KB units).
       S
            (-l and l flags) The state of the process or kernel thread :

            For processes:
              O
                   Nonexistent
              A
                   Active
              W
                   Swapped
              I
                   Idle (waiting for startup)
              Z
                   Canceled
              T
                   Stopped
            For kernel threads:
              O
                   Nonexistent

              R
                   Running
              S
                   Sleeping
              W
                   Swapped
              Z
                   Canceled
              T
                   Stopped
       SC
            (-o THREAD flag) The suspend count of the process or kernel thread. For a process, the suspend count is defined as the sum of the kernel threads suspend
            counts.
       SCH
            (-o THREAD flag) The scheduling policy for a kernel thread. The policies sched_other, sched_fifo, and sched_rr are respectively displayed using: 0, 1, 2.
       SIZE
            (v flag) The virtual size of the data section of the process (in 1KB units).
       SPGSZ
            (Z flag) The stack page size of the process.
       SSIZ
            (s flag) The size of the kernel stack. This value is always 0 (zero) for a multi-threaded process.
       STAT
            (s, u, and v flags) Contains the state of the process:
              0
                   Nonexistent
              A
                   Active
              I
                   Intermediate
              Z
                   Canceled
              T
                   Stopped
              K
                   Available kernel process
       STIME
            (-f and u flags) The starting time of the process. The LANG environment variables control the appearance of this field.
       SUBPROJ
            (-P flag) Subproject Identifier assigned to the process.
       SZ
            (-l and l flags) The size in 1KB units of the core image of the process.
       THCNT
            (-o thcount flag) The number of kernel threads owned by the process.
       TID
            (-o THREAD flag) The thread ID of the kernel thread.
       TIME
            (all flags) The total runtime for the process. The time is displayed in the format of mm:ss or mmmm:ss if the runtime reaches 100 minutes, which is
            different from the displayed format if you use the -o time flag.
       TPGSZ
            (Z flag) The text page size of the process.
       TRS
            (v flag) The size of resident-set (real memory) of text.
       TSIZ
            (v flag) The size of text (shared-program) image.
       TTY
            (all flags) The controlling workstation for the process:
              -
                   The process is not associated with a workstation.

              ?
                   Unknown.
              Number
                   The TTY number. For example, the entry 2 indicates TTY2.
       UID
            (-f, -l, and l flags) The user ID of the process owner. The login name is printed under the -f flag.
       USER
            (u flag) The login name of the process owner.
       WCHAN
            (-l flag) The event for which the process or kernel thread is waiting or sleeping. For a kernel thread, this field is blank if the kernel thread is
            running. For a process, the wait channel is defined as the wait channel of the sleeping kernel thread if only one kernel thread is sleeping; otherwise a
            star is displayed.
       WCHAN
            (l flag) The event on which process is waiting (an address in the system). A symbol is chosen that classifies the address, unless numerical output is
            requested.
       %CPU
            (u and v flags) The percentage of time the process has used the CPU since the process started. The value is computed by dividing the time the process
            uses the CPU by the elapsed time of the process. In a multi-processor environment, the value is further divided by the number of available CPUs because
            several threads in the same process can run on different CPUs at the same time. (Because the time base over which this data is computed varies, the sum
            of all %CPU fields can exceed 100%.)
       %MEM
            (u and v flags) The percentage of real memory used by this process. The %MEM value tends the exaggerate the cost of a process that is sharing program
            text with other processes. It does not account for times when multiple copies of a program are run and a copy of the program text is shared by all
            instances. The size of the text section is accounted for in every instance of the program. This means that if several copies of a program are run, the
            total %MEM value of all processes could exceed 100%.

       A process that has exited and has a parent that has not yet waited for the process is marked . A process that is blocked trying to exit is marked
       . The ps command attempts to determine the file name and arguments given when the process was created by memory or by the swap area. Notes:
       1    The process can change while the ps command is running. Some data displayed for defunct processes is irrelevant.
       2    The ps program examines memory to retrieve the file name and arguments used when the process was created. However, a process can destroy information,
            making this method of retrieving file name and arguments unreliable.

Flags

       The following flags are preceded by a - (minus sign):
       -A
            Writes to standard output information about all processes.
       -a
            Writes to standard output information about all processes, except the session leaders and processes not associated with a terminal.
       -c Clist
            Displays only information about processes assigned to the workload management classes listed in the Clist variable. The Clist variable is either a comma
            separated list of class names or a list of class names enclosed in double quotation marks (" "), which is separated from one another by a comma or by one
            or more spaces, or both.
       -d
            Writes information to standard output about all processes, except the session leaders.
       -e
            Writes information to standard output about all processes, except kernel processes.
       -F Format
            Same as -o Format
       -f
            Generates a full listing.
       -G Glist
            Writes information to standard output only about processes that are in the effective groups listed for the Glist variable. The Glist variable is either a
            comma-separated list of effective group identifiers or a list of effective group identifiers enclosed in double quotation marks (" ") and separated from
            one another by a comma or by one or more spaces.
       -g Glist
            Writes information to standard output only about processes that are in the process groups listed for the Glist variable. The Glist variable is either a
            comma-separated list of process group identifiers or a list of process group identifiers enclosed in double quotation marks (" ") and separated from one
            another by a comma or by one or more spaces.

       -k
            Lists kernel processes.
       -l
            Generates a long listing. See also the l flag.
       -L pidlist
            Generates a list of descendants of each and every pid that has been passed to it in the pidlist variable. The pidlist variable is a list of comma-
            separated process IDs. The list of descendants from all of the given pid is printed in the order in which they appear in the process table.
       -M
            Lists all 64 bit processes.
       -m
            Lists kernel threads as well as processes. Output lines for processes are followed by an additional output line for each kernel thread. This flag does
            not display thread-specific fields ( bnd, scount, sched, thcount, and tid), unless the appropriate -o Format flag is specified.
       -N
            Gathers no thread statistics. With this flag, ps reports those statistics that can be obtained by not traversing through the threads chain for the
            process.
       -n NameList
            Specifies an alternative system name-list file in place of the default. The operating system does not use the -n flag because information is supplied
            directly to the kernel.
       -o Format
            Displays information in the format specified by the Format variable. Multiple field specifiers can be specified for the Format variable. The Format
            variable is either a comma-separated list of field specifiers or a list of field specifiers enclosed within a set of " " (double-quotation marks) and
            separated from one another by a comma or by one or more spaces, or both.

            Each field specifier has a default header. The default header can be overridden by appending an = (equal sign) followed by the user-defined text for the
            header. The fields are written in the order specified on the command line in column format. The field widths are specified by the system to be at least
            as wide as the default or user-defined header text. If the header text is null, (such as if -o user= is specified), the field width is at least as wide
            as the default header text. If all header fields are null, no header line is written.

            The following field specifiers are recognized by the system:
              args
                   Indicates the full command name being executed. All command-line arguments are included, though truncation may occur. The default header for this
                   field is COMMAND.
              bnd
                   Indicates to which (if any) processor a process or kernel thread is bound. The default header for this field is BND.
              class
                   Indicates the workload management class assigned to the process or thread. The default header for this field is CLASS.
              comm
                   Indicates the short name of the command being executed. Command-line arguments are not included. The default header for this field is COMMAND.
              cpu
                   Determines process scheduling priority. CPU utilization of process or thread, incremented each time the system clock ticks and the process or
                   thread is found to be running. The value is decayed by the scheduler by dividing it by 2 once per second. For the sched_other policy, Large values
                   indicate a CPU intensive process and result in lower process priority whereas small values indicate an I/O intensive process and result in a more
                   favorable priority.
              dpgsz
                   Indicates the data page size of a process.
              etime
                   Indicates the elapsed time since the process started. The elapsed time is displayed in the following format:

                   [[ dd-]hh:]mm:ss

                   where dd specifies the number of days, hh specifies the number of hours, mm specifies the number of minutes, and ss specifies the number of
                   seconds. The default header for this field is ELAPSED.
              group
                   Indicates the effective group ID of the process. The textual group ID is displayed. If the textual group ID cannot be obtained, a decimal
                   representation is used. The default header for this field is GROUP.
              nice
                   Indicates the decimal value of the process nice value. The default header for this field is NI.
       -o Format (Continued)

              pcpu
                   Indicates the ratio of CPU time used to CPU time available, expressed as a percentage. The default header for this field is %CPU.
              pgid
                   Indicates the decimal value of the process group ID. The default header for this field is PGID.
              pid
                   Indicates the decimal value of the process ID. The default header for this field is PID.
              ppid
                   Indicates the decimal value of the parent process ID. The default header for this field is PPID.
              rgroup
                   Indicates the real group ID of the process. The textual group ID is displayed. If the textual group ID cannot be obtained, a decimal
                   representation is used. The default header for this field is RGROUP.
              ruser
                   Indicates the real user ID of the process. The textual user ID is displayed. If the textual user ID cannot be obtained, a decimal representation
                   is used. The default header for this field is RUSER.
              scount
                   Indicates the suspend count for a kernel thread. The default header for this field is SC.
              sched
                   Indicates the scheduling policy for a kernel thread. The default header for this field is SCH.
              spgsz
                   Indicates the stack page size of a process.
              tag
                   Indicates the Workload Manager application tag. The default header for this field is TAG. The tag is a character string up to 30 characters long
                   and may be truncated when displayed by ps. For processes that do not set their tag, this field displays as a - (hyphen).
              tcpu
                   Total CPU time. Indicates the total accumulated CPU time for a single process. The default header for this field is TCPU.
              tctime
                   Total connect time. Indicates the total amount of time that a login session can be active. This is meaningful only in the case of session leader
                   processes. The default header for this field is TCTIME.
              tdiskio
                   Total disk I/O. Indicates the total accumulated blocks of disk I/O for a single process. The default header for this field is TDISKIO.
              tpgsz
                   Indicates the text page size of a process.
              vmsize
                   Indicates the WLM virtual memory limits. When this is used, a new header, VMSIZ is displayed. VMSIZ displays the virtual memory used by the
                   process. This value is displayed in 1 MB units.
       -o Format (Continued)
              thcount
                   Indicates the number of kernel threads owned by the process. The default header for this field is THCNT.
              THREAD
                   Indicates the following fields:
                     *    User name (the uname field)
                     *    Process and parent process IDs for processes (the pid and ppid fields)
                     *    Kernel thread ID for threads (the tid field)
                     *    The state of the process or kernel thread (the S field)
                     *    The CPU utilization of the process or kernel thread (the C field)
                     *    The priority of the process or kernel thread (the PRI field)
                     *    The suspend count of the process or kernel thread (the scount field)
                     *    The wait channel of the process or kernel thread (the WCHAN field)
                     *    The flags of the process or kernel thread (the F field)
                     *    The controlling terminal of the process (the tty field)
                     *    The CPU to which the process or kernel thread is bound (the bnd field)
                     *    The command being executed by the process (the comm field).
                   Threads are not actually displayed with the -o THREAD flag, unless the -m flag is also specified.
              tid
                   Indicates the thread ID of a kernel thread. The default header for this field is TID.
              time
                   Indicates the cumulative CPU time since the process started. The time is displayed in the following format:

                   [ dd-]hh:mm:ss

                   where dd specifies the number of days, hh specifies the number of hours, mm specifies the number of minutes, and ss specifies the number of
                   seconds. The default header for this field is TIME.
              tty
                   Indicates the controlling terminal name of the process. The default header for this field is TT.
              user
                   Indicates the effective user ID of the process. The textual user ID is displayed. If the textual user ID cannot be obtained, a decimal
                   representation is used. The default header for this field is USER.
              vsz
                   Indicates, as a decimal integer, the size in kilobytes of the process in virtual memory. The default header for this field is VSZ.
       -o Format (Continued)
            Otherwise, multiple fields in a specified format can be displayed by the Format variable, including field descriptors. If field descriptors are used in
            the Format variable, it must be enclosed in double quotation marks (" "). The following table shows how field descriptors correspond to field specifiers:

            Field           Field           Default
            Descriptors     Specifiers      Headers
            %a              args            COMMAND
            %c              comm            COMMAND
            %t              etime           ELAPSED
            %D              dpgsz           DPGSZ
            %G              group           GROUP
            %n              nice            NI
            %C              pcpu            %CPU
            %r              pgid            PGID
            %p              pid             PID
            %P              ppid            PPID
            %g              rgroup          RGROUP
            %u              ruser           RUSER
            %S              spgsz           SPGSZ
            %x              time            TIME
            %T              tpgsz           TPGSZ gd
            %y              tty             TTY
            %U              user            USER
            %z              vsz             VSZ

            Each field specifier has a default header. The default header can be overridden by appending an equal sign (=) followed by the user-defined text for the
            header. The fields are written in the order specified on the command line in column format. The field widths are specified by the system to be at least
            as wide as the default or user-defined header text. If the header text is null (for example, -o user= is specified), the field width is at least as wide
            as the default header text. If all header fields are null, no header line is written.
       -o Format (Continued)
            Following is the mapping between the default headers and various field specifiers. Every entry in the Default Header column can be overridden by
            appending an equal sign (=) to the corresponding entry in the Field specifier followed by the user-defined text for the header.

            Default Header                 Field specifier
            ARGS                          "args"
            COMM                          "comm"
            COMM                          "command"
            COMM                          "ucomm"
            F_ETIME                       "etime"
            GROUP                         "group"
            GROUP                         "gname"
            GID                           "gid"
            NICE                          "nice"
            PRI                           "pri"
            NICE                          "ni"
            PCPU                          "pcpu"
            PMEM                          "pmem"
            PGID                          "pgid"
            PID                           "pid"
            PPID                          "ppid"

            RGROUP                        "rgroup"
            RGROUP                        "rgname"
            RGID                          "rgid"
            RUSER                         "ruser"
            RUSER                         "runame"
            RUID                          "ruid"
            TIME                          "time"
            TIME                          "cputime"
            TTY                           "tty"
            TTY                           "tt"
            TTY                           "tname"
            TTY                           "longtname"
            USER                          "user"
            USER                          "uname"
            UID                           "uid"
            LOGNAME                       "logname"
            STIME                         "start"
            VSZ                           "vsz"
            VSZ                           "vsize"
            RSS                           "rssize"
            FLAG                          "flag"
            STATUS                        "status"
            CP                            "cp"
            PAGEIN                        "pagein"
            WCHAN                         "wchan"
            NWCHAN                        "nwchan"
            ST                            "st"
            TID                           "tid"
            SCOUNT                        "scount"
            BIND                          "bnd"
            SCHED                         "sched"
            THCOUNT                        "thcount"
            TAG                           "tag"
            CLASS                         "class"
            TCPU                          "tcpu"
            TDISKIO                       "tdiskio"
            TCTIME                        "tctime"
            MACLAB                        "mac"
       -p Plist
            Displays only information about processes with the process numbers specified for the Plist variable. The Plist variable is either a comma separated list
            of process ID numbers or a list of process ID numbers enclosed in double quotation marks (" ") and separated from one another by a comma or by one or
            more spaces, or both.
       -P
            Displays the Project name, Project origin, and subproject identifier for the project. If the stick bit is set for the process, the project name will be
            preceded by an asterisk (*) character. The Project origin field designates the currently loaded project repository (LOCAL or LDAP).
       -t Tlist
            Displays only information about processes associated with the workstations listed in the Tlist variable. The Tlist variable is either a comma separated
            list of workstation identifiers or a list of workstation identifiers enclosed in double quotation marks (" ") and separated from one another by a comma
            or by one or more spaces, or both.
       -T pid
            Displays the process hierarchy rooted at a given pid in a tree format using ASCII art. This flag can be used in combination with the -f, -F, -o, and -l
            flags.
       -U Ulist
            Displays only information about processes with the user ID numbers or login names specified for the Ulist variable. The Ulist variable is either a
            comma-separated list of user IDs or a list of user IDs enclosed in double quotation marks (" ") and separated from one another by a comma and one or more
            spaces. In the listing, the ps command displays the numerical user ID unless the -f flag is used; then the command displays the login name. This flag is
            equivalent to the -u Ulist flag. See also the u flag.
       -u Ulist

            This flag is equivalent to the -U Ulist flag.
       -X
            Prints all available characters of each user/group name instead of truncating to the first 8 characters.
       -Z
            Displays the page size settings of processes.
              DPGSZ
                   Indicates the data page size of a process.
              SPGSZ
                   Indicates the stack page size of a process.
              TPGSZ
                   Indicates the text page size of a process.
Options

       The following options are not preceded by a minus sign (-):
       a
            Displays information about all processes with terminals (ordinarily only the user's own processes are displayed).
       c
            Displays the command name, as stored internally in the system for purposes of accounting, rather than the command parameters, which are kept in the
            process address space.
       e
            Displays the environment as well as the parameters to the command, up to a limit of 80 characters.
       ew
            Wraps display from the e flag one extra line.
       eww
            Wraps display from the e flag as many times as necessary.
       g
            Displays all processes.
       l
            Displays a long listing having the F, S, UID, PID, PPID, C, PRI, NI, ADDR, SZ, PSS, WCHAN, TTY, TIME, and CMD fields.
       n
            Displays numerical output. In a long listing, the WCHAN field is printed numerically rather than symbolically. In a user listing, the USER field is
            replaced by a UID field.
       s
            Displays the size (SSIZ) of the kernel stack of each process (for use by system maintainers) in the basic output format. This value is always 0 (zero)
            for a multi-threaded process.
       t Tty
            Displays processes whose controlling tty is the value of the Tty variable, which should be specified as printed by the ps command; that is, 0 for
            terminal /dev/tty/0, lft0 for /dev/lft0 , and pts/2 for /dev/pts/2.
       u
            Displays user-oriented output. This includes the USER, PID, %CPU, %MEM, SZ, RSS, TTY, STAT, STIME, TIME, and COMMAND fields.
       v
            Displays the PGIN, SIZE, RSS, LIM, TSIZ, TRS, %CPU, %MEM fields.
       w
            Specifies a wide-column format for output (132 columns rather than 80). If repeated, (for example, ww), uses arbitrarily wide output. This information is
            used to decide how much of long commands to print.
       x
            Displays processes without a controlling terminal in addition to processes with a controlling terminal.

Exit Status

       This command returns the following exit values:
       0
            Successful completion.
       >0
            An error occurred.

Examples
       1    To display all processes, type:

            ps -e -f
            To display all processes with expanded user name, type:

            ps -X -e -f
       2    To list processes owned by specific users, type:

            ps -f -l -ujim,jane,su
       3    To list processes that are associated with the /dev/console and /dev/tty1 ttys, type:

            ps -t console,tty/1
       4    To list processes not associated with a terminal, type:

            ps -t -
       5    To display a specified format with field specifiers, type:

            ps -o ruser,pid,ppid=parent,args

            The output is:

            RUSER   PID     parent  COMMAND
            helene  34      12      ps -o ruser,pid,ppid=parent,args
       6    To display a specified format with field descriptors, type:

            ps -o "< %u > %p %y : %a"

            The output is:

            < RUSER  >      PID     TT :    COMMAND
            < helene >      34      pts/3 : ps -o < %u > %p %y : %a
       7    To display information about processes and kernel threads controlled by the current terminal, type:

            ps -lm

            The output is similar to:

                 F S UID  PID PPID  C PRI NI ADDR  SZ WCHAN   TTY  TIME  CMD
            240003 A  26 8984 7190  1  60 20 2974 312       pts/1  0:00  -ksh
               400 S   -    -    -  1  60  -    -   -           -     -  -
            200005 A  26 9256 8984 15  67 20 18ed 164       pts/1  0:00  ps
                 0 R   -    -    - 15  67  -    -   -           -     -  -
       8    To display information about all processes and kernel threads, type:

            ps -emo THREAD

            The output is similar to:

            USER   PID  PPID  TID S  C PRI SC   WCHAN   FLAG   TTY BND  CMD
            jane  1716 19292    - A 10  60  1       * 260801 pts/7   -  biod
               -     -     - 4863 S  0  60  0 599e9d8   8400     -   -  -
               -     -     - 5537 R 10  60  1 5999e18   2420     -   3  -
            luke 19292 18524    - A  0  60  0 586ad84 200001 pts/7   -  -ksh
               -     -     - 7617 S  0  60  0 586ad84    400     -   -  -
            luke 25864 31168    - A 11  65  0       - 200001 pts/7   -  -
               -     -     - 8993 R 11  65  0       -      0     -   -  -
       9    To list all the 64-bit processes, type:

            ps -M
       10   To display the project assignment details for the processes, type:

            ps -P
       11   To display the processes' page size settings, type:

            ps -Z
            The output is similar to:

                      PID    TTY TIME DPGSZ SPGSZ TPGSZ CMD
                    41856 pts/15 0:00    4K    4K    4K ps
                    84516 pts/15 0:00    4K    4K    4K ksh

Files

       /usr/bin/ps
            Contains the ps command.
       /etc/passwd
            Specifies user ID information.
       /dev/pty*
            Indicates workstation (PTY) names.
       /dev/tty*
            Indicates workstation (TTY) names.

Related Information

       The kill command, nice command.

       Using the ps command in Performance management.

System V ps command

Syntax

       /usr/sysv/bin/ps [ -a ] [ -A ] [ -c ] [ -d ] [ -e ] [ -f ] [ -j ] [ -l ] [ -L ] [ -P ] [ -y ] [ -g pgrplist ] [ -o format ] [ -p proclist ] [ -s sidlist ] [
       -t termlist ] [ { -u | -U } uidlist ] [ -G grplist ] [ -X ]

Description

       The ps command prints information about active processes. Without flags, ps prints information about processes associated with the controlling terminal. The
       output contains the process ID, terminal identifier, cumulative runtime, and the command name. The information displayed with flags varies accordingly.

Output

       Depending on the flags used with the ps command, column headings vary for the information displayed . The headings are defined in the following list (flags
       that cause these headings to appear are shown in parentheses):

       F (-l)
            Flags (hexadecimal and additive) associated with the process, or the thread if the -L option is specified. Some of the more important F field flags
            (hexadecimal and additive) associated with processes and threads are shown below:

            F                                                   Field                                               Table
            Flags                                               Hexadecimal Value                                   Definition
            SLOAD                                               0x00000001                                          Indicates that the process is operating in core
                                                                                                                    memory.
            SNOSWAP                                             0x00000002                                          Indicates that the process cannot be swapped out.
            STRC                                                0x00000008                                          Indicates that the process is being traced.
            SKPROC                                              0x00000200                                          Indicates a Kernel process.
            SEXIT                                               0x00010000                                          Indicates that the process is exiting.
            SEXECED                                             0x00200000                                          Indicates that process has been run.
            SEXECING                                            0x01000000                                          Indicates that the process is execing (performing
                                                                                                                    an exec).
            TKTHREAD                                            0x00001000                                          Indicates that the thread is a kernel only
                                                                                                                    thread.

            Note: You can see the definitions of all process and thread flags by referring to the p_flags and t_flags fields in the /usr/include/sys/proc.h and
            /usr/include/sys/thread.h files respectively.
       S (-l)
            The state of the process or kernel thread :

            For processes:
              O
                   Nonexistent
              A
                   Active
              W
                   Swapped
              I
                   Idle
              Z
                   Canceled
              T
                   Stopped
            For kernel threads:
              O
                   Nonexistent
              R
                   Running
              S
                   Sleeping
              W
                   Swapped
              Z
                   Canceled
              T
                   Stopped
       UID (-f,- l)
            The user ID number of the process (the login name is printed under the -f option).
       PID (all)
            The process ID of the process.
       PPID (-f,-l)
            The process ID of the parent process.
       CLS (-c)
            Scheduling class for the process . Printed only when the -c flag is used.
       NI (-l)
            The nice value of the process used in calculating priority for the sched_other policy.
       PRI (-c, -l)

            The priority of the process or kernel thread. Higher numbers mean lower priority.
       ADDR (-l)
            Contains the segment number of the process stack, if normal; if a kernel process, the address of the preprocess data area.
       SZ (-l)
            The size in pages of the core image of the process.
       WCHAN(-l)
            The event for which the process or kernel thread is waiting or sleeping. For a kernel thread, this field is blank if the kernel thread is running. For a
            process, the wait channel is defined as the wait channel of the sleeping kernel thread if only one kernel thread is sleeping; otherwise a star is
            displayed.
       STIME (-f,-u)
            The starting time of the process. The LANG environment variables control the appearance of this field.
       TTY (all)
            The controlling workstation for the process:
              -
                   The process is not associated with a workstation.
              ?
                   Unknown
       TIME (all)
            The total runtime for the process. The time is displayed in the format of mm:ss or mmmm:ss if the runtime reaches 100 minutes, which is different from
            the displayed format if you use the -o time flag.
       LTIME (-L)
            The runtime for an individual LWP.
       CMD (all)
            Contains the command name. The full command name and its parameters are displayed with the -f flag.
       LWP (-L)
            The tid of the kernel thread.
       NLWP(-Lf)
            The number of kernel threads in the process.
       PSR (-P)
            The logical processor number of the processor to which the kernel thread is bound (if any). For a process, this field is shown if all its threads are
            bound to the same processor.
       RSS (-ly)
            The real memory (resident set) size of the process in pages.

Format

       The following list describes the field specifiers recognized by the system. These field specifiers can be used with the -o flag to specify the format for the
       output of the ps command.

       The field specifiers recognized by the system are:
       addr
            Indicates the segment number of the process stack, if normal; if a kernel process, the address of the preprocess data area. The default header for this
            field is ADDR.
       args
            Indicates the full command name being executed. All command line arguments are included, though truncation may occur. The default header for this field
            is COMMAND.
       c
            CPU utilization of process or thread, incremented each time the system clock ticks and the process or thread is found to be running. The value is decayed
            by the scheduler by dividing it by 2 once per second. For the sched_other policy, CPU utilization is used in determining process scheduling priority.
            Large values indicate a CPU intensive process and result in lower process priority whereas small values indicate an I/O intensive process and result in a
            more favorable priority. The default header for this field is C.
       class
            Indicates the scheduling policy for a kernel thread. The policies are sched_other , sched_fifo and sched_rr. The default header for this field is CLS.
       comm
            Indicates the short name of the command being executed. Command line arguments are not included. The default header for this field is COMMAND.
       etime
            Indicates the elapsed time since the process started. The elapsed time is displayed in the format

            [[ dd -] hh: ]mm :ss

            where dd specifies the number of days, hh specifies the number of hours, mm specifies the number of minutes, and ss specifies the number of seconds.

            The default header for this field is ELAPSED.
       f
            Indicates flags (hexadecimal and additive) associated with the process. The default header for this field is COMMAND.
       fname
            Indicates the first 8 bytes of the base name of the process's executable file. The default header for this field is COMMAND.
       gid
            Indicates the effective group ID number of the process as a decimal integer. The default header for this field is GID. The login name is printed under
            the -f option.
       group
            Indicates the effective group ID of the process. The textual group ID is displayed. If the textual group ID cannot be obtained, a decimal representation
            is used. The default header for this field is GROUP.
       lwp
            Indicates the thread ID of the kernel thread. The default header for this field is TID.
       nice
            Indicates the decimal value of the process nice value. The default header for this field is NI.
       nlwp
            Indicates the number of kernel threads owned by the process. The default header for this field is THCNT.
       pcpu
            Indicates the ratio of CPU time used to CPU time available, expressed as a percentage. The default header for this field is %CPU.
       pgid
            Indicates the decimal value of the process group ID. The default header for this field is PGID.
       pid
            Indicates the decimal value of the process ID. The default header for this field is PID.
       pmem
            Indicates the percentage of real memory used by this process. The default header for this field is %MEM.
       ppid
            Indicates the decimal value of the parent process ID. The default header for this field is PPID.
       pri
            Indicates the priority of the process or kernel thread ; higher numbers mean lower priority. The default header for this field is PRI.
       psr
            Indicates the logical processor number of the processor to which the kernel thread is bound (if any). The default header for this field is PSR.
       rgid
            Indicates the real group ID number of the process as a decimal integer. The default header for this field is RGID.
       rgroup
            Indicates the real group ID of the process. The textual group ID is displayed. If the textual group ID cannot be obtained, a decimal representation is
            used. The default header for this field is RGROUP.
       rss
            Indicates the real memory (resident set) size of the process (in 1 KB units). The default header for this field is RSS.
       ruid
            Indicates the real user ID number of the process as a decimal integer. The default header for this field is RUID.
       ruser
            Indicates the real user ID of the process. The textual user ID is displayed. If the textual user ID cannot be obtained, a decimal representation is used.
            The default header for this field is RUSER.
       s
            Indicates the state of the process. The default header for this field is S.
       sid
            Indicates the process ID of the session leader. The default header for this field is SID.
       stime
            Indicates the starting time of the process. The LANG environment variables control the appearance of this field. The default header for this field is
            STIME.
       time
            Indicates the cumulative CPU time since the process started. The time is displayed in the same format as in etime. The default header for this field is
            TIME.
       tty
            Indicates the controlling terminal name of the process. The default header for this field is TT.
       uid

            Indicates the effective user ID number of the process as a decimal integer. The default header for this field is UID.
       user
            Indicates the effective user ID of the process. The textual user ID is displayed. If the textual user ID cannot be obtained, a decimal representation is
            used. The default header for this field is USER.
       vsz
            Indicates, as a decimal integer, the size in kilobytes of the core image of the process. The default header for this field is VSZ.
       wchan
            Indicates the event for which the process or kernel thread is waiting or sleeping. For a kernel thread, this field is blank if the kernel thread is
            running. For a process, the wait channel is defined as the wait channel of the sleeping kernel thread if only one kernel thread is sleeping; otherwise a
            star is displayed.

            The default header for this field is WCHAN.

Flags

       Some flags accept lists as arguments. Items in a list can be either separated by commas or else enclosed in double quotes and separated by commas or spaces.
       Values for proclist and pgrplist must be numeric.
       -a
            Writes to standard output information about all processes, except the session leaders and processes not associated with a terminal.
       -A
            Writes to standard output information about all processes.
       -c
            Prints information in a format that reflects scheduler properties. The -c flag affects the output of the -f and -l flags, as described below.
       -d
            Writes to standard output information about all processes, except the session leaders.
       -e
            Writes to standard output information about all processes, except kernel processes.
       -f
            Generates a full listing.
       -g pgrplist
            Writes to standard output information only about processes that are in the process groups specified by pgrplist. Values for pgrplist must be numeric.
       -G grplist
            Writes to standard output information only about processes that are in the process groups specified by grplist. The -G flag accepts group names.
       -j
            Displays session ID and process group ID.
       -l
            Generates a long listing.
       -L
            Prints status of active threads within a process.
       -o format
            Displays information in the format specified by format. Multiple field specifiers can be specified for the format variable. The field specifiers that can
            be used with the -o flag are described above in the Format section.
       -p proclist
            Displays information only about processes with the process numbers specified by proclist. Values for proclist must be numeric.
       -P
            Displays the logical processor number of the processor to which the primary kernel thread of the process is bound (if any).
       -s sidlist
            Displays all processes whose session leader's IDs are specified by sidlist.
       -t termlist
            Displays information only about processes associated with the terminals specified by termlist.
       -u uidlist
            Displays information only about processes with the user ID numbers or login names specified by uidlist.
       -U uidlist
            Displays information only about processes with the user ID numbers or login names specified by uidlist.
       -X
            Prints the full user name or group name. The name is not truncated.
       -y
            When combined with the -l option, changes the long listing so that it prints the "RSS'' and "SZ'' fields in kilobytes and does not print the "F'' and
            "ADDR'' fields.

Exit Status

       This command returns the following exit values:
       0
            Successful completion.
       >0
            An error occurred.

Examples
       1    To display all processes, enter:

            ps -e -f
       2    To list processes owned by the user 'guest', enter:

            ps -f -l -u guest
       3    To list processes that are associated with the /dev/pts/0 and /dev/pts/1 terminals, enter:

            ps -t pts/0,pts/1
       4    To list processes not associated with a terminal, enter:

            ps -t -
       5    To display a specified format with field specifiers, enter:

            ps -o ruser,pid,ppid,args
       6    To display information about all kernel threads in a process, enter:

            ps -L
       7    To display session ID and process group IDs of all the processes, enter:

            ps -jA
       8    To display the scheduling class and priority of processes, enter:

            ps -c -l
       9    To display information about kernel threads and the number of kernel threads in a process, enter:

            ps -L -f
       10   To display the processor to which the process or kernel thread is bound to, enter:

            ps  -P
       11   To print an ASCII art for a given process (inetd in the example below), enter :

            ps -T 14220
            Output will look similar to the following:

                 PID    TTY  TIME CMD
               14220      -  0:00 inetd
               16948      -  0:00    |/--telnetd
               32542  pts/4  0:00    |    /--ksh
               26504      -  0:00    |/--telnetd
               41272  pts/5  0:00    |    /--ksh
               26908  pts/5  0:00    |        /--vi
               28602      -  0:00    |/--telnetd
               24830  pts/0  0:00    |    /--ksh
              676416  pts/0  0:00    |        /--ksh
               29984      -  0:00    |/--telnetd
               38546  pts/6  0:00    |    /--ksh
               32126      -  0:00    |/--telnetd
               11162  pts/7  0:00    |    /--ksh
               34466      -  0:00    |/--rpc.ttdbserver

               35750      -  0:00    |/--telnetd
               23612  pts/3  0:00    |    /--ksh
               36294      -  0:00    |/--telnetd
               38096  pts/8  0:00    |    /--ksh
               39740      -  0:00    |/--telnetd
               42226  pts/9  0:01    |    /--ksh
               40632      -  0:00    |/--telnetd
               40232  pts/2  0:00    |    /--ksh
               32910  pts/2  0:00    |        /--dbx
              987990  pts/2  0:00    |            /--a.out
               40722      -  0:00    |/--telnetd
               16792 pts/10  0:00    |    /--ksh
               37886 pts/10  0:00    |        /--ps
              105716      -  0:00     /--telnetd
               29508  pts/1  0:00         /--ksh
               39478  pts/1  0:00             /--ksh
               38392  pts/1  0:00                 /--vi
       12   To print information about all processes rooted at a given pid, enter:

            ps -fL 14220
            Output will look similar to the following:

              UID   PID  PPID   C    STIME    TTY  TIME CMD
            root 14220  8676   0   Apr 07      -  0:00 /usr/sbin/inetd
            root 16948 14220   0   Apr 06      -  0:00 telnetd -a
            root 23612 35750   0   Apr 10  pts/3  0:00 -ksh
            root 24830 28602   1 18:30:56  pts/0  0:00 -ksh
            root 28602 14220   0 18:30:55      -  0:00 telnetd -a
            root 32542 16948   0   Apr 06  pts/4  0:00 -ksh
            root 34466 14220   0   Apr 10      -  0:00 rpc.ttdbserver 100083 1
            root 35750 14220   0   Apr 10      -  0:00 telnetd -a
            root 40228 24830   8 18:36:01  pts/0  0:00 ps -fL 14220
       13   To display all processes with expanded user name, type:

            ps -X -e -f

Files

       /usr/sysv/bin/ps
            Contains the System V R4 ps command.
       /etc/passwd
            Contains the user ID information.
       /dev/pty*
            Indicates workstation (PTY ) names.
       /dev/tty*
            Indicates workstation (TTY ) names.

Related Information

       The kill command, nice command.

你可能感兴趣的:(Linux,IBM,AIX)