Android ps命令执行后的各项参数含义

直接输入ps后可以看到如下信息：

1. # ps
2. ps
3. USER     PID   PPID  VSIZE  RSS     WCHAN    PC         NAME
4. root      1     0     276    188   c0099f1c 000086e8 S /init
5. root      2     0     0      0     c004df64 00000000 S kthreadd
6. root      3     2     0      0     c003fa28 00000000 S ksoftirqd/0
7. root      4     2     0      0     c004abc0 00000000 S events/0
8. root      5     2     0      0     c004abc0 00000000 S khelper
9. root      6     2     0      0     c004abc0 00000000 S suspend
10. root      7     2     0      0     c004abc0 00000000 S kblockd/0
11. root      8     2     0      0     c004abc0 00000000 S cqueue
12. root      9     2     0      0     c01780d0 00000000 S kseriod
13. root      10    2     0      0     c004abc0 00000000 S kmmcd
14. root      11    2     0      0     c006efa8 00000000 S pdflush
15. root      12    2     0      0     c006efa8 00000000 S pdflush
16. root      13    2     0      0     c0073480 00000000 S kswapd0
17. root      14    2     0      0     c004abc0 00000000 S aio/0
18. root      22    2     0      0     c0175900 00000000 S mtdblockdc

那么这些项各代表着什么意思呢？

1. USER：  进程的当前用户；
2. PID   ： 毫无疑问, process ID的缩写，也就进程号；
3. PPID  ：process parent ID，父进程ID
4. VSIZE  ： virtual size，进程虚拟地址空间大小；
5. RSS    ： 进程正在使用的物理内存的大小；
6. WCHAN  ：进程如果处于休眠状态的话，在内核中的地址；
7. PC  ： program counter，
8. NAME: process name，进程的名称

对比linux下的参数信息：

1. root@long-desktop:~# ps aux
2. USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
3. root         1  0.0  0.2   2804  1684 ?        Ss   21:11   0:01 /sbin/init
4. root         2  0.0  0.0      0     0 ?        S    21:11   0:00 [kthreadd]
5. root      2286  0.0  0.4   8888  3172 ?        Ss   21:52   0:00 sshd: root@pts/0
6. root      2352  0.0  0.2   4684  2048 pts/0    Ss+  21:52   0:00 -bash
7. root      2454  0.4  0.4   8888  3164 ?        Rs   22:06   0:00 sshd: root@pts/1
8. root      2518  0.1  0.2   4684  2004 pts/1    Ss   22:06   0:00 -bash
9. root      2551  0.0  0.1   2736  1088 pts/1    R+   22:06   0:00 ps aux

在Linux下ps命令各项含义如下所示：

• %CPU 进程的cpu占用率
• %MEM 进程的内存占用率
• VSZ 进程所使用的虚存的大小
• RSS 进程使用的驻留集大小或者是实际内存的大小
• TTY 与进程关联的终端（tty）
• STAT 检查的状态：进程状态使用字符表示的，如R（running正在运行或准备运行）、S（sleeping睡眠）、I（idle空闲）、Z (僵死)、D（不可中断的睡眠，通常是I/O）、P（等待交换页）、W（换出,表示当前页面不在内存）、N（低优先级任务）T(terminate终 止)、W has no resident pages
• START （进程启动时间和日期）
• TIME ;（进程使用的总cpu时间）
• COMMAND （正在执行的命令行命令）
• NI (nice)优先级
• PRI 进程优先级编号
• PPID 父进程的进程ID（parent process id）
• SID 会话ID（session id）
• WCHAN 进程正在睡眠的内核函数名称；该函数的名称是从/root/system.map文件中获得的。
• FLAGS 与进程相关的数字标识

源码如下：

android下ps命令的源码的位置：android/system/core/toolbox/ps.c，其实现如下：

1. int ps_main(int argc, char **argv)
2. {
3. DIR *d;
4. struct dirent *de;
5. char *namefilter = 0;
6. int pidfilter = 0;
7. int threads = 0;
8. d = opendir("/proc");
9. if(d == 0) return -1;
10. while(argc > 1){
11. if(!strcmp(argv[1],"-t")) {
12. threads = 1;
13. } else if(!strcmp(argv[1],"-x")) {
14. display_flags |= SHOW_TIME;
15. } else if(!strcmp(argv[1],"-p")) {
16. display_flags |= SHOW_PRIO;
17. }  else if(isdigit(argv[1][0])){
18. pidfilter = atoi(argv[1]);
19. } else {
20. namefilter = argv[1];
21. }
22. argc--;
23. argv++;
24. }
25. printf("USER     PID   PPID  VSIZE RSS   %sWCHAN    PC         NAME\n",
26. (display_flags&SHOW_PRIO)?"PRIO  NICE  RTPRI SCHED ":"");
27. while((de = readdir(d)) != 0){
28. if(isdigit(de->d_name[0])){
29. int pid = atoi(de->d_name);
30. if(!pidfilter || (pidfilter == pid)) {
31. ps_line(pid, 0, namefilter);
32. if(threads) ps_threads(pid, namefilter);
33. }
34. }
35. }
36. closedir(d);
37. return 0;
38. }

