procps.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660
  1. /* vi: set sw=4 ts=4: */
  2. /*
  3. * Utility routines.
  4. *
  5. * Copyright 1998 by Albert Cahalan; all rights reserved.
  6. * Copyright (C) 2002 by Vladimir Oleynik <dzo@simtreas.ru>
  7. * SELinux support: (c) 2007 by Yuichi Nakamura <ynakam@hitachisoft.jp>
  8. *
  9. * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  10. */
  11. #include "libbb.h"
  12. typedef struct id_to_name_map_t {
  13. uid_t id;
  14. char name[USERNAME_MAX_SIZE];
  15. } id_to_name_map_t;
  16. typedef struct cache_t {
  17. id_to_name_map_t *cache;
  18. int size;
  19. } cache_t;
  20. static cache_t username, groupname;
  21. static void clear_cache(cache_t *cp)
  22. {
  23. free(cp->cache);
  24. cp->cache = NULL;
  25. cp->size = 0;
  26. }
  27. void FAST_FUNC clear_username_cache(void)
  28. {
  29. clear_cache(&username);
  30. clear_cache(&groupname);
  31. }
  32. #if 0 /* more generic, but we don't need that yet */
  33. /* Returns -N-1 if not found. */
  34. /* cp->cache[N] is allocated and must be filled in this case */
  35. static int get_cached(cache_t *cp, uid_t id)
  36. {
  37. int i;
  38. for (i = 0; i < cp->size; i++)
  39. if (cp->cache[i].id == id)
  40. return i;
  41. i = cp->size++;
  42. cp->cache = xrealloc_vector(cp->cache, 2, i);
  43. cp->cache[i++].id = id;
  44. return -i;
  45. }
  46. #endif
  47. static char* get_cached(cache_t *cp, uid_t id,
  48. char* FAST_FUNC x2x_utoa(uid_t id))
  49. {
  50. int i;
  51. for (i = 0; i < cp->size; i++)
  52. if (cp->cache[i].id == id)
  53. return cp->cache[i].name;
  54. i = cp->size++;
  55. cp->cache = xrealloc_vector(cp->cache, 2, i);
  56. cp->cache[i].id = id;
  57. /* Never fails. Generates numeric string if name isn't found */
  58. safe_strncpy(cp->cache[i].name, x2x_utoa(id), sizeof(cp->cache[i].name));
  59. return cp->cache[i].name;
  60. }
  61. const char* FAST_FUNC get_cached_username(uid_t uid)
  62. {
  63. return get_cached(&username, uid, uid2uname_utoa);
  64. }
  65. const char* FAST_FUNC get_cached_groupname(gid_t gid)
  66. {
  67. return get_cached(&groupname, gid, gid2group_utoa);
  68. }
  69. #define PROCPS_BUFSIZE 1024
  70. static int read_to_buf(const char *filename, void *buf)
  71. {
  72. int fd;
  73. /* open_read_close() would do two reads, checking for EOF.
  74. * When you have 10000 /proc/$NUM/stat to read, it isn't desirable */
  75. ssize_t ret = -1;
  76. fd = open(filename, O_RDONLY);
  77. if (fd >= 0) {
  78. ret = read(fd, buf, PROCPS_BUFSIZE-1);
  79. close(fd);
  80. }
  81. ((char *)buf)[ret > 0 ? ret : 0] = '\0';
  82. return ret;
  83. }
  84. static procps_status_t* FAST_FUNC alloc_procps_scan(void)
  85. {
  86. unsigned n = getpagesize();
  87. procps_status_t* sp = xzalloc(sizeof(procps_status_t));
  88. sp->dir = xopendir("/proc");
  89. while (1) {
  90. n >>= 1;
  91. if (!n) break;
  92. sp->shift_pages_to_bytes++;
  93. }
  94. sp->shift_pages_to_kb = sp->shift_pages_to_bytes - 10;
  95. return sp;
  96. }
  97. void FAST_FUNC free_procps_scan(procps_status_t* sp)
  98. {
  99. closedir(sp->dir);
  100. #if ENABLE_FEATURE_SHOW_THREADS
  101. if (sp->task_dir)
  102. closedir(sp->task_dir);
  103. #endif
  104. free(sp->argv0);
  105. free(sp->exe);
  106. IF_SELINUX(free(sp->context);)
  107. free(sp);
  108. }
  109. #if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
  110. static unsigned long fast_strtoul_16(char **endptr)
  111. {
  112. unsigned char c;
  113. char *str = *endptr;
  114. unsigned long n = 0;
  115. /* Need to stop on both ' ' and '\n' */
  116. while ((c = *str++) > ' ') {
  117. c = ((c|0x20) - '0');
  118. if (c > 9)
  119. /* c = c + '0' - 'a' + 10: */
  120. c = c - ('a' - '0' - 10);
  121. n = n*16 + c;
  122. }
  123. *endptr = str; /* We skip trailing space! */
  124. return n;
  125. }
  126. #endif
  127. #if ENABLE_FEATURE_FAST_TOP || ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
  128. /* We cut a lot of corners here for speed */
  129. static unsigned long fast_strtoul_10(char **endptr)
  130. {
  131. unsigned char c;
  132. char *str = *endptr;
  133. unsigned long n = *str - '0';
  134. /* Need to stop on both ' ' and '\n' */
  135. while ((c = *++str) > ' ')
  136. n = n*10 + (c - '0');
  137. *endptr = str + 1; /* We skip trailing space! */
  138. return n;
  139. }
  140. # if ENABLE_FEATURE_FAST_TOP
  141. static long fast_strtol_10(char **endptr)
  142. {
  143. if (**endptr != '-')
  144. return fast_strtoul_10(endptr);
  145. (*endptr)++;
  146. return - (long)fast_strtoul_10(endptr);
  147. }
  148. # endif
  149. static char *skip_fields(char *str, int count)
  150. {
  151. do {
  152. while (*str++ != ' ')
  153. continue;
  154. /* we found a space char, str points after it */
  155. } while (--count);
  156. return str;
  157. }
  158. #endif
  159. #if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
  160. int FAST_FUNC procps_read_smaps(pid_t pid, struct smaprec *total,
  161. void (*cb)(struct smaprec *, void *), void *data)
  162. {
  163. FILE *file;
  164. struct smaprec currec;
  165. char filename[sizeof("/proc/%u/smaps") + sizeof(int)*3];
  166. char buf[PROCPS_BUFSIZE];
  167. #if !ENABLE_PMAP
  168. void (*cb)(struct smaprec *, void *) = NULL;
  169. void *data = NULL;
  170. #endif
  171. sprintf(filename, "/proc/%u/smaps", (int)pid);
  172. file = fopen_for_read(filename);
  173. if (!file)
  174. return 1;
  175. memset(&currec, 0, sizeof(currec));
  176. while (fgets(buf, PROCPS_BUFSIZE, file)) {
  177. // Each mapping datum has this form:
  178. // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
  179. // Size: nnn kB
  180. // Rss: nnn kB
  181. // .....
  182. char *tp, *p;
  183. #define SCAN(S, X) \
  184. if ((tp = is_prefixed_with(buf, S)) != NULL) { \
  185. tp = skip_whitespace(tp); \
  186. total->X += currec.X = fast_strtoul_10(&tp); \
  187. continue; \
  188. }
  189. if (cb) {
  190. SCAN("Pss:" , smap_pss );
  191. SCAN("Swap:" , smap_swap );
  192. }
  193. SCAN("Private_Dirty:", private_dirty);
  194. SCAN("Private_Clean:", private_clean);
  195. SCAN("Shared_Dirty:" , shared_dirty );
  196. SCAN("Shared_Clean:" , shared_clean );
  197. #undef SCAN
  198. tp = strchr(buf, '-');
  199. if (tp) {
  200. // We reached next mapping - the line of this form:
  201. // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
  202. if (cb) {
  203. /* If we have a previous record, there's nothing more
  204. * for it, call the callback and clear currec
  205. */
  206. if (currec.smap_size)
  207. cb(&currec, data);
  208. free(currec.smap_name);
  209. }
  210. memset(&currec, 0, sizeof(currec));
  211. *tp = ' ';
  212. tp = buf;
  213. currec.smap_start = fast_strtoul_16(&tp);
  214. currec.smap_size = (fast_strtoul_16(&tp) - currec.smap_start) >> 10;
  215. strncpy(currec.smap_mode, tp, sizeof(currec.smap_mode)-1);
  216. // skipping "rw-s FILEOFS M:m INODE "
  217. tp = skip_whitespace(skip_fields(tp, 4));
  218. // filter out /dev/something (something != zero)
  219. if (!is_prefixed_with(tp, "/dev/") || strcmp(tp, "/dev/zero\n") == 0) {
  220. if (currec.smap_mode[1] == 'w') {
  221. currec.mapped_rw = currec.smap_size;
  222. total->mapped_rw += currec.smap_size;
  223. } else if (currec.smap_mode[1] == '-') {
  224. currec.mapped_ro = currec.smap_size;
  225. total->mapped_ro += currec.smap_size;
  226. }
  227. }
  228. if (strcmp(tp, "[stack]\n") == 0)
  229. total->stack += currec.smap_size;
  230. if (cb) {
  231. p = skip_non_whitespace(tp);
  232. if (p == tp) {
  233. currec.smap_name = xstrdup(" [ anon ]");
  234. } else {
  235. *p = '\0';
  236. currec.smap_name = xstrdup(tp);
  237. }
  238. }
  239. total->smap_size += currec.smap_size;
  240. }
  241. }
  242. fclose(file);
  243. if (cb) {
  244. if (currec.smap_size)
  245. cb(&currec, data);
  246. free(currec.smap_name);
  247. }
  248. return 0;
  249. }
  250. #endif
  251. procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
  252. {
  253. if (!sp)
  254. sp = alloc_procps_scan();
  255. for (;;) {
  256. struct dirent *entry;
  257. char buf[PROCPS_BUFSIZE];
  258. long tasknice;
  259. unsigned pid;
  260. int n;
  261. char filename[sizeof("/proc/%u/task/%u/cmdline") + sizeof(int)*3 * 2];
  262. char *filename_tail;
  263. #if ENABLE_FEATURE_SHOW_THREADS
  264. if (sp->task_dir) {
  265. entry = readdir(sp->task_dir);
  266. if (entry)
  267. goto got_entry;
  268. closedir(sp->task_dir);
  269. sp->task_dir = NULL;
  270. }
  271. #endif
  272. entry = readdir(sp->dir);
  273. if (entry == NULL) {
  274. free_procps_scan(sp);
  275. return NULL;
  276. }
  277. IF_FEATURE_SHOW_THREADS(got_entry:)
  278. pid = bb_strtou(entry->d_name, NULL, 10);
  279. if (errno)
  280. continue;
  281. #if ENABLE_FEATURE_SHOW_THREADS
  282. if ((flags & PSSCAN_TASKS) && !sp->task_dir) {
  283. /* We found another /proc/PID. Do not use it,
  284. * there will be /proc/PID/task/PID (same PID!),
  285. * so just go ahead and dive into /proc/PID/task. */
  286. sprintf(filename, "/proc/%u/task", pid);
  287. /* Note: if opendir fails, we just go to next /proc/XXX */
  288. sp->task_dir = opendir(filename);
  289. sp->main_thread_pid = pid;
  290. continue;
  291. }
  292. #endif
  293. /* After this point we can:
  294. * "break": stop parsing, return the data
  295. * "continue": try next /proc/XXX
  296. */
  297. memset(&sp->vsz, 0, sizeof(*sp) - offsetof(procps_status_t, vsz));
  298. sp->pid = pid;
  299. if (!(flags & ~PSSCAN_PID))
  300. break; /* we needed only pid, we got it */
  301. #if ENABLE_SELINUX
  302. if (flags & PSSCAN_CONTEXT) {
  303. if (getpidcon(sp->pid, &sp->context) < 0)
  304. sp->context = NULL;
  305. }
  306. #endif
  307. #if ENABLE_FEATURE_SHOW_THREADS
  308. if (sp->task_dir)
  309. filename_tail = filename + sprintf(filename, "/proc/%u/task/%u/", sp->main_thread_pid, pid);
  310. else
  311. #endif
  312. filename_tail = filename + sprintf(filename, "/proc/%u/", pid);
  313. if (flags & PSSCAN_UIDGID) {
  314. struct stat sb;
  315. if (stat(filename, &sb))
  316. continue; /* process probably exited */
  317. /* Effective UID/GID, not real */
  318. sp->uid = sb.st_uid;
  319. sp->gid = sb.st_gid;
  320. }
  321. /* These are all retrieved from proc/NN/stat in one go: */
  322. if (flags & (PSSCAN_PPID | PSSCAN_PGID | PSSCAN_SID
  323. | PSSCAN_COMM | PSSCAN_STATE
  324. | PSSCAN_VSZ | PSSCAN_RSS
  325. | PSSCAN_STIME | PSSCAN_UTIME | PSSCAN_START_TIME
  326. | PSSCAN_TTY | PSSCAN_NICE
  327. | PSSCAN_CPU)
  328. ) {
  329. int s_idx;
  330. char *cp, *comm1;
  331. int tty;
  332. #if !ENABLE_FEATURE_FAST_TOP
  333. unsigned long vsz, rss;
  334. #endif
  335. /* see proc(5) for some details on this */
  336. strcpy(filename_tail, "stat");
  337. n = read_to_buf(filename, buf);
  338. if (n < 0)
  339. continue; /* process probably exited */
  340. cp = strrchr(buf, ')'); /* split into "PID (cmd" and "<rest>" */
  341. /*if (!cp || cp[1] != ' ')
  342. continue;*/
  343. cp[0] = '\0';
  344. BUILD_BUG_ON(sizeof(sp->comm) < 16);
  345. comm1 = strchr(buf, '(');
  346. /*if (comm1)*/
  347. safe_strncpy(sp->comm, comm1 + 1, sizeof(sp->comm));
  348. #if !ENABLE_FEATURE_FAST_TOP
  349. n = sscanf(cp+2,
  350. "%c %u " /* state, ppid */
  351. "%u %u %d %*s " /* pgid, sid, tty, tpgid */
  352. "%*s %*s %*s %*s %*s " /* flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
  353. "%lu %lu " /* utime, stime */
  354. "%*s %*s %*s " /* cutime, cstime, priority */
  355. "%ld " /* nice */
  356. "%*s %*s " /* timeout, it_real_value */
  357. "%lu " /* start_time */
  358. "%lu " /* vsize */
  359. "%lu " /* rss */
  360. # if ENABLE_FEATURE_TOP_SMP_PROCESS
  361. "%*s %*s %*s %*s %*s %*s " /*rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
  362. "%*s %*s %*s %*s " /*signal, blocked, sigignore, sigcatch */
  363. "%*s %*s %*s %*s " /*wchan, nswap, cnswap, exit_signal */
  364. "%d" /*cpu last seen on*/
  365. # endif
  366. ,
  367. sp->state, &sp->ppid,
  368. &sp->pgid, &sp->sid, &tty,
  369. &sp->utime, &sp->stime,
  370. &tasknice,
  371. &sp->start_time,
  372. &vsz,
  373. &rss
  374. # if ENABLE_FEATURE_TOP_SMP_PROCESS
  375. , &sp->last_seen_on_cpu
  376. # endif
  377. );
  378. if (n < 11)
  379. continue; /* bogus data, get next /proc/XXX */
  380. # if ENABLE_FEATURE_TOP_SMP_PROCESS
  381. if (n == 11)
  382. sp->last_seen_on_cpu = 0;
  383. # endif
  384. /* vsz is in bytes and we want kb */
  385. sp->vsz = vsz >> 10;
  386. /* vsz is in bytes but rss is in *PAGES*! Can you believe that? */
  387. sp->rss = rss << sp->shift_pages_to_kb;
  388. sp->tty_major = (tty >> 8) & 0xfff;
  389. sp->tty_minor = (tty & 0xff) | ((tty >> 12) & 0xfff00);
  390. #else
  391. /* This costs ~100 bytes more but makes top faster by 20%
  392. * If you run 10000 processes, this may be important for you */
  393. sp->state[0] = cp[2];
  394. cp += 4;
  395. sp->ppid = fast_strtoul_10(&cp);
  396. sp->pgid = fast_strtoul_10(&cp);
  397. sp->sid = fast_strtoul_10(&cp);
  398. tty = fast_strtoul_10(&cp);
  399. sp->tty_major = (tty >> 8) & 0xfff;
  400. sp->tty_minor = (tty & 0xff) | ((tty >> 12) & 0xfff00);
  401. cp = skip_fields(cp, 6); /* tpgid, flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
  402. sp->utime = fast_strtoul_10(&cp);
  403. sp->stime = fast_strtoul_10(&cp);
  404. cp = skip_fields(cp, 3); /* cutime, cstime, priority */
  405. tasknice = fast_strtol_10(&cp);
  406. cp = skip_fields(cp, 2); /* timeout, it_real_value */
  407. sp->start_time = fast_strtoul_10(&cp);
  408. /* vsz is in bytes and we want kb */
  409. sp->vsz = fast_strtoul_10(&cp) >> 10;
  410. /* vsz is in bytes but rss is in *PAGES*! Can you believe that? */
  411. sp->rss = fast_strtoul_10(&cp) << sp->shift_pages_to_kb;
  412. # if ENABLE_FEATURE_TOP_SMP_PROCESS
  413. /* (6): rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
  414. /* (4): signal, blocked, sigignore, sigcatch */
  415. /* (4): wchan, nswap, cnswap, exit_signal */
  416. cp = skip_fields(cp, 14);
  417. //FIXME: is it safe to assume this field exists?
  418. sp->last_seen_on_cpu = fast_strtoul_10(&cp);
  419. # endif
  420. #endif /* FEATURE_FAST_TOP */
  421. #if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
  422. sp->niceness = tasknice;
  423. #endif
  424. sp->state[1] = ' ';
  425. sp->state[2] = ' ';
  426. s_idx = 1;
  427. if (sp->vsz == 0 && sp->state[0] != 'Z') {
  428. /* not sure what the purpose of this flag */
  429. sp->state[1] = 'W';
  430. s_idx = 2;
  431. }
  432. if (tasknice != 0) {
  433. if (tasknice < 0)
  434. sp->state[s_idx] = '<';
  435. else /* > 0 */
  436. sp->state[s_idx] = 'N';
  437. }
  438. }
  439. #if ENABLE_FEATURE_TOPMEM
  440. if (flags & PSSCAN_SMAPS)
  441. procps_read_smaps(pid, &sp->smaps, NULL, NULL);
  442. #endif /* TOPMEM */
  443. #if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
  444. if (flags & PSSCAN_RUIDGID) {
  445. FILE *file;
  446. strcpy(filename_tail, "status");
  447. file = fopen_for_read(filename);
  448. if (file) {
  449. while (fgets(buf, sizeof(buf), file)) {
  450. char *tp;
  451. #define SCAN_TWO(str, name, statement) \
  452. if ((tp = is_prefixed_with(buf, str)) != NULL) { \
  453. tp = skip_whitespace(tp); \
  454. sscanf(tp, "%u", &sp->name); \
  455. statement; \
  456. }
  457. SCAN_TWO("Uid:", ruid, continue);
  458. SCAN_TWO("Gid:", rgid, break);
  459. #undef SCAN_TWO
  460. }
  461. fclose(file);
  462. }
  463. }
  464. #endif /* PS_ADDITIONAL_COLUMNS */
  465. if (flags & PSSCAN_EXE) {
  466. strcpy(filename_tail, "exe");
  467. free(sp->exe);
  468. sp->exe = xmalloc_readlink(filename);
  469. }
  470. /* Note: if /proc/PID/cmdline is empty,
  471. * code below "breaks". Therefore it must be
  472. * the last code to parse /proc/PID/xxx data
  473. * (we used to have /proc/PID/exe parsing after it
  474. * and were getting stale sp->exe).
  475. */
  476. #if 0 /* PSSCAN_CMD is not used */
  477. if (flags & (PSSCAN_CMD|PSSCAN_ARGV0)) {
  478. free(sp->argv0);
  479. sp->argv0 = NULL;
  480. free(sp->cmd);
  481. sp->cmd = NULL;
  482. strcpy(filename_tail, "cmdline");
  483. /* TODO: to get rid of size limits, read into malloc buf,
  484. * then realloc it down to real size. */
  485. n = read_to_buf(filename, buf);
  486. if (n <= 0)
  487. break;
  488. if (flags & PSSCAN_ARGV0)
  489. sp->argv0 = xstrdup(buf);
  490. if (flags & PSSCAN_CMD) {
  491. do {
  492. n--;
  493. if ((unsigned char)(buf[n]) < ' ')
  494. buf[n] = ' ';
  495. } while (n);
  496. sp->cmd = xstrdup(buf);
  497. }
  498. }
  499. #else
  500. if (flags & (PSSCAN_ARGV0|PSSCAN_ARGVN)) {
  501. free(sp->argv0);
  502. sp->argv0 = NULL;
  503. strcpy(filename_tail, "cmdline");
  504. n = read_to_buf(filename, buf);
  505. if (n <= 0)
  506. break;
  507. if (flags & PSSCAN_ARGVN) {
  508. sp->argv_len = n;
  509. sp->argv0 = xmemdup(buf, n + 1);
  510. /* sp->argv0[n] = '\0'; - buf has it */
  511. } else {
  512. sp->argv_len = 0;
  513. sp->argv0 = xstrdup(buf);
  514. }
  515. }
  516. #endif
  517. break;
  518. } /* for (;;) */
  519. return sp;
  520. }
  521. void FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
  522. {
  523. int sz;
  524. char filename[sizeof("/proc/%u/cmdline") + sizeof(int)*3];
  525. sprintf(filename, "/proc/%u/cmdline", pid);
  526. sz = open_read_close(filename, buf, col - 1);
  527. if (sz > 0) {
  528. const char *base;
  529. int comm_len;
  530. buf[sz] = '\0';
  531. while (--sz >= 0 && buf[sz] == '\0')
  532. continue;
  533. /* Prevent basename("process foo/bar") = "bar" */
  534. strchrnul(buf, ' ')[0] = '\0';
  535. base = bb_basename(buf); /* before we replace argv0's NUL with space */
  536. while (sz >= 0) {
  537. if ((unsigned char)(buf[sz]) < ' ')
  538. buf[sz] = ' ';
  539. sz--;
  540. }
  541. if (base[0] == '-') /* "-sh" (login shell)? */
  542. base++;
  543. /* If comm differs from argv0, prepend "{comm} ".
  544. * It allows to see thread names set by prctl(PR_SET_NAME).
  545. */
  546. if (!comm)
  547. return;
  548. comm_len = strlen(comm);
  549. /* Why compare up to comm_len, not COMM_LEN-1?
  550. * Well, some processes rewrite argv, and use _spaces_ there
  551. * while rewriting. (KDE is observed to do it).
  552. * I prefer to still treat argv0 "process foo bar"
  553. * as 'equal' to comm "process".
  554. */
  555. if (strncmp(base, comm, comm_len) != 0) {
  556. comm_len += 3;
  557. if (col > comm_len)
  558. memmove(buf + comm_len, buf, col - comm_len);
  559. snprintf(buf, col, "{%s}", comm);
  560. if (col <= comm_len)
  561. return;
  562. buf[comm_len - 1] = ' ';
  563. buf[col - 1] = '\0';
  564. }
  565. } else {
  566. snprintf(buf, col, "[%s]", comm ? comm : "?");
  567. }
  568. }
  569. /* from kernel:
  570. // pid comm S ppid pgid sid tty_nr tty_pgrp flg
  571. sprintf(buffer,"%d (%s) %c %d %d %d %d %d %lu %lu \
  572. %lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
  573. %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu %llu\n",
  574. task->pid,
  575. tcomm,
  576. state,
  577. ppid,
  578. pgid,
  579. sid,
  580. tty_nr,
  581. tty_pgrp,
  582. task->flags,
  583. min_flt,
  584. cmin_flt,
  585. maj_flt,
  586. cmaj_flt,
  587. cputime_to_clock_t(utime),
  588. cputime_to_clock_t(stime),
  589. cputime_to_clock_t(cutime),
  590. cputime_to_clock_t(cstime),
  591. priority,
  592. nice,
  593. num_threads,
  594. // 0,
  595. start_time,
  596. vsize,
  597. mm ? get_mm_rss(mm) : 0,
  598. rsslim,
  599. mm ? mm->start_code : 0,
  600. mm ? mm->end_code : 0,
  601. mm ? mm->start_stack : 0,
  602. esp,
  603. eip,
  604. the rest is some obsolete cruft
  605. */