Currently defined functions include:
- addgroup, adduser, adjtimex, ar, basename, busybox, cat, chgrp, chmod,
-chown, chroot, chvt, clear, cmp, cp, cpio, cut, date, dc, dd, deallocvt,
-deluser, df, dirname, dmesg, dos2unix, dpkg, dpkg-deb, du, dumpkmap, dutmp,
-echo, expr, false, fbset, fdflush, find, free, freeramdisk, fsck.minix,
-getopt, getty, grep, gunzip, gzip, halt, head, hostid, hostname, id,
-ifconfig, init, insmod, kill, killall, klogd, length, ln, loadacm,
-loadfont, loadkmap, logger, logname, ls, lsmod, makedevs, md5sum, mkdir,
-mkfifo, mkfs.minix, mknod, mkswap, mktemp, more, mount, mt, mv, nc,
-nslookup, ping, pivot_root, poweroff, printf, ps, pwd, rdate, readlink,
-reboot, renice, reset, rm, rmdir, rmmod, route, rpm2cpio, sed, setkeycodes,
-sh, sleep, sort, stty, swapoff, swapon, sync, syslogd, tail, tar, tee,
-telnet, test, tftp, touch, tr, true, tty, umount, uname, uniq, unix2dos,
-update, uptime, usleep, uudecode, uuencode, watchdog, wc, wget, which,
-whoami, xargs, yes, zcat, [
+ addgroup, adduser, adjtimex, ar, awk, basename, busybox, cat, chgrp,
+chmod, chown, chroot, chvt, clear, cmp, cp, cpio, cut, date, dc, dd,
+deallocvt, deluser, df, dirname, dmesg, dos2unix, dpkg, dpkg-deb, du,
+dumpkmap, dutmp, echo, expr, false, fbset, fdflush, find, free,
+freeramdisk, fsck.minix, getopt, getty, grep, gunzip, gzip, halt, head,
+hostid, hostname, id, ifconfig, init, insmod, kill, killall, klogd, length,
+ln, loadacm, loadfont, loadkmap, logger, logname, ls, lsmod, makedevs,
+md5sum, mkdir, mkfifo, mkfs.minix, mknod, mkswap, mktemp, more, mount, mt,
+mv, nc, netstat, nslookup, ping, pivot_root, poweroff, printf, ps, pwd,
+rdate, readlink, reboot, renice, reset, rm, rmdir, rmmod, route, rpm2cpio,
+sed, setkeycodes, sh, sleep, sort, stty, swapoff, swapon, sync, syslogd,
+tail, tar, tee, telnet, telnetd, test, tftp, time, top, touch, tr, true,
+tty, umount, uname, uniq, unix2dos, update, uptime, usleep, uudecode,
+uuencode, watchdog, wc, wget, which, whoami, xargs, yes, zcat, [
=over 4
--- /dev/null
+/* $Id: telnetd.c,v 1.1 2002/09/30 20:52:04 andersen Exp $
+ *
+ * Simple telnet server
+ * Bjorn Wesen, Axis Communications AB (bjornw@axis.com)
+ *
+ * This file is distributed under the Gnu Public License (GPL),
+ * please see the file LICENSE for further information.
+ *
+ * ---------------------------------------------------------------------------
+ * (C) Copyright 2000, Axis Communications AB, LUND, SWEDEN
+ ****************************************************************************
+ *
+ * The telnetd manpage says it all:
+ *
+ * Telnetd operates by allocating a pseudo-terminal device (see pty(4)) for
+ * a client, then creating a login process which has the slave side of the
+ * pseudo-terminal as stdin, stdout, and stderr. Telnetd manipulates the
+ * master side of the pseudo-terminal, implementing the telnet protocol and
+ * passing characters between the remote client and the login process.
+ *
+ * Vladimir Oleynik <dzo@simtreas.ru> 2001
+ * Set process group corrections, initial busybox port
+ */
+
+/*#define DEBUG 1 */
+
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <signal.h>
+#include <termios.h>
+#ifdef DEBUG
+#define TELCMDS
+#define TELOPTS
+#endif
+#include <arpa/telnet.h>
+#include <ctype.h>
+#include <sys/syslog.h>
+
+#include "busybox.h"
+
+#define BUFSIZE 4000
+
+static const char *loginpath = "/bin/sh";
+
+/* shell name and arguments */
+
+static const char *argv_init[] = {NULL, NULL};
+
+/* structure that describes a session */
+
+struct tsession {
+ struct tsession *next;
+ int sockfd, ptyfd;
+ int shell_pid;
+ /* two circular buffers */
+ char *buf1, *buf2;
+ int rdidx1, wridx1, size1;
+ int rdidx2, wridx2, size2;
+};
+
+/*
+
+ This is how the buffers are used. The arrows indicate the movement
+ of data.
+
+ +-------+ wridx1++ +------+ rdidx1++ +----------+
+ | | <-------------- | buf1 | <-------------- | |
+ | | size1-- +------+ size1++ | |
+ | pty | | socket |
+ | | rdidx2++ +------+ wridx2++ | |
+ | | --------------> | buf2 | --------------> | |
+ +-------+ size2++ +------+ size2-- +----------+
+
+ Each session has got two buffers.
+
+*/
+
+static int maxfd;
+
+static struct tsession *sessions;
+
+
+/*
+
+ Remove all IAC's from the buffer pointed to by bf (recieved IACs are ignored
+ and must be removed so as to not be interpreted by the terminal). Make an
+ uninterrupted string of characters fit for the terminal. Do this by packing
+ all characters meant for the terminal sequentially towards the end of bf.
+
+ Return a pointer to the beginning of the characters meant for the terminal.
+ and make *num_totty the number of characters that should be sent to
+ the terminal.
+
+ Note - If an IAC (3 byte quantity) starts before (bf + len) but extends
+ past (bf + len) then that IAC will be left unprocessed and *processed will be
+ less than len.
+
+ FIXME - if we mean to send 0xFF to the terminal then it will be escaped,
+ what is the escape character? We aren't handling that situation here.
+
+ */
+static char *
+remove_iacs(struct tsession *ts, int *pnum_totty) {
+ unsigned char *ptr0 = ts->buf1 + ts->wridx1;
+ unsigned char *ptr = ptr0;
+ unsigned char *totty = ptr;
+ unsigned char *end = ptr + MIN(BUFSIZE - ts->wridx1, ts->size1);
+ int processed;
+ int num_totty;
+
+ while (ptr < end) {
+ if (*ptr != IAC) {
+ *totty++ = *ptr++;
+ }
+ else {
+ if ((ptr+2) < end) {
+ /* the entire IAC is contained in the buffer
+ we were asked to process. */
+#ifdef DEBUG
+ fprintf(stderr, "Ignoring IAC %s,%s\n",
+ *ptr, TELCMD(*(ptr+1)), TELOPT(*(ptr+2)));
+#endif
+ ptr += 3;
+ } else {
+ /* only the beginning of the IAC is in the
+ buffer we were asked to process, we can't
+ process this char. */
+ break;
+ }
+ }
+ }
+
+ processed = ptr - ptr0;
+ num_totty = totty - ptr0;
+ /* the difference between processed and num_to tty
+ is all the iacs we removed from the stream.
+ Adjust buf1 accordingly. */
+ ts->wridx1 += processed - num_totty;
+ ts->size1 -= processed - num_totty;
+ *pnum_totty = num_totty;
+ /* move the chars meant for the terminal towards the end of the
+ buffer. */
+ return memmove(ptr - num_totty, ptr0, num_totty);
+}
+
+
+static int
+getpty(char *line)
+{
+ int p;
+#ifdef HAVE_DEVPTS_FS
+ p = open("/dev/ptmx", 2);
+ if (p > 0) {
+ grantpt(p);
+ unlockpt(p);
+ strcpy(line, ptsname(p));
+ return(p);
+ }
+#else
+ struct stat stb;
+ int i;
+ int j;
+
+ strcpy(line, "/dev/ptyXX");
+
+ for (i = 0; i < 16; i++) {
+ line[8] = "pqrstuvwxyzabcde"[i];
+ line[9] = '0';
+ if (stat(line, &stb) < 0) {
+ continue;
+ }
+ for (j = 0; j < 16; j++) {
+ line[9] = j < 10 ? j + '0' : j - 10 + 'a';
+ if ((p = open(line, O_RDWR | O_NOCTTY)) >= 0) {
+ line[5] = 't';
+ return p;
+ }
+ }
+ }
+#endif /* HAVE_DEVPTS_FS */
+ return -1;
+}
+
+
+static void
+send_iac(struct tsession *ts, unsigned char command, int option)
+{
+ /* We rely on that there is space in the buffer for now. */
+ char *b = ts->buf2 + ts->rdidx2;
+ *b++ = IAC;
+ *b++ = command;
+ *b++ = option;
+ ts->rdidx2 += 3;
+ ts->size2 += 3;
+}
+
+
+static struct tsession *
+make_new_session(int sockfd)
+{
+ struct termios termbuf;
+ int pty, pid;
+ char tty_name[32];
+ struct tsession *ts = malloc(sizeof(struct tsession) + BUFSIZE * 2);
+
+ ts->buf1 = (char *)(&ts[1]);
+ ts->buf2 = ts->buf1 + BUFSIZE;
+
+ ts->sockfd = sockfd;
+
+ ts->rdidx1 = ts->wridx1 = ts->size1 = 0;
+ ts->rdidx2 = ts->wridx2 = ts->size2 = 0;
+
+ /* Got a new connection, set up a tty and spawn a shell. */
+
+ pty = getpty(tty_name);
+
+ if (pty < 0) {
+ syslog_msg(LOG_USER, LOG_ERR, "All network ports in use!");
+ return 0;
+ }
+
+ if (pty > maxfd)
+ maxfd = pty;
+
+ ts->ptyfd = pty;
+
+ /* Make the telnet client understand we will echo characters so it
+ * should not do it locally. We don't tell the client to run linemode,
+ * because we want to handle line editing and tab completion and other
+ * stuff that requires char-by-char support.
+ */
+
+ send_iac(ts, DO, TELOPT_ECHO);
+ send_iac(ts, DO, TELOPT_LFLOW);
+ send_iac(ts, WILL, TELOPT_ECHO);
+ send_iac(ts, WILL, TELOPT_SGA);
+
+
+ if ((pid = fork()) < 0) {
+ syslog_msg(LOG_USER, LOG_ERR, "Can`t forking");
+ }
+ if (pid == 0) {
+ /* In child, open the child's side of the tty. */
+ int i;
+
+ for(i = 0; i <= maxfd; i++)
+ close(i);
+ /* make new process group */
+ setsid();
+
+ if (open(tty_name, O_RDWR /*| O_NOCTTY*/) < 0) {
+ syslog_msg(LOG_USER, LOG_ERR, "Could not open tty");
+ exit(1);
+ }
+ dup(0);
+ dup(0);
+
+ tcsetpgrp(0, getpid());
+
+ /* The pseudo-terminal allocated to the client is configured to operate in
+ * cooked mode, and with XTABS CRMOD enabled (see tty(4)).
+ */
+
+ tcgetattr(0, &termbuf);
+ termbuf.c_lflag |= ECHO; /* if we use readline we dont want this */
+ termbuf.c_oflag |= ONLCR|XTABS;
+ termbuf.c_iflag |= ICRNL;
+ termbuf.c_iflag &= ~IXOFF;
+ /*termbuf.c_lflag &= ~ICANON;*/
+ tcsetattr(0, TCSANOW, &termbuf);
+
+ /* exec shell, with correct argv and env */
+ execv(loginpath, (char *const *)argv_init);
+
+ /* NOT REACHED */
+ syslog_msg(LOG_USER, LOG_ERR, "execv error");
+ exit(1);
+ }
+
+ ts->shell_pid = pid;
+
+ return ts;
+}
+
+static void
+free_session(struct tsession *ts)
+{
+ struct tsession *t = sessions;
+
+ /* Unlink this telnet session from the session list. */
+ if(t == ts)
+ sessions = ts->next;
+ else {
+ while(t->next != ts)
+ t = t->next;
+ t->next = ts->next;
+ }
+
+ kill(ts->shell_pid, SIGKILL);
+
+ wait4(ts->shell_pid, NULL, 0, NULL);
+
+ close(ts->ptyfd);
+ close(ts->sockfd);
+
+ if(ts->ptyfd == maxfd || ts->sockfd == maxfd)
+ maxfd--;
+ if(ts->ptyfd == maxfd || ts->sockfd == maxfd)
+ maxfd--;
+
+ free(ts);
+}
+
+int
+telnetd_main(int argc, char **argv)
+{
+ struct sockaddr_in sa;
+ int master_fd;
+ fd_set rdfdset, wrfdset;
+ int selret;
+ int on = 1;
+ int portnbr = 23;
+ int c;
+
+ /* check if user supplied a port number */
+
+ for (;;) {
+ c = getopt( argc, argv, "p:l:");
+ if (c == EOF) break;
+ switch (c) {
+ case 'p':
+ portnbr = atoi(optarg);
+ break;
+ case 'l':
+ loginpath = strdup (optarg);
+ break;
+ default:
+ show_usage();
+ }
+ }
+
+ if (access(loginpath, X_OK) < 0) {
+ error_msg_and_die ("'%s' unavailable.", loginpath);
+ }
+
+ argv_init[0] = loginpath;
+ sessions = 0;
+
+ /* Grab a TCP socket. */
+
+ master_fd = socket(AF_INET, SOCK_STREAM, 0);
+ if (master_fd < 0) {
+ perror_msg_and_die("socket");
+ }
+ (void)setsockopt(master_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+
+ /* Set it to listen to specified port. */
+
+ memset((void *)&sa, 0, sizeof(sa));
+ sa.sin_family = AF_INET;
+ sa.sin_port = htons(portnbr);
+
+ if (bind(master_fd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
+ perror_msg_and_die("bind");
+ }
+
+ if (listen(master_fd, 1) < 0) {
+ perror_msg_and_die("listen");
+ }
+
+ if (daemon(0, 0) < 0)
+ perror_msg_and_die("daemon");
+
+
+ maxfd = master_fd;
+
+ do {
+ struct tsession *ts;
+
+ FD_ZERO(&rdfdset);
+ FD_ZERO(&wrfdset);
+
+ /* select on the master socket, all telnet sockets and their
+ * ptys if there is room in their respective session buffers.
+ */
+
+ FD_SET(master_fd, &rdfdset);
+
+ ts = sessions;
+ while (ts) {
+ /* buf1 is used from socket to pty
+ * buf2 is used from pty to socket
+ */
+ if (ts->size1 > 0) {
+ FD_SET(ts->ptyfd, &wrfdset); /* can write to pty */
+ }
+ if (ts->size1 < BUFSIZE) {
+ FD_SET(ts->sockfd, &rdfdset); /* can read from socket */
+ }
+ if (ts->size2 > 0) {
+ FD_SET(ts->sockfd, &wrfdset); /* can write to socket */
+ }
+ if (ts->size2 < BUFSIZE) {
+ FD_SET(ts->ptyfd, &rdfdset); /* can read from pty */
+ }
+ ts = ts->next;
+ }
+
+ selret = select(maxfd + 1, &rdfdset, &wrfdset, 0, 0);
+
+ if (!selret)
+ break;
+
+ /* First check for and accept new sessions. */
+ if (FD_ISSET(master_fd, &rdfdset)) {
+ int fd, salen;
+
+ salen = sizeof(sa);
+ if ((fd = accept(master_fd, (struct sockaddr *)&sa,
+ &salen)) < 0) {
+ continue;
+ } else {
+ /* Create a new session and link it into
+ our active list. */
+ struct tsession *new_ts = make_new_session(fd);
+ if (new_ts) {
+ new_ts->next = sessions;
+ sessions = new_ts;
+ if (fd > maxfd)
+ maxfd = fd;
+ } else {
+ close(fd);
+ }
+ }
+ }
+
+ /* Then check for data tunneling. */
+
+ ts = sessions;
+ while (ts) { /* For all sessions... */
+ int maxlen, w, r;
+ struct tsession *next = ts->next; /* in case we free ts. */
+
+ if (ts->size1 && FD_ISSET(ts->ptyfd, &wrfdset)) {
+ int num_totty;
+ char *ptr;
+ /* Write to pty from buffer 1. */
+
+ ptr = remove_iacs(ts, &num_totty);
+
+ w = write(ts->ptyfd, ptr, num_totty);
+ if (w < 0) {
+ free_session(ts);
+ ts = next;
+ continue;
+ }
+ ts->wridx1 += w;
+ ts->size1 -= w;
+ if (ts->wridx1 == BUFSIZE)
+ ts->wridx1 = 0;
+ }
+
+ if (ts->size2 && FD_ISSET(ts->sockfd, &wrfdset)) {
+ /* Write to socket from buffer 2. */
+ maxlen = MIN(BUFSIZE - ts->wridx2, ts->size2);
+ w = write(ts->sockfd, ts->buf2 + ts->wridx2, maxlen);
+ if (w < 0) {
+ free_session(ts);
+ ts = next;
+ continue;
+ }
+ ts->wridx2 += w;
+ ts->size2 -= w;
+ if (ts->wridx2 == BUFSIZE)
+ ts->wridx2 = 0;
+ }
+
+ if (ts->size1 < BUFSIZE && FD_ISSET(ts->sockfd, &rdfdset)) {
+ /* Read from socket to buffer 1. */
+ maxlen = MIN(BUFSIZE - ts->rdidx1,
+ BUFSIZE - ts->size1);
+ r = read(ts->sockfd, ts->buf1 + ts->rdidx1, maxlen);
+ if (!r || (r < 0 && errno != EINTR)) {
+ free_session(ts);
+ ts = next;
+ continue;
+ }
+ if(!*(ts->buf1 + ts->rdidx1 + r - 1)) {
+ r--;
+ if(!r)
+ continue;
+ }
+ ts->rdidx1 += r;
+ ts->size1 += r;
+ if (ts->rdidx1 == BUFSIZE)
+ ts->rdidx1 = 0;
+ }
+
+ if (ts->size2 < BUFSIZE && FD_ISSET(ts->ptyfd, &rdfdset)) {
+ /* Read from pty to buffer 2. */
+ maxlen = MIN(BUFSIZE - ts->rdidx2,
+ BUFSIZE - ts->size2);
+ r = read(ts->ptyfd, ts->buf2 + ts->rdidx2, maxlen);
+ if (!r || (r < 0 && errno != EINTR)) {
+ free_session(ts);
+ ts = next;
+ continue;
+ }
+ ts->rdidx2 += r;
+ ts->size2 += r;
+ if (ts->rdidx2 == BUFSIZE)
+ ts->rdidx2 = 0;
+ }
+
+ if (ts->size1 == 0) {
+ ts->rdidx1 = 0;
+ ts->wridx1 = 0;
+ }
+ if (ts->size2 == 0) {
+ ts->rdidx2 = 0;
+ ts->wridx2 = 0;
+ }
+ ts = next;
+ }
+
+ } while (1);
+
+ return 0;
+}
/*
* A tiny 'top' utility.
*
- * This is written specifically for the linux /proc/<PID>/status
- * file format, but it checks that the file actually conforms to the
- * format that this utility expects.
-
- * This reads the PIDs of all processes at startup and then shows the
- * status of those processes at given intervals. User can give
- * maximum number of processes to show. If a process exits, it's PID
- * is shown as 'EXIT'. If new processes are started while this works,
- * it doesn't add them to the list of shown processes.
+ * This is written specifically for the linux /proc/<PID>/stat(m)
+ * files format.
+
+ * This reads the PIDs of all processes and their status and shows
+ * the status of processes (first ones that fit to screen) at given
+ * intervals.
*
* NOTES:
* - At startup this changes to /proc, all the reads are then
* relative to that.
- * - Includes code from the scandir() manual page.
- *
- * TODO:
- * - ppid, uid etc could be read only once when program starts
- * and rest of the information could be gotten from the
- * /proc/<PID>/statm file.
- * - Add process CPU and memory usage *percentages*.
*
* (C) Eero Tamminen <oak at welho dot com>
+ *
+ * Rewroted by Vladimir Oleynik (C) 2002 <dzo@simtreas.ru>
+ */
+
+/* Original code Copyrights */
+/*
+ * Copyright (c) 1992 Branko Lankester
+ * Copyright (c) 1992 Roger Binns
+ * Copyright (C) 1994-1996 Charles L. Blake.
+ * Copyright (C) 1992-1998 Michael K. Johnson
+ * May be distributed under the conditions of the
+ * GNU Library General Public License
*/
+
+#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <sys/ioctl.h>
+#include <sys/stat.h>
+/* get page info */
+#include <asm/page.h>
#include "busybox.h"
+//#define FEATURE_CPU_USAGE_PERCENTAGE /* + 2k */
+
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+#include <time.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <netinet/in.h> /* htons */
+#endif
+
-/* process information taken from /proc,
- * The code takes into account how long the fields below are,
- * starting from copying the file from 'status' file to displaying it!
- */
typedef struct {
- char uid[6]; /* User ID */
- char pid[6]; /* Pid */
- char ppid[6]; /* Parent Pid */
- char name[12]; /* Name */
- char cmd[20]; /* command line[read/show size] */
- char state[2]; /* State: S, W... */
- char size[9]; /* VmSize */
- char lck[9]; /* VmLck */
- char rss[9]; /* VmRSS */
- char data[9]; /* VmData */
- char stk[9]; /* VmStk */
- char exe[9]; /* VmExe */
- char lib[9]; /* VmLib */
+ int pid;
+ char user[9];
+ char state[4];
+ unsigned long rss;
+ int ppid;
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ unsigned pcpu;
+ unsigned long stime, utime;
+#endif
+ char *cmd;
+
+ /* basename of executable file in call to exec(2),
+ size from kernel headers */
+ char short_cmd[16];
} status_t;
+typedef int (*cmp_t)(status_t *P, status_t *Q);
+
+static status_t *top; /* Hehe */
+static int ntop;
+
+
+static int pid_sort (status_t *P, status_t *Q)
+{
+ int p = P->pid;
+ int q = Q->pid;
+
+ if( p < q ) return -1;
+ if( p > q ) return 1;
+ return 0;
+}
+
+static int mem_sort (status_t *P, status_t *Q)
+{
+ long p = P->rss;
+ long q = Q->rss;
+
+ if( p > q ) return -1;
+ if( p < q ) return 1;
+ return 0;
+}
+
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+
+#define sort_depth 3
+static cmp_t sort_function[sort_depth];
+
+static int pcpu_sort (status_t *P, status_t *Q)
+{
+ int p = P->pcpu;
+ int q = Q->pcpu;
+
+ if( p > q ) return -1;
+ if( p < q ) return 1;
+ return 0;
+}
+
+static int time_sort (status_t *P, status_t *Q)
+{
+ long p = P->stime;
+ long q = Q->stime;
+
+ p += P->utime;
+ q += Q->utime;
+ if( p > q ) return -1;
+ if( p < q ) return 1;
+ return 0;
+}
+
+int mult_lvl_cmp(void* a, void* b) {
+ int i, cmp_val;
+
+ for(i = 0; i < sort_depth; i++) {
+ cmp_val = (*sort_function[i])(a, b);
+ if (cmp_val != 0)
+ return cmp_val;
+ }
+ return 0;
+}
+
+/* This structure stores some critical information from one frame to
+ the next. mostly used for sorting. Added cumulative and resident fields. */
+struct save_hist {
+ int ticks;
+ int pid;
+ int utime;
+ int stime;
+};
+
+/*
+ * Calculates percent cpu usage for each task.
+ */
+
+static struct save_hist *save_history;
+
+static unsigned long Hertz;
+
+/***********************************************************************
+ * Some values in /proc are expressed in units of 1/HZ seconds, where HZ
+ * is the kernel clock tick rate. One of these units is called a jiffy.
+ * The HZ value used in the kernel may vary according to hacker desire.
+ * According to Linus Torvalds, this is not true. He considers the values
+ * in /proc as being in architecture-dependant units that have no relation
+ * to the kernel clock tick rate. Examination of the kernel source code
+ * reveals that opinion as wishful thinking.
+ *
+ * In any case, we need the HZ constant as used in /proc. (the real HZ value
+ * may differ, but we don't care) There are several ways we could get HZ:
+ *
+ * 1. Include the kernel header file. If it changes, recompile this library.
+ * 2. Use the sysconf() function. When HZ changes, recompile the C library!
+ * 3. Ask the kernel. This is obviously correct...
+ *
+ * Linus Torvalds won't let us ask the kernel, because he thinks we should
+ * not know the HZ value. Oh well, we don't have to listen to him.
+ * Someone smuggled out the HZ value. :-)
+ *
+ * This code should work fine, even if Linus fixes the kernel to match his
+ * stated behavior. The code only fails in case of a partial conversion.
+ *
+ */
+
+#define FILE_TO_BUF(filename, fd) do{ \
+ if (fd == -1 && (fd = open(filename, O_RDONLY)) == -1) { \
+ perror_msg_and_die("/proc not be mounted?"); \
+ } \
+ lseek(fd, 0L, SEEK_SET); \
+ if ((local_n = read(fd, buf, sizeof buf - 1)) < 0) { \
+ perror_msg_and_die("%s", filename); \
+ } \
+ buf[local_n] = '\0'; \
+}while(0)
+
+#define FILE_TO_BUF2(filename, fd) do{ \
+ lseek(fd, 0L, SEEK_SET); \
+ if ((local_n = read(fd, buf, sizeof buf - 1)) < 0) { \
+ perror_msg_and_die("%s", filename); \
+ } \
+ buf[local_n] = '\0'; \
+}while(0)
+
+static void init_Hertz_value(void) {
+ unsigned long user_j, nice_j, sys_j, other_j; /* jiffies (clock ticks) */
+ double up_1, up_2, seconds;
+ unsigned long jiffies, h;
+ char buf[80];
+ int uptime_fd = -1;
+ int stat_fd = -1;
+
+ long smp_num_cpus = sysconf(_SC_NPROCESSORS_CONF);
+
+ if(smp_num_cpus<1) smp_num_cpus=1;
+ do {
+ int local_n;
+
+ FILE_TO_BUF("uptime", uptime_fd);
+ up_1 = strtod(buf, 0);
+ FILE_TO_BUF("stat", stat_fd);
+ sscanf(buf, "cpu %lu %lu %lu %lu", &user_j, &nice_j, &sys_j, &other_j);
+ FILE_TO_BUF2("uptime", uptime_fd);
+ up_2 = strtod(buf, 0);
+ } while((long)( (up_2-up_1)*1000.0/up_1 )); /* want under 0.1% error */
+
+ close(uptime_fd);
+ close(stat_fd);
+
+ jiffies = user_j + nice_j + sys_j + other_j;
+ seconds = (up_1 + up_2) / 2;
+ h = (unsigned long)( (double)jiffies/seconds/smp_num_cpus );
+ /* actual values used by 2.4 kernels: 32 64 100 128 1000 1024 1200 */
+ switch(h){
+ case 30 ... 34 : Hertz = 32; break; /* ia64 emulator */
+ case 48 ... 52 : Hertz = 50; break;
+ case 58 ... 62 : Hertz = 60; break;
+ case 63 ... 65 : Hertz = 64; break; /* StrongARM /Shark */
+ case 95 ... 105 : Hertz = 100; break; /* normal Linux */
+ case 124 ... 132 : Hertz = 128; break; /* MIPS, ARM */
+ case 195 ... 204 : Hertz = 200; break; /* normal << 1 */
+ case 253 ... 260 : Hertz = 256; break;
+ case 295 ... 304 : Hertz = 300; break; /* 3 cpus */
+ case 393 ... 408 : Hertz = 400; break; /* normal << 2 */
+ case 495 ... 504 : Hertz = 500; break; /* 5 cpus */
+ case 595 ... 604 : Hertz = 600; break; /* 6 cpus */
+ case 695 ... 704 : Hertz = 700; break; /* 7 cpus */
+ case 790 ... 808 : Hertz = 800; break; /* normal << 3 */
+ case 895 ... 904 : Hertz = 900; break; /* 9 cpus */
+ case 990 ... 1010 : Hertz = 1000; break; /* ARM */
+ case 1015 ... 1035 : Hertz = 1024; break; /* Alpha, ia64 */
+ case 1095 ... 1104 : Hertz = 1100; break; /* 11 cpus */
+ case 1180 ... 1220 : Hertz = 1200; break; /* Alpha */
+ default:
+ /* If 32-bit or big-endian (not Alpha or ia64), assume HZ is 100. */
+ Hertz = (sizeof(long)==sizeof(int) || htons(999)==999) ? 100UL : 1024UL;
+ }
+}
+
+static void do_stats(void)
+{
+ struct timeval t;
+ static struct timeval oldtime;
+ struct timezone timez;
+ float elapsed_time;
+
+ status_t *cur;
+ int total_time, i, n;
+ static int prev_count;
+ int systime, usrtime, pid;
+
+ struct save_hist *New_save_hist;
+
+ /*
+ * Finds the current time (in microseconds) and calculates the time
+ * elapsed since the last update.
+ */
+ gettimeofday(&t, &timez);
+ elapsed_time = (t.tv_sec - oldtime.tv_sec)
+ + (float) (t.tv_usec - oldtime.tv_usec) / 1000000.0;
+ oldtime.tv_sec = t.tv_sec;
+ oldtime.tv_usec = t.tv_usec;
+
+ New_save_hist = alloca(sizeof(struct save_hist)*ntop);
+ /*
+ * Make a pass through the data to get stats.
+ */
+ for(n = 0; n < ntop; n++) {
+ cur = top + n;
+
+ /*
+ * Calculate time in cur process. Time is sum of user time
+ * (usrtime) plus system time (systime).
+ */
+ systime = cur->stime;
+ usrtime = cur->utime;
+ pid = cur->pid;
+ total_time = systime + usrtime;
+ New_save_hist[n].ticks = total_time;
+ New_save_hist[n].pid = pid;
+ New_save_hist[n].stime = systime;
+ New_save_hist[n].utime = usrtime;
+
+ /* find matching entry from previous pass */
+ for (i = 0; i < prev_count; i++) {
+ if (save_history[i].pid == pid) {
+ total_time -= save_history[i].ticks;
+ systime -= save_history[i].stime;
+ usrtime -= save_history[i].utime;
+ break;
+ }
+ }
+
+ /*
+ * Calculate percent cpu time for cur task.
+ */
+ i = (total_time * 10 * 100/Hertz) / elapsed_time;
+ if (i > 999)
+ i = 999;
+ cur->pcpu = i;
+
+ }
+
+ /*
+ * Save cur frame's information.
+ */
+ free(save_history);
+ save_history = memcpy(xmalloc(sizeof(struct save_hist)*n), New_save_hist,
+ sizeof(struct save_hist)*n);
+ prev_count = n;
+ qsort(top, n, sizeof(status_t), (void*)mult_lvl_cmp);
+}
+#else
+static cmp_t sort_function;
+#endif /* FEATURE_CPU_USAGE_PERCENTAGE */
+
/* display generic info (meminfo / loadavg) */
-static void display_generic(void)
+static unsigned long display_generic(void)
{
FILE *fp;
char buf[80];
unsigned long total, used, mfree, shared, buffers, cached;
/* read memory info */
- fp = fopen("meminfo", "r");
- if (!fp) {
- perror("fopen('meminfo')");
- return;
- }
+ fp = xfopen("meminfo", "r");
fgets(buf, sizeof(buf), fp); /* skip first line */
if (fscanf(fp, "Mem: %lu %lu %lu %lu %lu %lu",
&total, &used, &mfree, &shared, &buffers, &cached) != 6) {
- fprintf(stderr, "Error: failed to read 'meminfo'");
- fclose(fp);
+ error_msg_and_die("failed to read '%s'", "meminfo");
}
fclose(fp);
/* read load average */
- fp = fopen("loadavg", "r");
- if (!fp) {
- perror("fopen('loadavg')");
- return;
- }
+ fp = xfopen("loadavg", "r");
if (fscanf(fp, "%f %f %f", &avg1, &avg2, &avg3) != 3) {
- fprintf(stderr, "Error: failed to read 'loadavg'");
- fclose(fp);
- return;
+ error_msg_and_die("failed to read '%s'", "loadavg");
}
fclose(fp);
/* convert to kilobytes */
- if (total) total /= 1024;
- if (used) used /= 1024;
- if (mfree) mfree /= 1024;
- if (shared) shared /= 1024;
- if (buffers) buffers /= 1024;
- if (cached) cached /= 1024;
+ used /= 1024;
+ mfree /= 1024;
+ shared /= 1024;
+ buffers /= 1024;
+ cached /= 1024;
/* output memory info and load average */
- printf("Mem: %ldK, %ldK used, %ldK free, %ldK shrd, %ldK buff, %ldK cached\n",
- total, used, mfree, shared, buffers, cached);
- printf("Load average: %.2f, %.2f, %.2f (State: S=sleeping R=running, W=waiting)\n",
+ /* clear screen & go to top */
+ printf("\e[H\e[J" "Mem: "
+ "%ldK used, %ldK free, %ldK shrd, %ldK buff, %ldK cached\n",
+ used, mfree, shared, buffers, cached);
+ printf("Load average: %.2f, %.2f, %.2f "
+ "(State: S=sleeping R=running, W=waiting)\n",
avg1, avg2, avg3);
+ return total / 1024;
}
/* display process statuses */
-static void display_status(int count, const status_t *s)
+static void display_status(int count, int col)
{
- const char *fmt, *cmd;
-
- /* clear screen & go to top */
- printf("\e[2J\e[1;1H");
-
- display_generic();
+ status_t *s = top;
+ char rss_str_buf[8];
+ unsigned long total_memory = display_generic();
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
/* what info of the processes is shown */
- printf("\n%*s %*s %*s %*s %*s %*s %-*s\n",
- sizeof(s->pid)-1, "Pid:",
- sizeof(s->state)-1, "",
- sizeof(s->ppid)-1, "PPid:",
- sizeof(s->uid)-1, "UID:",
- sizeof(s->size)-1, "WmSize:",
- sizeof(s->rss)-1, "WmRSS:",
- sizeof(s->cmd)-1, "command line:");
+ printf("\n\e[7m PID USER STATUS RSS PPID %%CPU %%MEM COMMAND\e[0m\n");
+#else
+ printf("\n\e[7m PID USER STATUS RSS PPID %%MEM COMMAND\e[0m\n");
+#endif
while (count--) {
- if (s->cmd[0]) {
- /* normal process, has command line */
- cmd = s->cmd;
- fmt = "%*s %*s %*s %*s %*s %*s %s\n";
- } else {
- /* no command line, show only process name */
- cmd = s->name;
- fmt = "%*s %*s %*s %*s %*s %*s [%s]\n";
- }
- printf(fmt,
- sizeof(s->pid)-1, s->pid,
- sizeof(s->state)-1, s->state,
- sizeof(s->ppid)-1, s->ppid,
- sizeof(s->uid)-1, s->uid,
- sizeof(s->size)-1, s->size,
- sizeof(s->rss)-1, s->rss,
- cmd);
- s++;
- }
-}
+ char *namecmd = s->cmd;
+ int pmem;
-
-/* checks if given 'buf' for process starts with 'id' + ':' + TAB
- * and stores rest of the buf to 'store' with max size 'size'
- */
-static int process_status(const char *buf, const char *id, char *store, size_t size)
-{
- int len, i;
+ pmem = 1000.0 * s->rss / total_memory;
+ if (pmem > 999) pmem = 999;
- /* check status field name */
- len = strlen(id);
- if (strncmp(buf, id, len) != 0) {
- if(store)
- error_msg_and_die("ERROR status: line doesn't start with '%s' in:\n%s\n", id, buf);
+ if(s->rss > 10*1024)
+ sprintf(rss_str_buf, "%6ldM", s->rss/1024);
else
- return 0;
- }
- if (!store) {
- /* ignoring this field */
- return 1;
- }
- buf += len;
-
- /* check status field format */
- if ((*buf++ != ':') || (*buf++ != '\t')) {
- error_msg_and_die("ERROR status: field '%s' not followed with ':' + TAB in:\n%s\n", id, buf);
- }
-
- /* skip whitespace in Wm* fields */
- if (id[0] == 'V' && id[1] == 'm') {
- i = 3;
- while (i--) {
- if (*buf == ' ') {
- buf++;
+ sprintf(rss_str_buf, "%7ld", s->rss);
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ printf("%5d %-8s %s %s %5d %2d.%d %2u.%u ",
+#else
+ printf("%5d %-8s %s %s %5d %2u.%u ",
+#endif
+ s->pid, s->user, s->state, rss_str_buf, s->ppid,
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ s->pcpu/10, s->pcpu%10,
+#endif
+ pmem/10, pmem%10);
+ if(namecmd != 0 && namecmd[0] != 0) {
+ if(strlen(namecmd) > col)
+ namecmd[col] = 0;
+ printf("%s\n", namecmd);
} else {
- error_msg_and_die("ERROR status: can't skip whitespace for "
- "'%s' field in:\n%s\n", id, buf);
+ namecmd = s->short_cmd;
+ if(strlen(namecmd) > (col-2))
+ namecmd[col-2] = 0;
+ printf("[%s]\n", namecmd);
}
+ s++;
}
- }
-
- /* copy at max (size-1) chars and force '\0' to the end */
- while (--size) {
- if (*buf < ' ') {
- break;
- }
- *store++ = *buf++;
- }
- *store = '\0';
- return 1;
}
-/* read process statuses */
-static void read_status(int num, status_t *s)
+/* returns true for file names which are PID dirs
+ * (i.e. start with number)
+ */
+static int filter_pids(const struct dirent *dir)
{
+ char *name = dir->d_name;
+ int n;
char status[20];
- char buf[80];
+ char buf[1024];
FILE *fp;
+ status_t curstatus;
+ int pid;
+ long tasknice;
+ struct stat sb;
+
+ if (!(*name >= '0' && *name <= '9'))
+ return 0;
+ if(stat(name, &sb))
+ return 0;
+
+ memset(&curstatus, 0, sizeof(status_t));
+ pid = atoi(name);
+ curstatus.pid = pid;
- while (num--) {
- sprintf(status, "%s/status", s->pid);
-
- /* read the command line from 'cmdline' in PID dir */
- fp = fopen(status, "r");
- if (!fp) {
- strncpy(s->pid, "EXIT", sizeof(s->pid));
- s->pid[sizeof(s->pid)-1] = '\0';
+ my_getpwuid(curstatus.user, sb.st_uid);
+
+ sprintf(status, "%d/stat", pid);
+ if((fp = fopen(status, "r")) == NULL)
+ return 0;
+ name = fgets(buf, sizeof(buf), fp);
fclose(fp);
- continue;
- }
+ if(name == NULL)
+ return 0;
+ name = strrchr(buf, ')'); /* split into "PID (cmd" and "<rest>" */
+ if(name == 0 || name[1] != ' ')
+ return 0;
+ *name = 0;
+ sscanf(buf, "%*s (%15c", curstatus.short_cmd);
+ n = sscanf(name+2,
+ "%c %d "
+ "%*s %*s %*s %*s " /* pgrp, session, tty, tpgid */
+ "%*s %*s %*s %*s %*s " /* flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ "%lu %lu "
+#else
+ "%*s %*s "
+#endif
+ "%*s %*s %*s " /* cutime, cstime, priority */
+ "%ld "
+ "%*s %*s %*s " /* timeout, it_real_value, start_time */
+ "%*s " /* vsize */
+ "%ld",
+ curstatus.state, &curstatus.ppid,
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ &curstatus.utime, &curstatus.stime,
+#endif
+ &tasknice,
+ &curstatus.rss);
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ if(n != 6)
+#else
+ if(n != 4)
+#endif
+ return 0;
+
+ if (curstatus.rss == 0 && curstatus.state[0] != 'Z')
+ curstatus.state[1] = 'W';
+ else
+ curstatus.state[1] = ' ';
+ if (tasknice < 0)
+ curstatus.state[2] = '<';
+ else if (tasknice > 0)
+ curstatus.state[2] = 'N';
+ else
+ curstatus.state[2] = ' ';
+
+ curstatus.rss <<= (PAGE_SHIFT - 10); /* 2**10 = 1kb */
- /* get and process the information */
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "Name", s->name, sizeof(s->name));
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "State", s->state, sizeof(s->state));
- fgets(buf, sizeof(buf), fp);
- if(process_status(buf, "Tgid", NULL, 0))
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "Pid", NULL, 0);
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "PPid", s->ppid, sizeof(s->ppid));
- fgets(buf, sizeof(buf), fp);
- if(process_status(buf, "TracerPid", NULL, 0))
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "Uid", s->uid, sizeof(s->uid));
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "Gid", NULL, 0);
- fgets(buf, sizeof(buf), fp);
- if(process_status(buf, "FDSize", NULL, 0))
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "Groups", NULL, 0);
- fgets(buf, sizeof(buf), fp);
- /* only user space processes have command line
- * and memory statistics
- */
- if (s->cmd[0]) {
- process_status(buf, "VmSize", s->size, sizeof(s->size));
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "VmLck", s->lck, sizeof(s->lck));
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "VmRSS", s->rss, sizeof(s->rss));
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "VmData", s->data, sizeof(s->data));
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "VmStk", s->stk, sizeof(s->stk));
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "VmExe", s->exe, sizeof(s->exe));
- fgets(buf, sizeof(buf), fp);
- process_status(buf, "VmLib", s->lib, sizeof(s->lib));
+ sprintf(status, "%d/cmdline", pid);
+ if((fp = fopen(status, "r")) == NULL)
+ return 0;
+ if(fgets(buf, sizeof(buf), fp) != NULL) {
+ name = strchr(buf, '\n');
+ if(name != NULL)
+ *name = 0;
+ if(buf[0])
+ curstatus.cmd = strdup(buf); /* if NULL it work true also */
}
fclose(fp);
- /* next process */
- s++;
- }
+ n = ntop;
+ top = xrealloc(top, (++ntop)*sizeof(status_t));
+ memcpy(top + n, &curstatus, sizeof(status_t));
+ return 1;
}
-/* allocs statuslist and reads process command lines, frees namelist,
- * returns filled statuslist or NULL in case of error.
- */
-static status_t *read_info(int num, struct dirent **namelist)
-{
- status_t *statuslist, *s;
- char cmdline[20];
- FILE *fp;
- int idx;
+static struct dirent **namelist;
- /* allocate & zero status for each of the processes */
- statuslist = calloc(num, sizeof(status_t));
- if (!statuslist) {
- return NULL;
- }
-
- /* go through the processes */
- for (idx = 0; idx < num; idx++) {
-
- /* copy PID string to status struct and free name */
- s = &(statuslist[idx]);
- if (strlen(namelist[idx]->d_name) > sizeof(s->pid)-1) {
- fprintf(stderr, "PID '%s' too long\n", namelist[idx]->d_name);
- return NULL;
- }
- strncpy(s->pid, namelist[idx]->d_name, sizeof(s->pid));
- s->pid[sizeof(s->pid)-1] = '\0';
- free(namelist[idx]);
-
- /* read the command line from 'cmdline' in PID dir */
- sprintf(cmdline, "%s/cmdline", s->pid);
- fp = fopen(cmdline, "r");
- if (!fp) {
- fclose(fp);
- perror("fopen('cmdline')");
- return NULL;
- }
- fgets(statuslist[idx].cmd, sizeof(statuslist[idx].cmd), fp);
- fclose(fp);
+static void clearmems(void) {
+ int i;
+
+ for(i = 0; i < ntop; i++) {
+ free(top[i].cmd);
+ free(namelist[i]);
}
+ free(top);
free(namelist);
- return statuslist;
+ top = 0;
+ namelist = 0;
+ ntop = 0;
}
+#if defined CONFIG_FEATURE_USE_TERMIOS
+#include <termios.h>
+#include <sys/time.h>
+#include <signal.h>
-/* returns true for file names which are PID dirs
- * (i.e. start with number)
- */
-static int filter_pids(const struct dirent *dir)
-{
- status_t dummy;
- char *name = dir->d_name;
-
- if (*name >= '0' && *name <= '9') {
- if (strlen(name) > sizeof(dummy.pid)-1) {
- fprintf(stderr, "PID name '%s' too long\n", name);
- return 0;
- }
- return 1;
- }
- return 0;
-}
+static struct termios initial_settings;
-/* compares two directory entry names as numeric strings
- */
-static int num_sort(const void *a, const void *b)
+static void reset_term(void)
{
- int ia = atoi((*(struct dirent **)a)->d_name);
- int ib = atoi((*(struct dirent **)b)->d_name);
+ tcsetattr(0, TCSANOW, (void *) &initial_settings);
+#ifdef CONFIG_FEATURE_CLEAN_UP
+ clearmems();
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ free(save_history);
+#endif
+#endif /* CONFIG_FEATURE_CLEAN_UP */
+}
- if (ia == ib) {
- return 0;
- }
- /* NOTE: by switching the check, you change the process sort order */
- if (ia < ib) {
- return -1;
- } else {
- return 1;
- }
+static void sig_catcher (int sig)
+{
+ reset_term();
}
+#endif /* CONFIG_FEATURE_USE_TERMIOS */
+
int top_main(int argc, char **argv)
{
- status_t *statuslist;
- struct dirent **namelist;
- int opt, num, interval, lines;
-#if defined CONFIG_FEATURE_AUTOWIDTH && defined CONFIG_FEATURE_USE_TERMIOS
+ int opt, interval, lines, col;
+#if defined CONFIG_FEATURE_USE_TERMIOS
+ struct termios new_settings;
+ struct timeval tv;
+ fd_set readfds;
+ unsigned char c;
+ struct sigaction sa;
+#if defined CONFIG_FEATURE_AUTOWIDTH
struct winsize win = { 0, 0, 0, 0 };
#endif
+#endif /* CONFIG_FEATURE_USE_TERMIOS */
+
/* Default update rate is 5 seconds */
interval = 5;
- /* Default to 25 lines - 5 lines for status */
- lines = 25 - 5;
/* do normal option parsing */
while ((opt = getopt(argc, argv, "d:")) > 0) {
}
}
-#if defined CONFIG_FEATURE_AUTOWIDTH && defined CONFIG_FEATURE_USE_TERMIOS
- ioctl(fileno(stdout), TIOCGWINSZ, &win);
- if (win.ws_row > 4)
- lines = win.ws_row - 5;
+ /* Default to 25 lines - 5 lines for status */
+ lines = 25 - 5;
+ /* Default CMD format size */
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ col = 35 - 6;
+#else
+ col = 35;
#endif
-
/* change to proc */
if (chdir("/proc") < 0) {
perror_msg_and_die("chdir('/proc')");
}
-
- /* read process IDs for all the processes from the procfs */
- num = scandir(".", &namelist, filter_pids, num_sort);
- if (num < 0) {
+#if defined CONFIG_FEATURE_USE_TERMIOS
+ tcgetattr(0, (void *) &initial_settings);
+ memcpy(&new_settings, &initial_settings, sizeof(struct termios));
+ new_settings.c_lflag &= ~(ISIG | ICANON); /* unbuffered input */
+ /* Turn off echoing */
+ new_settings.c_lflag &= ~(ECHO | ECHONL);
+
+ signal (SIGTERM, sig_catcher);
+ sigaction (SIGTERM, (struct sigaction *) 0, &sa);
+ sa.sa_flags |= SA_RESTART;
+ sa.sa_flags &= ~SA_INTERRUPT;
+ sigaction (SIGTERM, &sa, (struct sigaction *) 0);
+ sigaction (SIGINT, &sa, (struct sigaction *) 0);
+ tcsetattr(0, TCSANOW, (void *) &new_settings);
+ atexit(reset_term);
+#if defined CONFIG_FEATURE_AUTOWIDTH
+ ioctl(0, TIOCGWINSZ, &win);
+ if (win.ws_row > 4) {
+ lines = win.ws_row - 5;
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ col = win.ws_col - 80 + 35 - 6;
+#else
+ col = win.ws_col - 80 + 35;
+#endif
+ }
+#endif
+#endif /* CONFIG_FEATURE_USE_TERMIOS */
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ sort_function[0] = pcpu_sort;
+ sort_function[1] = mem_sort;
+ sort_function[2] = time_sort;
+#else
+ sort_function = mem_sort;
+#endif
+ while (1) {
+ /* read process IDs & status for all the processes */
+ if (scandir(".", &namelist, filter_pids, 0) < 0) {
perror_msg_and_die("scandir('/proc')");
}
- if (lines > num) {
- lines = num;
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ if(!Hertz) {
+ init_Hertz_value();
+ do_stats();
+ sleep(1);
+ clearmems();
+ continue;
}
-
- /* read command line for each of the processes */
- statuslist = read_info(num, namelist);
- if (!statuslist) {
+ do_stats();
+#else
+ qsort(top, ntop, sizeof(status_t), (void*)sort_function);
+#endif
+ opt = lines;
+ if (opt > ntop) {
+ opt = ntop;
+ }
+ /* show status for each of the processes */
+ display_status(opt, col);
+#if defined CONFIG_FEATURE_USE_TERMIOS
+ tv.tv_sec = interval;
+ tv.tv_usec = 0;
+ FD_ZERO (&readfds);
+ FD_SET (0, &readfds);
+ select (1, &readfds, NULL, NULL, &tv);
+ if (FD_ISSET (0, &readfds)) {
+ if (read (0, &c, 1) <= 0) { /* signal */
return EXIT_FAILURE;
}
-
- while (1) {
- /* read status for each of the processes */
- read_status(num, statuslist);
-
- /* display status */
- display_status(lines, statuslist);
-
+ if(c == 'q' || c == initial_settings.c_cc[VINTR])
+ return EXIT_SUCCESS;
+ if(c == 'M') {
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ sort_function[0] = mem_sort;
+ sort_function[1] = pcpu_sort;
+ sort_function[2] = time_sort;
+#else
+ sort_function = mem_sort;
+#endif
+ }
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ if(c == 'P') {
+ sort_function[0] = pcpu_sort;
+ sort_function[1] = mem_sort;
+ sort_function[2] = time_sort;
+ }
+ if(c == 'T') {
+ sort_function[0] = time_sort;
+ sort_function[1] = mem_sort;
+ sort_function[2] = pcpu_sort;
+ }
+#endif
+ if(c == 'N') {
+#ifdef FEATURE_CPU_USAGE_PERCENTAGE
+ sort_function[0] = pid_sort;
+#else
+ sort_function = pid_sort;
+#endif
+ }
+ }
+#else
sleep(interval);
+#endif /* CONFIG_FEATURE_USE_TERMIOS */
+ clearmems();
}
- free(statuslist);
return EXIT_SUCCESS;
}
projects / platform / upstream / busybox.git / commitdiff