每一行数据是如何获得的：

1. static int ps_line(int pid, int tid, char *namefilter)
2. {
3. char statline[1024];
4. char cmdline[1024];
5. char user[32];
6. struct stat stats;
7. int fd, r;
8. char *ptr, *name, *state;
9. int ppid, tty;
10. unsigned wchan, rss, vss, eip;
11. unsigned utime, stime;
12. int prio, nice, rtprio, sched;
13. struct passwd *pw;
14. sprintf(statline, "/proc/%d", pid);
15. stat(statline, &stats);
16. if(tid) {
17. sprintf(statline, "/proc/%d/task/%d/stat", pid, tid);
18. cmdline[0] = 0;
19. } else {
20. sprintf(statline, "/proc/%d/stat", pid);
21. sprintf(cmdline, "/proc/%d/cmdline", pid);
22. fd = open(cmdline, O_RDONLY);
23. if(fd == 0) {
24. r = 0;
25. } else {
26. r = read(fd, cmdline, 1023);
27. close(fd);
28. if(r < 0) r = 0;
29. }
30. cmdline[r] = 0;
31. }
32. fd = open(statline, O_RDONLY);
33. if(fd == 0) return -1;
34. r = read(fd, statline, 1023);
35. close(fd);
36. if(r < 0) return -1;
37. statline[r] = 0;
38. ptr = statline;
39. nexttok(&ptr); // skip pid
40. ptr++;          // skip "("
41. name = ptr;
42. ptr = strrchr(ptr, ')'); // Skip to *last* occurence of ')',
43. *ptr++ = '\0';           // and null-terminate name.
44. ptr++;          // skip " "
45. state = nexttok(&ptr);
46. ppid = atoi(nexttok(&ptr));
47. nexttok(&ptr); // pgrp
48. nexttok(&ptr); // sid
49. tty = atoi(nexttok(&ptr));
50. nexttok(&ptr); // tpgid
51. nexttok(&ptr); // flags
52. nexttok(&ptr); // minflt
53. nexttok(&ptr); // cminflt
54. nexttok(&ptr); // majflt
55. nexttok(&ptr); // cmajflt
56. #if 1
57. utime = atoi(nexttok(&ptr));
58. stime = atoi(nexttok(&ptr));
59. #else
60. nexttok(&ptr); // utime
61. nexttok(&ptr); // stime
62. #endif
63. nexttok(&ptr); // cutime
64. nexttok(&ptr); // cstime
65. prio = atoi(nexttok(&ptr));
66. nice = atoi(nexttok(&ptr));
67. nexttok(&ptr); // threads
68. nexttok(&ptr); // itrealvalue
69. nexttok(&ptr); // starttime
70. vss = strtoul(nexttok(&ptr), 0, 10); // vsize
71. rss = strtoul(nexttok(&ptr), 0, 10); // rss
72. nexttok(&ptr); // rlim
73. nexttok(&ptr); // startcode
74. nexttok(&ptr); // endcode
75. nexttok(&ptr); // startstack
76. nexttok(&ptr); // kstkesp
77. eip = strtoul(nexttok(&ptr), 0, 10); // kstkeip
78. nexttok(&ptr); // signal
79. nexttok(&ptr); // blocked
80. nexttok(&ptr); // sigignore
81. nexttok(&ptr); // sigcatch
82. wchan = strtoul(nexttok(&ptr), 0, 10); // wchan
83. nexttok(&ptr); // nswap
84. nexttok(&ptr); // cnswap
85. nexttok(&ptr); // exit signal
86. nexttok(&ptr); // processor
87. rtprio = atoi(nexttok(&ptr)); // rt_priority
88. sched = atoi(nexttok(&ptr)); // scheduling policy
89. tty = atoi(nexttok(&ptr));
90. if(tid != 0) {
91. ppid = pid;
92. pid = tid;
93. }
94. pw = getpwuid(stats.st_uid);
95. if(pw == 0) {
96. sprintf(user,"%d",(int)stats.st_uid);
97. } else {
98. strcpy(user,pw->pw_name);
99. }
100. if(!namefilter || !strncmp(name, namefilter, strlen(namefilter))) {
101. printf("%-8s %-5d %-5d %-5d %-5d", user, pid, ppid, vss / 1024, rss * 4);
102. if(display_flags&SHOW_PRIO)
103. printf(" %-5d %-5d %-5d %-5d", prio, nice, rtprio, sched);
104. printf(" %08x %08x %s %s", wchan, eip, state, cmdline[0] ? cmdline : name);
105. if(display_flags&SHOW_TIME)
106. printf(" (u:%d, s:%d)", utime, stime);
107. printf("\n");
108. }
109. return 0;
110. }