Changeset 1765 in MondoRescue for branches/2.2.5/mindi-busybox/procps

Timestamp:

Nov 4, 2007, 3:16:40 AM (16 years ago)

Author:

Bruno Cornec

Message:

Update to busybox 1.7.2

Location:

branches/2.2.5/mindi-busybox/procps

Files:

• Config.in (modified) (13 diffs)
• Kbuild (added)
• Makefile (deleted)
• Makefile.in (deleted)
• free.c (modified) (4 diffs)
• fuser.c (modified) (17 diffs)
• kill.c (modified) (2 diffs)
• nmeter.c (added)
• pidof.c (modified) (3 diffs)
• ps.c (modified) (1 diff)
• ps.posix (added)
• renice.c (modified) (5 diffs)
• sysctl.c (modified) (9 diffs)
• top.c (modified) (24 diffs)
• uptime.c (modified) (4 diffs)
• watch.c (added)

branches/2.2.5/mindi-busybox/procps/Config.in

@@ -6 +6 @@
 menu "Process Utilities"
 
-config CONFIG_FREE
+config FREE
     bool "free"
     default n
@@ -14 +14 @@
       The shared memory column should be ignored; it is obsolete.
 
-config CONFIG_FUSER
+config FUSER
     bool "fuser"
     default n
@@ -22 +22 @@
       (TCP or UDP) port open.
 
-config CONFIG_KILL
+config KILL
     bool "kill"
     default n
@@ -30 +30 @@
       signal is sent.
 
-config CONFIG_KILLALL
+config KILLALL
     bool "killall"
     default n
-    depends on CONFIG_KILL
+    depends on KILL
     help
       killall sends a signal to all processes running any of the
@@ -39 +39 @@
       sent.
 
-config CONFIG_PIDOF
+config KILLALL5
+    bool "killall5"
+    default n
+    depends on KILL
+
+config NMETER
+    bool "nmeter"
+    default n
+    help
+      Prints selected system stats continuously, one line per update.
+
+config PIDOF
     bool "pidof"
     default n
@@ -46 +57 @@
       those id's on the standard output.
 
-config CONFIG_FEATURE_PIDOF_SINGLE
+config FEATURE_PIDOF_SINGLE
     bool "Enable argument for single shot (-s)"
     default n
-    depends on CONFIG_PIDOF
+    depends on PIDOF
     help
       Support argument '-s' for returning only the first pid found.
 
-config CONFIG_FEATURE_PIDOF_OMIT
+config FEATURE_PIDOF_OMIT
     bool "Enable argument for omitting pids (-o)"
     default n
-    depends on CONFIG_PIDOF
+    depends on PIDOF
     help
       Support argument '-o' for omitting the given pids in output.
@@ -62 +73 @@
       of the pidof, in other words the calling shell or shell script.
 
-config CONFIG_PS
+config PS
     bool "ps"
     default n
@@ -68 +79 @@
       ps gives a snapshot of the current processes.
 
-config CONFIG_FEATURE_PS_WIDE
+config FEATURE_PS_WIDE
     bool "Enable argument for wide output (-w)"
     default n
-    depends on CONFIG_PS
+    depends on PS
     help
       Support argument 'w' for wide output.
@@ -77 +88 @@
       one, the length is unlimited.
 
-config CONFIG_RENICE
+config RENICE
     bool "renice"
     default n
@@ -84 +95 @@
       processes.
 
-config CONFIG_BB_SYSCTL
+config BB_SYSCTL
     bool "sysctl"
     default n
@@ -90 +101 @@
       Configure kernel parameters at runtime.
 
-config CONFIG_TOP
+config TOP
     bool "top"
     default n
@@ -97 +108 @@
       system.
 
-config CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
-    bool "Support showing CPU usage percentage (add 2k bytes)"
+config FEATURE_TOP_CPU_USAGE_PERCENTAGE
+    bool "Show CPU per-process usage percentage (adds 2k bytes)"
     default y
-    depends on CONFIG_TOP
+    depends on TOP
     help
-      Make top display CPU usage.
+      Make top display CPU usage for each process.
 
-config CONFIG_UPTIME
+config FEATURE_TOP_CPU_GLOBAL_PERCENTS
+    bool "Show CPU global usage percentage (adds 0.5k bytes)"
+    default y
+    depends on FEATURE_TOP_CPU_USAGE_PERCENTAGE
+    help
+      Makes top display "CPU: NN% usr NN% sys..." line.
+
+config FEATURE_TOP_DECIMALS
+    bool "Show 1/10th of a percent in CPU/mem statistics (adds 0.3k bytes)"
+    default n
+    depends on FEATURE_TOP_CPU_USAGE_PERCENTAGE
+    help
+      Show 1/10th of a percent in CPU/mem statistics.
+
+config UPTIME
     bool "uptime"
     default n
@@ -112 +137 @@
       on, and the system load averages for the past 1, 5, and 15 minutes.
 
+config WATCH
+    bool "watch"
+    default n
+    #huh?? select DATE
+    help
+      watch is used to execute a program periodically, showing
+      output to the screen.
+
 
 endmenu

branches/2.2.5/mindi-busybox/procps/free.c

@@ -5 +5 @@
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under the GPL version 2, see the file LICENSE in this tarball.
  */
 
 /* getopt not needed */
 
-#include "busybox.h"
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
+#include "libbb.h"
 
+int free_main(int argc, char **argv);
 int free_main(int argc, char **argv)
 {
@@ -21 +19 @@
 
     /* Kernels prior to 2.4.x will return info.mem_unit==0, so cope... */
-    if (info.mem_unit==0) {
+    if (info.mem_unit == 0) {
         info.mem_unit=1;
     }
-    if ( info.mem_unit == 1 ) {
+    if (info.mem_unit == 1) {
         info.mem_unit=1024;
 
@@ -49 +47 @@
     }
 
-    if (argc > 1 && **(argv + 1) == '-')
+    if (argc > 1 && *argv[1] == '-')
         bb_show_usage();
 
@@ -69 +67 @@
     return EXIT_SUCCESS;
 }
-

branches/2.2.5/mindi-busybox/procps/fuser.c

@@ -9 +9 @@
  */
 
-#include "busybox.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <limits.h>
-#include <dirent.h>
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/socket.h>
-#include <sys/sysmacros.h>
+#include "libbb.h"
 
 #define FUSER_PROC_DIR "/proc"
@@ -47 +35 @@
     int opt = 0;
 
-    if(!(strlen(option))) return 0;
-    if(option[0] != '-') return 0;
+    if (!option[0])
+        return 0;
+    if (option[0] != '-')
+        return 0;
     ++option;
-    while(*option != '\0') {
-        if(*option == 'm') opt |= FUSER_OPT_MOUNT;
-        else if(*option == 'k') opt |= FUSER_OPT_KILL;
-        else if(*option == 's') opt |= FUSER_OPT_SILENT;
-        else if(*option == '6') opt |= FUSER_OPT_IP6;
-        else if(*option == '4') opt |= FUSER_OPT_IP4;
-        else {
-            bb_error_msg_and_die(
-                "Unsupported option '%c'", *option);
-        }
+    while (*option != '\0') {
+        if (*option == 'm') opt |= FUSER_OPT_MOUNT;
+        else if (*option == 'k') opt |= FUSER_OPT_KILL;
+        else if (*option == 's') opt |= FUSER_OPT_SILENT;
+        else if (*option == '6') opt |= FUSER_OPT_IP6;
+        else if (*option == '4') opt |= FUSER_OPT_IP4;
+        else
+            bb_error_msg_and_die("unsupported option '%c'", *option);
         ++option;
     }
@@ -69 +57 @@
 {
     struct stat f_stat;
-    if((stat(filename, &f_stat)) < 0) return 0;
+    if ((stat(filename, &f_stat)) < 0)
+        return 0;
     *inode = f_stat.st_ino;
     *dev = f_stat.st_dev;
@@ -81 +70 @@
 
     if (fd >= 0 && (fstat(fd, &buf)) == 0) {
-        *dev =  buf.st_dev;
+        *dev = buf.st_dev;
         close(fd);
         return 1;
@@ -93 +82 @@
     char path[sizeof(FUSER_PROC_DIR)+12], tproto[5];
 
-    if((sscanf(filename, "%d/%4s", port, tproto)) != 2) return 0;
-    sprintf(path, "%s/net/%s", FUSER_PROC_DIR, tproto);
-    if((access(path, R_OK)) != 0) return 0;
-    *proto = bb_xstrdup(tproto);
+    if ((sscanf(filename, "%d/%4s", port, tproto)) != 2)
+        return 0;
+    sprintf(path, FUSER_PROC_DIR "/net/%s", tproto);
+    if ((access(path, R_OK)) != 0)
+        return 0;
+    *proto = xstrdup(tproto);
     return 1;
 }
@@ -104 +95 @@
     pid_list *curr = NULL, *last = NULL;
 
-    if(plist->pid == 0) plist->pid = pid;
+    if (plist->pid == 0)
+        plist->pid = pid;
     curr = plist;
-    while(curr != NULL) {
-        if(curr->pid == pid) return 1;
+    while (curr != NULL) {
+        if (curr->pid == pid)
+            return 1;
         last = curr;
         curr = curr->next;
     }
-    curr = xmalloc(sizeof(pid_list));
+    curr = xzalloc(sizeof(pid_list));
     last->next = curr;
     curr->pid = pid;
-    curr->next = NULL;
+    /*curr->next = NULL;*/
     return 1;
 }
@@ -122 +115 @@
     inode_list *curr = NULL, *last = NULL;
 
-    if(!ilist->inode && !ilist->dev) {
+    if (!ilist->inode && !ilist->dev) {
         ilist->dev = dev;
         ilist->inode = inode;
     }
     curr = ilist;
-    while(curr != NULL) {
-        if(curr->inode == inode && curr->dev == dev) return 1;
+    while (curr != NULL) {
+        if (curr->inode == inode && curr->dev == dev)
+            return 1;
         last = curr;
         curr = curr->next;
     }
-    curr = xmalloc(sizeof(inode_list));
+    curr = xzalloc(sizeof(inode_list));
     last->next = curr;
     curr->dev = dev;
     curr->inode = inode;
-    curr->next = NULL;
+    /*curr->next = NULL;*/
     return 1;
 }
@@ -147 +141 @@
     ino_t tmp_inode;
     dev_t tmp_dev;
-    long long  uint64_inode;
+    long long uint64_inode;
     int tmp_port;
     FILE *f;
 
-    if(!fuser_find_socket_dev(&tmp_dev)) tmp_dev = 0;
-    sprintf(path, "%s/net/%s", FUSER_PROC_DIR, proto);
-
-    if (!(f = fopen(path, "r"))) return 0;
-    while(fgets(line, FUSER_MAX_LINE, f)) {
-        if(sscanf(line,
-            "%*d: %64[0-9A-Fa-f]:%x %*x:%*x %*x %*x:%*x "
-            "%*x:%*x %*x %*d %*d %llu",
-            addr, &tmp_port, &uint64_inode) == 3) {
-            if((strlen(addr) == 8) &&
-                (opts & FUSER_OPT_IP6)) continue;
-            else if((strlen(addr) > 8) &&
-                (opts & FUSER_OPT_IP4)) continue;
-            if(tmp_port == port) {
+    if (!fuser_find_socket_dev(&tmp_dev))
+        tmp_dev = 0;
+    sprintf(path, FUSER_PROC_DIR "/net/%s", proto);
+
+    f = fopen(path, "r");
+    if (!f)
+        return 0;
+    while (fgets(line, FUSER_MAX_LINE, f)) {
+        if (sscanf(line, "%*d: %64[0-9A-Fa-f]:%x %*x:%*x %*x %*x:%*x "
+                "%*x:%*x %*x %*d %*d %llu",
+                addr, &tmp_port, &uint64_inode) == 3
+        ) {
+            if (strlen(addr) == 8 && (opts & FUSER_OPT_IP6))
+                continue;
+            if (strlen(addr) > 8 && (opts & FUSER_OPT_IP4))
+                continue;
+            if (tmp_port == port) {
                 tmp_inode = uint64_inode;
                 fuser_add_inode(ilist, tmp_dev, tmp_inode);
             }
         }
-
     }
     fclose(f);
@@ -181 +177 @@
     curr = ilist;
 
-    while(curr) {
-        if((opts & FUSER_OPT_MOUNT) &&  curr->dev == dev)
+    while (curr) {
+        if ((opts & FUSER_OPT_MOUNT) && curr->dev == dev)
             return 1;
-        if(curr->inode == inode && curr->dev == dev)
+        if (curr->inode == inode && curr->dev == dev)
             return 1;
         curr = curr->next;
@@ -201 +197 @@
     dev_t dev;
 
-    if (!(file = fopen(fname, "r"))) return 0;
+    file = fopen(fname, "r");
+    if (!file)
+        return 0;
     while (fgets(line, FUSER_MAX_LINE, file)) {
-        if(sscanf(line, "%*s %*s %*s %x:%x %llu",
-            &major, &minor, &uint64_inode) != 3) continue;
+        if (sscanf(line, "%*s %*s %*s %x:%x %llu", &major, &minor, &uint64_inode) != 3)
+            continue;
         inode = uint64_inode;
-        if(major == 0 && minor == 0 && inode == 0) continue;
+        if (major == 0 && minor == 0 && inode == 0)
+            continue;
         dev = makedev(major, minor);
-        if(fuser_search_dev_inode(opts, ilist, dev, inode)) {
+        if (fuser_search_dev_inode(opts, ilist, dev, inode)) {
             fuser_add_pid(plist, pid);
         }
-
     }
     fclose(file);
@@ -223 +221 @@
     dev_t dev;
 
-    if(!fuser_file_to_dev_inode(lname, &dev, &inode)) return 0;
-    if(fuser_search_dev_inode(opts, ilist, dev, inode))
+    if (!fuser_file_to_dev_inode(lname, &dev, &inode))
+        return 0;
+    if (fuser_search_dev_inode(opts, ilist, dev, inode))
         fuser_add_pid(plist, pid);
     return 1;
@@ -236 +235 @@
     char *lname;
 
-    if((d = opendir(dname))) {
-        while((de = readdir(d)) != NULL) {
-            lname = concat_subpath_file(dname, de->d_name);
-            if(lname == NULL)
-                continue;
-            fuser_scan_link(opts, lname, pid, ilist, plist);
-            free(lname);
-        }
-        closedir(d);
-    }
-    else return 0;
-    return 1;
-
+    d = opendir(dname);
+    if (!d)
+        return 0;
+    while ((de = readdir(d)) != NULL) {
+        lname = concat_subpath_file(dname, de->d_name);
+        if (lname == NULL)
+            continue;
+        fuser_scan_link(opts, lname, pid, ilist, plist);
+        free(lname);
+    }
+    closedir(d);
+    return 1;
 }
 
@@ -258 +256 @@
     char *dname;
 
-    if(!(d = opendir(FUSER_PROC_DIR))) return 0;
-    while((de = readdir(d)) != NULL) {
+    d = opendir(FUSER_PROC_DIR);
+    if (!d)
+        return 0;
+    while ((de = readdir(d)) != NULL) {
         pid = (pid_t)atoi(de->d_name);
-        if(!pid) continue;
+        if (!pid)
+            continue;
         dname = concat_subpath_file(FUSER_PROC_DIR, de->d_name);
-        if(chdir(dname) < 0) {
+        if (chdir(dname) < 0) {
             free(dname);
             continue;
@@ -285 +286 @@
     pid_list *curr = plist;
 
-    if(plist == NULL) return 0;
-    while(curr != NULL) {
-        if(curr->pid > 0) printf("%d ", curr->pid);
-        curr = curr->next;
-    }
-    printf("\n");
+    if (plist == NULL)
+        return 0;
+    while (curr != NULL) {
+        if (curr->pid > 0)
+            printf("%d ", curr->pid);
+        curr = curr->next;
+    }
+    puts("");
     return 1;
 }
@@ -300 +303 @@
     int success = 1;
 
-    if(plist == NULL) return 0;
-    while(curr != NULL) {
-        if(curr->pid > 0 && curr->pid != mypid) {
+    if (plist == NULL)
+        return 0;
+    while (curr != NULL) {
+        if (curr->pid > 0 && curr->pid != mypid) {
             if (kill(curr->pid, sig) != 0) {
-                bb_perror_msg(
-                    "Could not kill pid '%d'", curr->pid);
+                bb_perror_msg("kill pid '%d'", curr->pid);
                 success = 0;
             }
@@ -314 +317 @@
 }
 
+int fuser_main(int argc, char **argv);
 int fuser_main(int argc, char **argv)
 {
+    /*static -- huh???*/ int opt = 0; /* FUSER_OPT_ */
+
     int port, i, optn;
     int* fni; /* file name indexes of argv */
     int fnic = 0;  /* file name index count */
     const char *proto;
-    static int opt = 0; /* FUSER_OPT_ */
     dev_t dev;
     ino_t inode;
@@ -332 +337 @@
 
     fni = xmalloc(sizeof(int));
-    for(i=1;i<argc;i++) {
+    for (i = 1; i < argc; i++) {
         optn = fuser_option(argv[i]);
-        if(optn) opt |= optn;
-        else if(argv[i][0] == '-') {
-            if(!(u_signal_names(argv[i]+1, &killsig, 0)))
+        if (optn)
+            opt |= optn;
+        else if (argv[i][0] == '-') {
+            killsig = get_signum(argv[i]+1);
+            if (killsig < 0)
                 killsig = SIGTERM;
-        }
-        else {
+        } else {
             fni = xrealloc(fni, sizeof(int) * (fnic+2));
             fni[fnic++] = i;
         }
     }
-    if(!fnic) return 1;
-
-    pids = xmalloc(sizeof(pid_list));
+
+    if (!fnic)
+        return 1;
+
     inodes = xmalloc(sizeof(inode_list));
-    for(i=0;i<fnic;i++) {
-        if(fuser_parse_net_arg(argv[fni[i]], &proto, &port)) {
+    for (i = 0; i < fnic; i++) {
+        if (fuser_parse_net_arg(argv[fni[i]], &proto, &port)) {
             fuser_scan_proc_net(opt, proto, port, inodes);
-        }
-        else {
-            if(!fuser_file_to_dev_inode(
-                argv[fni[i]], &dev, &inode)) {
-                free(pids);
-                free(inodes);
-                bb_perror_msg_and_die(
-                    "Could not open '%s'", argv[fni[i]]);
+        } else {
+            if (!fuser_file_to_dev_inode(argv[fni[i]], &dev, &inode)) {
+                if (ENABLE_FEATURE_CLEAN_UP)
+                    free(inodes);
+                bb_perror_msg_and_die("cannot open '%s'", argv[fni[i]]);
             }
             fuser_add_inode(inodes, dev, inode);
         }
     }
+    pids = xmalloc(sizeof(pid_list));
     success = fuser_scan_proc_pids(opt, inodes, pids);
     /* if the first pid in the list is 0, none have been found */
-    if(pids->pid == 0) success = 0;
-    if(success) {
-        if(opt & FUSER_OPT_KILL) {
+    if (pids->pid == 0)
+        success = 0;
+    if (success) {
+        if (opt & FUSER_OPT_KILL) {
             success = fuser_kill_pid_list(pids, killsig);
-        }
-        else if(!(opt & FUSER_OPT_SILENT)) {
+        } else if (!(opt & FUSER_OPT_SILENT)) {
             success = fuser_print_pid_list(pids);
         }
     }
-    free(pids);
-    free(inodes);
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        free(pids);
+        free(inodes);
+    }
     /* return 0 on (success == 1) 1 otherwise */
     return (success != 1);

branches/2.2.5/mindi-busybox/procps/kill.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * Mini kill/killall implementation for busybox
+ * Mini kill/killall[5] implementation for busybox
  *
  * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
@@ -9 +9 @@
  */
 
-#include "busybox.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <unistd.h>
-#include <signal.h>
-#include <ctype.h>
-#include <string.h>
-#include <unistd.h>
+#include "libbb.h"
 
-#define KILL 0
-#define KILLALL 1
+/* Note: kill_main is directly called from shell in order to implement
+ * kill built-in. Shell substitutes job ids with process groups first.
+ *
+ * This brings some complications:
+ *
+ * + we can't use xfunc here
+ * + we can't use applet_name
+ * + we can't use bb_show_usage
+ * (Above doesn't apply for killall[5] cases)
+ *
+ * kill %n gets translated into kill ' -<process group>' by shell (note space!)
+ * This is needed to avoid collision with kill -9 ... syntax
+ */
 
+int kill_main(int argc, char **argv);
 int kill_main(int argc, char **argv)
 {
-    int whichApp, signo = SIGTERM;
-    const char *name;
-    int errors = 0;
-
-#ifdef CONFIG_KILLALL
-    int quiet=0;
-    /* Figure out what we are trying to do here */
-    whichApp = (strcmp(bb_applet_name, "killall") == 0)? KILLALL : KILL;
+    char *arg;
+    pid_t pid;
+    int signo = SIGTERM, errors = 0, quiet = 0;
+#if !ENABLE_KILLALL && !ENABLE_KILLALL5
+#define killall 0
+#define killall5 0
 #else
-    whichApp = KILL;
+/* How to determine who we are? find 3rd char from the end:
+ * kill, killall, killall5
+ *  ^i       ^a        ^l  - it's unique
+ * (checking from the start is complicated by /bin/kill... case) */
+    const char char3 = argv[0][strlen(argv[0]) - 3];
+#define killall (ENABLE_KILLALL && char3 == 'a')
+#define killall5 (ENABLE_KILLALL5 && char3 == 'l')
 #endif
 
     /* Parse any options */
-    if (argc < 2)
-        bb_show_usage();
+    argc--;
+    arg = *++argv;
 
-    if(argv[1][0] != '-'){
-        argv++;
-        argc--;
+    if (argc < 1 || arg[0] != '-') {
         goto do_it_now;
     }
 
-    /* The -l option, which prints out signal names. */
-    if(argv[1][1]=='l' && argv[1][2]=='\0'){
-        if(argc==2) {
+    /* The -l option, which prints out signal names.
+     * Intended usage in shell:
+     * echo "Died of SIG`kill -l $?`"
+     * We try to mimic what kill from coreutils-6.8 does */
+    if (arg[1] == 'l' && arg[2] == '\0') {
+        if (argc == 1) {
             /* Print the whole signal list */
-            int col = 0;
-            for(signo=1; signo < NSIG; signo++) {
-                name = u_signal_names(0, &signo, 1);
-                if(name==NULL)  /* unnamed */
-                    continue;
-                col += printf("%2d) %-16s", signo, name);
-                if (col > 60) {
-                    printf("\n");
-                    col = 0;
+            for (signo = 1; signo < 32; signo++) {
+                const char *name = get_signame(signo);
+                if (!isdigit(name[0]))
+                    puts(name);
+            }
+        } else { /* -l <sig list> */
+            while ((arg = *++argv)) {
+                if (isdigit(arg[0])) {
+                    signo = bb_strtou(arg, NULL, 10);
+                    if (errno) {
+                        bb_error_msg("unknown signal '%s'", arg);
+                        return EXIT_FAILURE;
+                    }
+                    /* Exitcodes >= 0x80 are to be treated
+                     * as "killed by signal (exitcode & 0x7f)" */
+                    puts(get_signame(signo & 0x7f));
+                    /* TODO: 'bad' signal# - coreutils says:
+                     * kill: 127: invalid signal
+                     * we just print "127" instead */
+                } else {
+                    signo = get_signum(arg);
+                    if (signo < 0) {
+                        bb_error_msg("unknown signal '%s'", arg);
+                        return EXIT_FAILURE;
+                    }
+                    printf("%d\n", signo);
                 }
             }
-            printf("\n");
-
-        } else {
-            for(argv++; *argv; argv++) {
-                name = u_signal_names(*argv, &signo, -1);
-                if(name!=NULL)
-                    printf("%s\n", name);
-            }
         }
-        /* If they specified -l, were all done */
+        /* If they specified -l, we are all done */
         return EXIT_SUCCESS;
     }
 
-#ifdef CONFIG_KILLALL
     /* The -q quiet option */
-    if(whichApp != KILL && argv[1][1]=='q' && argv[1][2]=='\0'){
-        quiet++;
-        argv++;
+    if (killall && arg[1] == 'q' && arg[2] == '\0') {
+        quiet = 1;
+        arg = *++argv;
         argc--;
-        if(argc<2 || argv[1][0] != '-'){
-            goto do_it_now;
-        }
+        if (argc < 1) bb_show_usage();
+        if (arg[0] != '-') goto do_it_now;
     }
-#endif
 
-    if(!u_signal_names(argv[1]+1, &signo, 0))
-        bb_error_msg_and_die( "bad signal name '%s'", argv[1]+1);
-    argv+=2;
-    argc-=2;
+    /* -SIG */
+    signo = get_signum(&arg[1]);
+    if (signo < 0) { /* || signo > MAX_SIGNUM ? */
+        bb_error_msg("bad signal name '%s'", &arg[1]);
+        return EXIT_FAILURE;
+    }
+    arg = *++argv;
+    argc--;
 
 do_it_now:
 
-    /* Pid or name required */
-    if (argc <= 0)
-        bb_show_usage();
+    if (killall5) {
+        pid_t sid;
+        procps_status_t* p = NULL;
 
-    if (whichApp == KILL) {
-        /* Looks like they want to do a kill. Do that */
-        while (--argc >= 0) {
-            int pid;
+        /* Now stop all processes */
+        kill(-1, SIGSTOP);
+        /* Find out our own session id */
+        pid = getpid();
+        sid = getsid(pid);
+        /* Now kill all processes except our session */
+        while ((p = procps_scan(p, PSSCAN_PID|PSSCAN_SID))) {
+            if (p->sid != sid && p->pid != pid && p->pid != 1)
+                kill(p->pid, signo);
+        }
+        /* And let them continue */
+        kill(-1, SIGCONT);
+        return 0;
+    }
 
-            if (!isdigit(**argv) && **argv != '-')
-                bb_error_msg_and_die( "Bad PID '%s'", *argv);
-            pid = strtol(*argv, NULL, 0);
-            if (kill(pid, signo) != 0) {
-                bb_perror_msg( "Could not kill pid '%d'", pid);
+    /* Pid or name is required for kill/killall */
+    if (argc < 1) {
+        puts("You need to specify whom to kill");
+        return EXIT_FAILURE;
+    }
+
+    if (killall) {
+        /* Looks like they want to do a killall.  Do that */
+        pid = getpid();
+        while (arg) {
+            pid_t* pidList;
+
+            pidList = find_pid_by_name(arg);
+            if (*pidList == 0) {
                 errors++;
-            }
-            argv++;
-        }
+                if (!quiet)
+                    bb_error_msg("%s: no process killed", arg);
+            } else {
+                pid_t *pl;
 
-    }
-#ifdef CONFIG_KILLALL
-    else {
-        pid_t myPid=getpid();
-        /* Looks like they want to do a killall.  Do that */
-        while (--argc >= 0) {
-            long* pidList;
-
-            pidList = find_pid_by_name(*argv);
-            if (!pidList || *pidList<=0) {
-                errors++;
-                if (quiet==0)
-                    bb_error_msg( "%s: no process killed", *argv);
-            } else {
-                long *pl;
-
-                for(pl = pidList; *pl !=0 ; pl++) {
-                    if (*pl==myPid)
+                for (pl = pidList; *pl; pl++) {
+                    if (*pl == pid)
                         continue;
-                    if (kill(*pl, signo) != 0) {
-                        errors++;
-                        if (quiet==0)
-                            bb_perror_msg( "Could not kill pid '%ld'", *pl);
-                    }
+                    if (kill(*pl, signo) == 0)
+                        continue;
+                    errors++;
+                    if (!quiet)
+                        bb_perror_msg("cannot kill pid %u", (unsigned)*pl);
                 }
             }
             free(pidList);
-            argv++;
+            arg = *++argv;
         }
+        return errors;
     }
-#endif
+
+    /* Looks like they want to do a kill. Do that */
+    while (arg) {
+        /* Support shell 'space' trick */
+        if (arg[0] == ' ')
+            arg++;
+        pid = bb_strtoi(arg, NULL, 10);
+        if (errno) {
+            bb_error_msg("bad pid '%s'", arg);
+            errors++;
+        } else if (kill(pid, signo) != 0) {
+            bb_perror_msg("cannot kill pid %d", (int)pid);
+            errors++;
+        }
+        arg = *++argv;
+    }
     return errors;
 }

branches/2.2.5/mindi-busybox/procps/pidof.c

@@ -5 +5 @@
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
  *
- * Licensed under the GPL v2, see the file LICENSE in this tarball.
+ * Licensed under the GPL version 2, see the file LICENSE in this tarball.
  */
 
-#include "busybox.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <unistd.h>
-#include <signal.h>
-#include <ctype.h>
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include "libbb.h"
 
-#if ENABLE_FEATURE_PIDOF_SINGLE
-#define _SINGLE_COMPL(a) a
-#define SINGLE (1<<0)
-#else
-#define _SINGLE_COMPL(a)
-#define SINGLE (0)
-#endif
+enum {
+    USE_FEATURE_PIDOF_SINGLE(OPTBIT_SINGLE,)
+    USE_FEATURE_PIDOF_OMIT(  OPTBIT_OMIT  ,)
+    OPT_SINGLE = USE_FEATURE_PIDOF_SINGLE((1<<OPTBIT_SINGLE)) + 0,
+    OPT_OMIT   = USE_FEATURE_PIDOF_OMIT(  (1<<OPTBIT_OMIT  )) + 0,
+};
 
-#if ENABLE_FEATURE_PIDOF_OMIT
-#define _OMIT_COMPL(a) a
-#define _OMIT(a) ,a
-#if ENABLE_FEATURE_PIDOF_SINGLE
-#define OMIT (1<<1)
-#else
-#define OMIT (1<<0)
-#endif
-#else
-#define _OMIT_COMPL(a) ""
-#define _OMIT(a)
-#define OMIT (0)
-#define omitted (0)
-#endif
-
+int pidof_main(int argc, char **argv);
 int pidof_main(int argc, char **argv)
 {
-    unsigned n = 0;
-    unsigned fail = 1;
-    unsigned long int opt;
+    unsigned first = 1;
+    unsigned opt;
 #if ENABLE_FEATURE_PIDOF_OMIT
+    char ppid_str[sizeof(int)*3 + 1];
     llist_t *omits = NULL; /* list of pids to omit */
-    bb_opt_complementally = _OMIT_COMPL("o::");
+    opt_complementary = "o::";
 #endif
 
     /* do unconditional option parsing */
-    opt = bb_getopt_ulflags(argc, argv,
-                    _SINGLE_COMPL("s") _OMIT_COMPL("o:")
-                    _OMIT(&omits));
+    opt = getopt32(argv, ""
+            USE_FEATURE_PIDOF_SINGLE ("s")
+            USE_FEATURE_PIDOF_OMIT("o:", &omits));
 
 #if ENABLE_FEATURE_PIDOF_OMIT
     /* fill omit list.  */
     {
-        char getppid_str[32];
-        llist_t * omits_p = omits;
+        llist_t *omits_p = omits;
         while (omits_p) {
             /* are we asked to exclude the parent's process ID?  */
-            if (!strncmp(omits_p->data, "%PPID", 5)) {
-                llist_pop(&omits_p);
-                snprintf(getppid_str, sizeof(getppid_str), "%d", getppid());
-                llist_add_to(&omits_p, getppid_str);
+            if (strcmp(omits_p->data, "%PPID") == 0) {
+                sprintf(ppid_str, "%u", (unsigned)getppid());
+                omits_p->data = ppid_str;
             }
             omits_p = omits_p->link;
@@ -74 +48 @@
 #endif
     /* Looks like everything is set to go.  */
-    while(optind < argc) {
-        long *pidList;
-        long *pl;
+    while (optind < argc) {
+        pid_t *pidList;
+        pid_t *pl;
 
         /* reverse the pidlist like GNU pidof does.  */
         pidList = pidlist_reverse(find_pid_by_name(argv[optind]));
-        for(pl = pidList; *pl > 0; pl++) {
+        for (pl = pidList; *pl; pl++) {
 #if ENABLE_FEATURE_PIDOF_OMIT
-            unsigned omitted = 0;
-            if (opt & OMIT) {
+            if (opt & OPT_OMIT) {
                 llist_t *omits_p = omits;
-                while (omits_p)
-                    if (strtol(omits_p->data, NULL, 10) == *pl) {
-                        omitted = 1; break;
-                    } else
-                        omits_p = omits_p->link;
+                while (omits_p) {
+                    if (xatoul(omits_p->data) == *pl) {
+                        goto omitting;
+                    }
+                    omits_p = omits_p->link;
+                }
             }
 #endif
-            if (!omitted) {
-                if (n) {
-                    putchar(' ');
-                } else {
-                    n = 1;
-                }
-                printf("%ld", *pl);
-            }
-            fail = (!ENABLE_FEATURE_PIDOF_OMIT && omitted);
-
-            if (ENABLE_FEATURE_PIDOF_SINGLE && (opt & SINGLE))
+            printf(" %u" + first, (unsigned)*pl);
+            first = 0;
+            if (ENABLE_FEATURE_PIDOF_SINGLE && (opt & OPT_SINGLE))
                 break;
+#if ENABLE_FEATURE_PIDOF_OMIT
+ omitting: ;
+#endif
         }
         free(pidList);
@@ -114 +83 @@
         llist_free(omits, NULL);
 #endif
-    return fail ? EXIT_FAILURE : EXIT_SUCCESS;
+    return first; /* 1 (failure) - no processes found */
 }

branches/2.2.5/mindi-busybox/procps/ps.c

@@ -4 +4 @@
  *
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ * Fix for SELinux Support:(c)2007 Hiroshi Shinji <shiroshi@my.email.ne.jp>
+                           (c)2007 Yuichi Nakamura <ynakam@hitachisoft.jp>
  *
- * Licensed under the GPL v2, see the file LICENSE in this tarball.
+ * Licensed under the GPL version 2, see the file LICENSE in this tarball.
  */
 
-#include "busybox.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <string.h>
-#include <termios.h>
-#include <sys/ioctl.h>
-#if ENABLE_SELINUX
-#include <selinux/selinux.h>  /* for is_selinux_enabled()  */
-#endif
-
+#include "libbb.h"
+
+/* Absolute maximum on output line length */
+enum { MAX_WIDTH = 2*1024 };
+
+#if ENABLE_DESKTOP
+
+/* Print value to buf, max size+1 chars (including trailing '\0') */
+
+static void func_user(char *buf, int size, const procps_status_t *ps)
+{
+    safe_strncpy(buf, get_cached_username(ps->uid), size+1);
+}
+
+static void func_comm(char *buf, int size, const procps_status_t *ps)
+{
+    safe_strncpy(buf, ps->comm, size+1);
+}
+
+static void func_args(char *buf, int size, const procps_status_t *ps)
+{
+    read_cmdline(buf, size, ps->pid, ps->comm);
+}
+
+static void func_pid(char *buf, int size, const procps_status_t *ps)
+{
+    sprintf(buf, "%*u", size, ps->pid);
+}
+
+static void func_ppid(char *buf, int size, const procps_status_t *ps)
+{
+    sprintf(buf, "%*u", size, ps->ppid);
+}
+
+static void func_pgid(char *buf, int size, const procps_status_t *ps)
+{
+    sprintf(buf, "%*u", size, ps->pgid);
+}
+
+static void put_u(char *buf, int size, unsigned u)
+{
+    char buf5[5];
+    smart_ulltoa5( ((unsigned long long)u) << 10, buf5);
+    sprintf(buf, "%.*s", size, buf5);
+}
+
+static void func_vsz(char *buf, int size, const procps_status_t *ps)
+{
+    put_u(buf, size, ps->vsz);
+}
+
+static void func_rss(char *buf, int size, const procps_status_t *ps)
+{
+    put_u(buf, size, ps->rss);
+}
+
+static void func_tty(char *buf, int size, const procps_status_t *ps)
+{
+    buf[0] = '?';
+    buf[1] = '\0';
+    if (ps->tty_major) /* tty field of "0" means "no tty" */
+        snprintf(buf, size+1, "%u,%u", ps->tty_major, ps->tty_minor);
+}
+
+#if ENABLE_SELINUX
+static void func_label(char *buf, int size, const procps_status_t *ps)
+{
+    safe_strncpy(buf, ps->context ? ps->context : "unknown", size+1);
+}
+#endif
+
+/*
+static void func_nice(char *buf, int size, const procps_status_t *ps)
+{
+    ps->???
+}
+
+static void func_etime(char *buf, int size, const procps_status_t *ps)
+{
+    elapled time [[dd-]hh:]mm:ss
+}
+
+static void func_time(char *buf, int size, const procps_status_t *ps)
+{
+    cumulative time [[dd-]hh:]mm:ss
+}
+
+static void func_pcpu(char *buf, int size, const procps_status_t *ps)
+{
+}
+*/
+
+typedef struct {
+    uint16_t width;
+    char name[6];
+    const char *header;
+    void (*f)(char *buf, int size, const procps_status_t *ps);
+    int ps_flags;
+} ps_out_t;
+
+static const ps_out_t out_spec[] = {
+// Mandated by POSIX:
+    { 8                  , "user"  ,"USER"   ,func_user  ,PSSCAN_UIDGID  },
+    { 16                 , "comm"  ,"COMMAND",func_comm  ,PSSCAN_COMM    },
+    { 256                , "args"  ,"COMMAND",func_args  ,PSSCAN_COMM    },
+    { 5                  , "pid"   ,"PID"    ,func_pid   ,PSSCAN_PID     },
+    { 5                  , "ppid"  ,"PPID"   ,func_ppid  ,PSSCAN_PPID    },
+    { 5                  , "pgid"  ,"PGID"   ,func_pgid  ,PSSCAN_PGID    },
+//  { sizeof("ELAPSED")-1, "etime" ,"ELAPSED",func_etime ,PSSCAN_        },
+//  { sizeof("GROUP"  )-1, "group" ,"GROUP"  ,func_group ,PSSCAN_UIDGID  },
+//  { sizeof("NI"     )-1, "nice"  ,"NI"     ,func_nice  ,PSSCAN_        },
+//  { sizeof("%CPU"   )-1, "pcpu"  ,"%CPU"   ,func_pcpu  ,PSSCAN_        },
+//  { sizeof("RGROUP" )-1, "rgroup","RGROUP" ,func_rgroup,PSSCAN_UIDGID  },
+//  { sizeof("RUSER"  )-1, "ruser" ,"RUSER"  ,func_ruser ,PSSCAN_UIDGID  },
+//  { sizeof("TIME"   )-1, "time"  ,"TIME"   ,func_time  ,PSSCAN_        },
+    { 6                  , "tty"   ,"TT"     ,func_tty   ,PSSCAN_TTY     },
+    { 4                  , "vsz"   ,"VSZ"    ,func_vsz   ,PSSCAN_VSZ     },
+// Not mandated by POSIX, but useful:
+    { 4                  , "rss"   ,"RSS"    ,func_rss   ,PSSCAN_RSS     },
+#if ENABLE_SELINUX
+    { 35                 , "label" ,"LABEL"  ,func_label ,PSSCAN_CONTEXT },
+#endif
+};
+
+#if ENABLE_SELINUX
+#define SELINIX_O_PREFIX "label,"
+#define DEFAULT_O_STR    SELINIX_O_PREFIX "pid,user" /* TODO: ,vsz,stat */ ",args"
+#else
+#define DEFAULT_O_STR    "pid,user" /* TODO: ,vsz,stat */ ",args"
+#endif
+
+struct globals {
+    ps_out_t* out;
+    int out_cnt;
+    int print_header;
+    int need_flags;
+    char *buffer;
+    unsigned terminal_width;
+    char default_o[sizeof(DEFAULT_O_STR)];
+};
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define out            (G.out           )
+#define out_cnt        (G.out_cnt       )
+#define print_header   (G.print_header  )
+#define need_flags     (G.need_flags    )
+#define buffer         (G.buffer        )
+#define terminal_width (G.terminal_width)
+#define default_o      (G.default_o     )
+
+static ps_out_t* new_out_t(void)
+{
+    int i = out_cnt++;
+    out = xrealloc(out, out_cnt * sizeof(*out));
+    return &out[i];
+}
+
+static const ps_out_t* find_out_spec(const char *name)
+{
+    int i;
+    for (i = 0; i < ARRAY_SIZE(out_spec); i++) {
+        if (!strcmp(name, out_spec[i].name))
+            return &out_spec[i];
+    }
+    bb_error_msg_and_die("bad -o argument '%s'", name);
+}
+
+static void parse_o(char* opt)
+{
+    ps_out_t* new;
+    // POSIX: "-o is blank- or comma-separated list" (FIXME)
+    char *comma, *equal;
+    while (1) {
+        comma = strchr(opt, ',');
+        equal = strchr(opt, '=');
+        if (comma && (!equal || equal > comma)) {
+            *comma = '\0';
+            *new_out_t() = *find_out_spec(opt);
+            *comma = ',';
+            opt = comma + 1;
+            continue;
+        }
+        break;
+    }
+    // opt points to last spec in comma separated list.
+    // This one can have =HEADER part.
+    new = new_out_t();
+    if (equal)
+        *equal = '\0';
+    *new = *find_out_spec(opt);
+    if (equal) {
+        *equal = '=';
+        new->header = equal + 1;
+        // POSIX: the field widths shall be ... at least as wide as
+        // the header text (default or overridden value).
+        // If the header text is null, such as -o user=,
+        // the field width shall be at least as wide as the
+        // default header text
+        if (new->header[0]) {
+            new->width = strlen(new->header);
+            print_header = 1;
+        }
+    } else
+        print_header = 1;
+}
+
+static void post_process(void)
+{
+    int i;
+    int width = 0;
+    for (i = 0; i < out_cnt; i++) {
+        need_flags |= out[i].ps_flags;
+        if (out[i].header[0]) {
+            print_header = 1;
+        }
+        width += out[i].width + 1; /* "FIELD " */
+    }
+#if ENABLE_SELINUX
+    if (!is_selinux_enabled())
+        need_flags &= ~PSSCAN_CONTEXT;
+#endif
+    buffer = xmalloc(width + 1); /* for trailing \0 */
+}
+
+static void format_header(void)
+{
+    int i;
+    ps_out_t* op;
+    char *p;
+
+    if (!print_header)
+        return;
+    p = buffer;
+    i = 0;
+    if (out_cnt) {
+        while (1) {
+            op = &out[i];
+            if (++i == out_cnt) /* do not pad last field */
+                break;
+            p += sprintf(p, "%-*s ", op->width, op->header);
+        }
+        strcpy(p, op->header);
+    }
+    printf("%.*s\n", terminal_width, buffer);
+}
+
+static void format_process(const procps_status_t *ps)
+{
+    int i, len;
+    char *p = buffer;
+    i = 0;
+    if (out_cnt) while (1) {
+        out[i].f(p, out[i].width, ps);
+        // POSIX: Any field need not be meaningful in all
+        // implementations. In such a case a hyphen ( '-' )
+        // should be output in place of the field value.
+        if (!p[0]) {
+            p[0] = '-';
+            p[1] = '\0';
+        }
+        len = strlen(p);
+        p += len;
+        len = out[i].width - len + 1;
+        if (++i == out_cnt) /* do not pad last field */
+            break;
+        p += sprintf(p, "%*s", len, "");
+    }
+    printf("%.*s\n", terminal_width, buffer);
+}
+
+int ps_main(int argc, char **argv);
 int ps_main(int argc, char **argv)
 {
-    procps_status_t * p;
-    int i, len;
-
-#if ENABLE_SELINUX
-    int use_selinux = 0;
-    security_context_t sid=NULL;
-#endif
-
-#if ENABLE_FEATURE_PS_WIDE
+    procps_status_t *p;
+    llist_t* opt_o = NULL;
+    USE_SELINUX(int opt;)
+
+    // POSIX:
+    // -a  Write information for all processes associated with terminals
+    //     Implementations may omit session leaders from this list
+    // -A  Write information for all processes
+    // -d  Write information for all processes, except session leaders
+    // -e  Write information for all processes (equivalent to -A.)
+    // -f  Generate a full listing
+    // -l  Generate a long listing
+    // -o col1,col2,col3=header
+    //     Select which columns to display
+    /* We allow (and ignore) most of the above. FIXME */
+    opt_complementary = "o::";
+    USE_SELINUX(opt =) getopt32(argv, "Zo:aAdefl", &opt_o);
+    if (opt_o) {
+        do {
+            parse_o(opt_o->data);
+            opt_o = opt_o->link;
+        } while (opt_o);
+    } else {
+        /* Below: parse_o() needs char*, NOT const char*... */
+#if ENABLE_SELINUX
+        if (!(opt & 1) || !is_selinux_enabled()) {
+            /* no -Z or no SELinux: do not show LABEL */
+            strcpy(default_o, DEFAULT_O_STR + sizeof(SELINIX_O_PREFIX)-1);
+        } else
+#endif
+        {
+            strcpy(default_o, DEFAULT_O_STR);
+        }
+        parse_o(default_o);
+    }
+    post_process();
+
+    /* Was INT_MAX, but some libc's go belly up with printf("%.*s")
+     * and such large widths */
+    terminal_width = MAX_WIDTH;
+    if (isatty(1)) {
+        get_terminal_width_height(0, &terminal_width, NULL);
+        if (--terminal_width > MAX_WIDTH)
+            terminal_width = MAX_WIDTH;
+    }
+    format_header();
+
+    p = NULL;
+    while ((p = procps_scan(p, need_flags))) {
+        format_process(p);
+    }
+
+    return EXIT_SUCCESS;
+}
+
+
+#else /* !ENABLE_DESKTOP */
+
+
+int ps_main(int argc, char **argv);
+int ps_main(int argc, char **argv)
+{
+    procps_status_t *p = NULL;
+    int len;
+    SKIP_SELINUX(const) int use_selinux = 0;
+    USE_SELINUX(int i;)
+#if !ENABLE_FEATURE_PS_WIDE
+    enum { terminal_width = 79 };
+#else
     int terminal_width;
     int w_count = 0;
-
-    bb_opt_complementally="-:ww";
-#else
-# define terminal_width 79
 #endif
 
 #if ENABLE_FEATURE_PS_WIDE || ENABLE_SELINUX
-    /* handle arguments */
-#if ENABLE_FEATURE_PS_WIDE && ENABLE_SELINUX
-    i = bb_getopt_ulflags(argc, argv, "wc", &w_count);
-#elif ENABLE_FEATURE_PS_WIDE && !ENABLE_SELINUX
-    bb_getopt_ulflags(argc, argv, "w", &w_count);
-#else /* !ENABLE_FEATURE_PS_WIDE && ENABLE_SELINUX */
-    i = bb_getopt_ulflags(argc, argv, "c");
-#endif
 #if ENABLE_FEATURE_PS_WIDE
+    opt_complementary = "-:ww";
+    USE_SELINUX(i =) getopt32(argv, USE_SELINUX("Z") "w", &w_count);
     /* if w is given once, GNU ps sets the width to 132,
      * if w is given more than once, it is "unlimited"
      */
-    if(w_count) {
-        terminal_width = (w_count==1) ? 132 : INT_MAX;
+    if (w_count) {
+        terminal_width = (w_count==1) ? 132 : MAX_WIDTH;
     } else {
-        get_terminal_width_height(1, &terminal_width, NULL);
+        get_terminal_width_height(0, &terminal_width, NULL);
         /* Go one less... */
-        terminal_width--;
-    }
-#endif
-#if ENABLE_SELINUX
-    if ((i & (1+ENABLE_FEATURE_PS_WIDE)) && is_selinux_enabled())
-        use_selinux = 1;
-#endif
-#endif  /* ENABLE_FEATURE_PS_WIDE || ENABLE_SELINUX */
-
-#if ENABLE_SELINUX
+        if (--terminal_width > MAX_WIDTH)
+            terminal_width = MAX_WIDTH;
+    }
+#else /* only ENABLE_SELINUX */
+    i = getopt32(argv, "Z");
+#endif
+#if ENABLE_SELINUX
+    if ((i & 1) && is_selinux_enabled())
+        use_selinux = PSSCAN_CONTEXT;
+#endif
+#endif /* ENABLE_FEATURE_PS_WIDE || ENABLE_SELINUX */
+
     if (use_selinux)
-      printf("  PID Context                          Stat Command\n");
+        puts("  PID Context                          Stat Command");
     else
-#endif
-      printf("  PID  Uid     VmSize Stat Command\n");
-
-    while ((p = procps_scan(1)) != 0)  {
-        char *namecmd = p->cmd;
-#if ENABLE_SELINUX
-        if (use_selinux)
-          {
-            char sbuf[128];
-            len = sizeof(sbuf);
-
-            if (is_selinux_enabled()) {
-              if (getpidcon(p->pid,&sid)<0)
-                sid=NULL;
-            }
-
-            if (sid) {
-              /*  I assume sid initilized with NULL  */
-              len = strlen(sid)+1;
-              safe_strncpy(sbuf, sid, len);
-              freecon(sid);
-              sid=NULL;
-            }else {
-              safe_strncpy(sbuf, "unknown",7);
-            }
-            len = printf("%5d %-32s %s ", p->pid, sbuf, p->state);
-        }
-        else
-#endif
-          if(p->rss == 0)
-            len = printf("%5d %-8s        %s ", p->pid, p->user, p->state);
-          else
-            len = printf("%5d %-8s %6ld %s ", p->pid, p->user, p->rss, p->state);
-
-        i = terminal_width-len;
-
-        if(namecmd && namecmd[0]) {
-            if(i < 0)
-                i = 0;
-            if(strlen(namecmd) > (size_t)i)
-                namecmd[i] = 0;
-            printf("%s\n", namecmd);
-        } else {
-            namecmd = p->short_cmd;
-            if(i < 2)
-                i = 2;
-            if(strlen(namecmd) > ((size_t)i-2))
-                namecmd[i-2] = 0;
-            printf("[%s]\n", namecmd);
-        }
-        /* no check needed, but to make valgrind happy..  */
-        if (ENABLE_FEATURE_CLEAN_UP && p->cmd)
-            free(p->cmd);
-    }
+        puts("  PID  Uid        VSZ Stat Command");
+
+    while ((p = procps_scan(p, 0
+            | PSSCAN_PID
+            | PSSCAN_UIDGID
+            | PSSCAN_STATE
+            | PSSCAN_VSZ
+            | PSSCAN_COMM
+            | use_selinux
+    ))) {
+#if ENABLE_SELINUX
+        if (use_selinux) {
+            len = printf("%5u %-32s %s ",
+                    p->pid,
+                    p->context ? p->context : "unknown",
+                    p->state);
+        } else
+#endif
+        {
+            const char *user = get_cached_username(p->uid);
+            if (p->vsz == 0)
+                len = printf("%5u %-8s        %s ",
+                    p->pid, user, p->state);
+            else
+                len = printf("%5u %-8s %6u %s ",
+                    p->pid, user, p->vsz, p->state);
+        }
+
+        {
+            int sz = terminal_width - len;
+            char buf[sz + 1];
+            read_cmdline(buf, sz, p->pid, p->comm);
+            puts(buf);
+        }
+    }
+    if (ENABLE_FEATURE_CLEAN_UP)
+        clear_username_cache();
     return EXIT_SUCCESS;
 }
+
+#endif /* ENABLE_DESKTOP */

branches/2.2.5/mindi-busybox/procps/renice.c

@@ -20 +20 @@
  */
 
-#include "busybox.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <errno.h>
-#include <unistd.h>
+#include "libbb.h"
 #include <sys/resource.h>
 
-#if (PRIO_PROCESS < CHAR_MIN) || (PRIO_PROCESS > CHAR_MAX)
-#error Assumption violated : PRIO_PROCESS value
-#endif
-#if (PRIO_PGRP < CHAR_MIN) || (PRIO_PGRP > CHAR_MAX)
-#error Assumption violated : PRIO_PGRP value
-#endif
-#if (PRIO_USER < CHAR_MIN) || (PRIO_USER > CHAR_MAX)
-#error Assumption violated : PRIO_USER value
-#endif
+void BUG_bad_PRIO_PROCESS(void);
+void BUG_bad_PRIO_PGRP(void);
+void BUG_bad_PRIO_USER(void);
 
-static inline int int_add_no_wrap(int a, int b)
-{
-    int s = a + b;
-
-    if (b < 0) {
-        if (s > a) s = INT_MIN;
-    } else {
-        if (s < a) s = INT_MAX;
-    }
-
-    return s;
-}
-
+int renice_main(int argc, char **argv);
 int renice_main(int argc, char **argv)
 {
-    static const char Xetpriority_msg[] = "%d : %cetpriority";
+    static const char Xetpriority_msg[] ALIGN1 = "%cetpriority";
 
     int retval = EXIT_SUCCESS;
@@ -60 +36 @@
     int use_relative = 0;
     int adjustment, new_priority;
-    id_t who;
+    unsigned who;
+    char *arg;
 
-    ++argv;
+    /* Yes, they are not #defines in glibc 2.4! #if won't work */
+    if (PRIO_PROCESS < CHAR_MIN || PRIO_PROCESS > CHAR_MAX)
+        BUG_bad_PRIO_PROCESS();
+    if (PRIO_PGRP < CHAR_MIN || PRIO_PGRP > CHAR_MAX)
+        BUG_bad_PRIO_PGRP();
+    if (PRIO_USER < CHAR_MIN || PRIO_USER > CHAR_MAX)
+        BUG_bad_PRIO_USER();
+
+    arg = *++argv;
 
     /* Check if we are using a relative adjustment. */
-    if (argv[0] && (argv[0][0] == '-') && (argv[0][1] == 'n') && !argv[0][2]) {
+    if (arg && arg[0] == '-' && arg[1] == 'n') {
         use_relative = 1;
-        ++argv;
+        if (!arg[2])
+            arg = *++argv;
+        else
+            arg += 2;
     }
 
-    if (!*argv) {               /* No args?  Then show usage. */
+    if (!arg) {             /* No args?  Then show usage. */
         bb_show_usage();
     }
 
     /* Get the priority adjustment (absolute or relative). */
-    adjustment = bb_xgetlarg(*argv, 10, INT_MIN, INT_MAX);
+    adjustment = xatoi_range(arg, INT_MIN/2, INT_MAX/2);
 
-    while (*++argv) {
+    while ((arg = *++argv) != NULL) {
         /* Check for a mode switch. */
-        if ((argv[0][0] == '-') && argv[0][1] && !argv[0][2]) {
-            static const char opts[]
-                = { 'p', 'g', 'u', 0, PRIO_PROCESS, PRIO_PGRP, PRIO_USER };
-            const char *p;
-            if ((p = strchr(opts, argv[0][1]))) {
+        if (arg[0] == '-' && arg[1]) {
+            static const char opts[] ALIGN1 = {
+                'p', 'g', 'u', 0, PRIO_PROCESS, PRIO_PGRP, PRIO_USER
+            };
+            const char *p = strchr(opts, arg[1]);
+            if (p) {
                 which = p[4];
-                continue;
+                if (!arg[2])
+                    continue;
+                arg += 2;
             }
         }
@@ -92 +83 @@
         if (which == PRIO_USER) {
             struct passwd *p;
-            if (!(p = getpwnam(*argv))) {
-                bb_error_msg("unknown user: %s", *argv);
+            p = getpwnam(arg);
+            if (!p) {
+                bb_error_msg("unknown user: %s", arg);
                 goto HAD_ERROR;
             }
             who = p->pw_uid;
         } else {
-            char *e;
-            errno = 0;
-            who = strtoul(*argv, &e, 10);
-            if (*e || (*argv == e) || errno) {
-                bb_error_msg("bad value: %s", *argv);
+            who = bb_strtou(arg, NULL, 10);
+            if (errno) {
+                bb_error_msg("bad value: %s", arg);
                 goto HAD_ERROR;
             }
@@ -114 +104 @@
             old_priority = getpriority(which, who);
             if (errno) {
-                bb_perror_msg(Xetpriority_msg, who, 'g');
+                bb_perror_msg(Xetpriority_msg, 'g');
                 goto HAD_ERROR;
             }
 
-            new_priority = int_add_no_wrap(old_priority, adjustment);
+            new_priority = old_priority + adjustment;
         } else {
             new_priority = adjustment;
@@ -127 +117 @@
         }
 
-        bb_perror_msg(Xetpriority_msg, who, 's');
-    HAD_ERROR:
+        bb_perror_msg(Xetpriority_msg, 's');
+ HAD_ERROR:
         retval = EXIT_FAILURE;
     }

branches/2.2.5/mindi-busybox/procps/sysctl.c

@@ -15 +15 @@
  */
 
-#include "busybox.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <string.h>
-#include <errno.h>
-#include <fcntl.h>
+#include "libbb.h"
 
 /*
@@ -37 +28 @@
  *    Globals...
  */
-static const char PROC_PATH[] = "/proc/sys/";
-static const char DEFAULT_PRELOAD[] = "/etc/sysctl.conf";
+static const char PROC_PATH[] ALIGN1 = "/proc/sys/";
+static const char DEFAULT_PRELOAD[] ALIGN1 = "/etc/sysctl.conf";
 
 /* error messages */
-static const char ERR_UNKNOWN_PARAMETER[] = "error: Unknown parameter '%s'\n";
-static const char ERR_MALFORMED_SETTING[] = "error: Malformed setting '%s'\n";
-static const char ERR_NO_EQUALS[] =
+static const char ERR_UNKNOWN_PARAMETER[] ALIGN1 =
+    "error: Unknown parameter '%s'\n";
+static const char ERR_MALFORMED_SETTING[] ALIGN1 =
+    "error: Malformed setting '%s'\n";
+static const char ERR_NO_EQUALS[] ALIGN1 =
     "error: '%s' must be of the form name=value\n";
-static const char ERR_INVALID_KEY[] = "error: '%s' is an unknown key\n";
-static const char ERR_UNKNOWN_WRITING[] =
+static const char ERR_INVALID_KEY[] ALIGN1 =
+    "error: '%s' is an unknown key\n";
+static const char ERR_UNKNOWN_WRITING[] ALIGN1 =
     "error: unknown error %d setting key '%s'\n";
-static const char ERR_UNKNOWN_READING[] =
+static const char ERR_UNKNOWN_READING[] ALIGN1 =
     "error: unknown error %d reading key '%s'\n";
-static const char ERR_PERMISSION_DENIED[] =
+static const char ERR_PERMISSION_DENIED[] ALIGN1 =
     "error: permission denied on key '%s'\n";
-static const char ERR_PRELOAD_FILE[] =
-    "error: unable to open preload file '%s'\n";
-static const char WARN_BAD_LINE[] =
+static const char ERR_PRELOAD_FILE[] ALIGN1 =
+    "error: cannot open preload file '%s'\n";
+static const char WARN_BAD_LINE[] ALIGN1 =
     "warning: %s(%d): invalid syntax, continuing...\n";
 
@@ -66 +60 @@
  *    sysctl_main()...
  */
+int sysctl_main(int argc, char **argv);
 int sysctl_main(int argc, char **argv)
 {
@@ -139 +134 @@
 
     while (fgets(oneline, sizeof(oneline) - 1, fp)) {
-        oneline[sizeof(oneline) - 1] = 0;
+        oneline[sizeof(oneline) - 1] = '\0';
         lineno++;
         trim(oneline);
@@ -166 +161 @@
         while ((*value == ' ' || *value == '\t') && *value != 0)
             value++;
-        strcpy(buffer, name);
-        strcat(buffer, "=");
-        strcat(buffer, value);
+        /* safe because sizeof(oneline) == sizeof(buffer) */
+        sprintf(buffer, "%s=%s", name, value);
         sysctl_write_setting(buffer, output);
     }
@@ -203 +197 @@
     }
 
-    tmpname = bb_xasprintf("%s%.*s", PROC_PATH, (int)(equals - name), name);
-    outname = bb_xstrdup(tmpname + strlen(PROC_PATH));
+    tmpname = xasprintf("%s%.*s", PROC_PATH, (int)(equals - name), name);
+    outname = xstrdup(tmpname + strlen(PROC_PATH));
 
     while ((cptr = strchr(tmpname, '.')) != NULL)
@@ -212 +206 @@
         *cptr = '.';
 
-    if ((fd = open(tmpname, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0) {
+    fd = open(tmpname, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+    if (fd < 0) {
         switch (errno) {
         case ENOENT:
@@ -259 +254 @@
 
     tmpname = concat_path_file(PROC_PATH, name);
-    outname = bb_xstrdup(tmpname + strlen(PROC_PATH));
+    outname = xstrdup(tmpname + strlen(PROC_PATH));
 
     while ((cptr = strchr(tmpname, '.')) != NULL)
@@ -310 +305 @@
     struct stat ts;
 
-    if (!(dp = bb_opendir(path))) {
+    dp = opendir(path);
+    if (!dp) {
         retval = -1;
     } else {
         while ((de = readdir(dp)) != NULL) {
             tmpdir = concat_subpath_file(path, de->d_name);
-            if(tmpdir == NULL)
+            if (tmpdir == NULL)
                 continue;
-            if ((retval2 = stat(tmpdir, &ts)) != 0)
+            retval2 = stat(tmpdir, &ts);
+            if (retval2 != 0)
                 bb_perror_msg(tmpdir);
             else {

branches/2.2.5/mindi-busybox/procps/top.c

@@ -29 +29 @@
  */
 
-#include "busybox.h"
-#include <sys/types.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/ioctl.h>
-
-//#define CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE  /* + 2k */
-
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
-#include <time.h>
-#include <fcntl.h>
-#include <netinet/in.h>  /* htons */
-#endif
-
-
-typedef int (*cmp_t)(procps_status_t *P, procps_status_t *Q);
-
-static procps_status_t *top;   /* Hehe */
-static int ntop;
-
-#ifdef CONFIG_FEATURE_USE_TERMIOS
-static int pid_sort(procps_status_t *P, procps_status_t *Q)
-{
+#include "libbb.h"
+
+
+typedef struct top_status_t {
+    unsigned long vsz;
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+    unsigned long ticks;
+    unsigned pcpu; /* delta of ticks */
+#endif
+    unsigned pid, ppid;
+    unsigned uid;
+    char state[4];
+    char comm[COMM_LEN];
+} top_status_t;
+
+typedef struct jiffy_counts_t {
+    unsigned long long usr,nic,sys,idle,iowait,irq,softirq,steal;
+    unsigned long long total;
+    unsigned long long busy;
+} jiffy_counts_t;
+
+/* This structure stores some critical information from one frame to
+   the next. Used for finding deltas. */
+typedef struct save_hist {
+    unsigned long ticks;
+    unsigned pid;
+} save_hist;
+
+typedef int (*cmp_funcp)(top_status_t *P, top_status_t *Q);
+
+enum { SORT_DEPTH = 3 };
+
+struct globals {
+    top_status_t *top;
+    int ntop;
+#if ENABLE_FEATURE_USE_TERMIOS
+    struct termios initial_settings;
+#endif
+#if !ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+    cmp_funcp sort_function;
+#else
+    cmp_funcp sort_function[SORT_DEPTH];
+    struct save_hist *prev_hist;
+    int prev_hist_count;
+    jiffy_counts_t jif, prev_jif;
+    /* int hist_iterations; */
+    unsigned total_pcpu;
+    /* unsigned long total_vsz; */
+#endif
+};
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define top              (G.top               )
+#define ntop             (G.ntop              )
+#if ENABLE_FEATURE_USE_TERMIOS
+#define initial_settings (G. initial_settings )
+#endif
+#define sort_function    (G.sort_function     )
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+#define prev_hist        (G.prev_hist         )
+#define prev_hist_count  (G.prev_hist_count   )
+#define jif              (G.jif               )
+#define prev_jif         (G.prev_jif          )
+#define total_pcpu       (G.total_pcpu        )
+#endif
+
+#define OPT_BATCH_MODE (option_mask32 & 0x4)
+
+
+#if ENABLE_FEATURE_USE_TERMIOS
+static int pid_sort(top_status_t *P, top_status_t *Q)
+{
+    /* Buggy wrt pids with high bit set */
+    /* (linux pids are in [1..2^15-1]) */
     return (Q->pid - P->pid);
 }
 #endif
 
-static int mem_sort(procps_status_t *P, procps_status_t *Q)
-{
-    return (int)(Q->rss - P->rss);
-}
-
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
-
-#define sort_depth 3
-static cmp_t sort_function[sort_depth];
-
-static int pcpu_sort(procps_status_t *P, procps_status_t *Q)
-{
-    return (Q->pcpu - P->pcpu);
-}
-
-static int time_sort(procps_status_t *P, procps_status_t *Q)
-{
-    return (int)((Q->stime + Q->utime) - (P->stime + P->utime));
-}
-
-static int mult_lvl_cmp(void* a, void* b) {
+static int mem_sort(top_status_t *P, top_status_t *Q)
+{
+    /* We want to avoid unsigned->signed and truncation errors */
+    if (Q->vsz < P->vsz) return -1;
+    return Q->vsz != P->vsz; /* 0 if ==, 1 if > */
+}
+
+
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+
+static int pcpu_sort(top_status_t *P, top_status_t *Q)
+{
+    /* Buggy wrt ticks with high bit set */
+    /* Affects only processes for which ticks overflow */
+    return (int)Q->pcpu - (int)P->pcpu;
+}
+
+static int time_sort(top_status_t *P, top_status_t *Q)
+{
+    /* We want to avoid unsigned->signed and truncation errors */
+    if (Q->ticks < P->ticks) return -1;
+    return Q->ticks != P->ticks; /* 0 if ==, 1 if > */
+}
+
+static int mult_lvl_cmp(void* a, void* b)
+{
     int i, cmp_val;
 
-    for (i = 0; i < sort_depth; i++) {
+    for (i = 0; i < SORT_DEPTH; i++) {
         cmp_val = (*sort_function[i])(a, b);
         if (cmp_val != 0)
@@ -89 +142 @@
 }
 
-/* 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;
-};
-
-/*
- * Calculates percent cpu usage for each task.
- */
-
-static struct save_hist *prev_hist;
-static int prev_hist_count;
-/* static int hist_iterations; */
-
-
-static unsigned total_pcpu;
-/* static unsigned long total_rss; */
-
-struct jiffy_counts {
-    unsigned long long usr,nic,sys,idle,iowait,irq,softirq,steal;
-    unsigned long long total;
-    unsigned long long busy;
-};
-static struct jiffy_counts jif, prev_jif;
 
 static void get_jiffy_counts(void)
 {
-    FILE* fp = bb_xfopen("stat", "r");
+    FILE* fp = xfopen("stat", "r");
     prev_jif = jif;
     if (fscanf(fp, "cpu  %lld %lld %lld %lld %lld %lld %lld %lld",
             &jif.usr,&jif.nic,&jif.sys,&jif.idle,
             &jif.iowait,&jif.irq,&jif.softirq,&jif.steal) < 4) {
-        bb_error_msg_and_die("failed to read 'stat'");
+        bb_error_msg_and_die("failed to read /proc/stat");
     }
     fclose(fp);
@@ -131 +159 @@
 }
 
+
 static void do_stats(void)
 {
-    procps_status_t *cur;
-    int pid, total_time, i, last_i, n;
+    top_status_t *cur;
+    pid_t pid;
+    int i, last_i, n;
     struct save_hist *new_hist;
 
     get_jiffy_counts();
     total_pcpu = 0;
-    /* total_rss = 0; */
+    /* total_vsz = 0; */
     new_hist = xmalloc(sizeof(struct save_hist)*ntop);
     /*
@@ -154 +184 @@
          */
         pid = cur->pid;
-        total_time = cur->stime + cur->utime;
-        new_hist[n].ticks = total_time;
+        new_hist[n].ticks = cur->ticks;
         new_hist[n].pid = pid;
 
@@ -165 +194 @@
         if (prev_hist_count) do {
             if (prev_hist[i].pid == pid) {
-                cur->pcpu = total_time - prev_hist[i].ticks;
+                cur->pcpu = cur->ticks - prev_hist[i].ticks;
+                total_pcpu += cur->pcpu;
                 break;
             }
@@ -171 +201 @@
             /* hist_iterations++; */
         } while (i != last_i);
-        total_pcpu += cur->pcpu;
-        /* total_rss += cur->rss; */
+        /* total_vsz += cur->vsz; */
     }
 
@@ -182 +211 @@
     prev_hist_count = ntop;
 }
-#else
-static cmp_t sort_function;
-#endif /* CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE */
+#endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
+
+#if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS && ENABLE_FEATURE_TOP_DECIMALS
+/* formats 7 char string (8 with terminating NUL) */
+static char *fmt_100percent_8(char pbuf[8], unsigned value, unsigned total)
+{
+    unsigned t;
+    if (value >= total) { /* 100% ? */
+        strcpy(pbuf, "  100% ");
+        return pbuf;
+    }
+    /* else generate " [N/space]N.N% " string */
+    value = 1000 * value / total;
+    t = value / 100;
+    value = value % 100;
+    pbuf[0] = ' ';
+    pbuf[1] = t ? t + '0' : ' ';
+    pbuf[2] = '0' + (value / 10);
+    pbuf[3] = '.';
+    pbuf[4] = '0' + (value % 10);
+    pbuf[5] = '%';
+    pbuf[6] = ' ';
+    pbuf[7] = '\0';
+    return pbuf;
+}
+#endif
 
 /* display generic info (meminfo / loadavg) */
@@ -192 +244 @@
     char buf[80];
     char scrbuf[80];
-    char *end;
     unsigned long total, used, mfree, shared, buffers, cached;
-    unsigned int needs_conversion = 1;
+#if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS
+    unsigned total_diff;
+#endif
 
     /* read memory info */
-    fp = bb_xfopen("meminfo", "r");
+    fp = xfopen("meminfo", "r");
 
     /*
@@ -213 +266 @@
 
         fscanf(fp, "Mem: %lu %lu %lu %lu %lu %lu",
-           &total, &used, &mfree, &shared, &buffers, &cached);
-    } else {
-        /*
-         * Revert to manual parsing, which incidentally already has the
-         * sizes in kilobytes. This should be safe for both 2.4 and
-         * 2.6.
-         */
-        needs_conversion = 0;
-
-        fscanf(fp, "MemFree: %lu %s\n", &mfree, buf);
-
-        /*
-         * MemShared: is no longer present in 2.6. Report this as 0,
-         * to maintain consistent behavior with normal procps.
-         */
-        if (fscanf(fp, "MemShared: %lu %s\n", &shared, buf) != 2)
-            shared = 0;
-
-        fscanf(fp, "Buffers: %lu %s\n", &buffers, buf);
-        fscanf(fp, "Cached: %lu %s\n", &cached, buf);
-
-        used = total - mfree;
-    }
-    fclose(fp);
-
-    /* read load average as a string */
-    fp = bb_xfopen("loadavg", "r");
-    buf[0] = '\0';
-    fgets(buf, sizeof(buf), fp);
-    end = strchr(buf, ' ');
-    if (end) end = strchr(end+1, ' ');
-    if (end) end = strchr(end+1, ' ');
-    if (end) *end = '\0';
-    fclose(fp);
-
-    if (needs_conversion) {
+            &total, &used, &mfree, &shared, &buffers, &cached);
         /* convert to kilobytes */
         used /= 1024;
@@ -256 +274 @@
         cached /= 1024;
         total /= 1024;
-    }
-
-    /* output memory info and load average */
-    /* clear screen & go to top */
+    } else {
+        /*
+         * Revert to manual parsing, which incidentally already has the
+         * sizes in kilobytes. This should be safe for both 2.4 and
+         * 2.6.
+         */
+
+        fscanf(fp, "MemFree: %lu %s\n", &mfree, buf);
+
+        /*
+         * MemShared: is no longer present in 2.6. Report this as 0,
+         * to maintain consistent behavior with normal procps.
+         */
+        if (fscanf(fp, "MemShared: %lu %s\n", &shared, buf) != 2)
+            shared = 0;
+
+        fscanf(fp, "Buffers: %lu %s\n", &buffers, buf);
+        fscanf(fp, "Cached: %lu %s\n", &cached, buf);
+
+        used = total - mfree;
+    }
+    fclose(fp);
+
+    /* output memory info */
     if (scr_width > sizeof(scrbuf))
         scr_width = sizeof(scrbuf);
     snprintf(scrbuf, scr_width,
-        "Mem: %ldK used, %ldK free, %ldK shrd, %ldK buff, %ldK cached",
+        "Mem: %luK used, %luK free, %luK shrd, %luK buff, %luK cached",
         used, mfree, shared, buffers, cached);
-    printf("\e[H\e[J%s\n", scrbuf);
-    snprintf(scrbuf, scr_width,
-        "Load average: %s  (Status: S=sleeping R=running, W=waiting)", buf);
-    printf("%s\n", scrbuf);
+    /* clear screen & go to top */
+    printf(OPT_BATCH_MODE ? "%s\n" : "\e[H\e[J%s\n", scrbuf);
+
+#if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS
+    /*
+     * xxx% = (jif.xxx - prev_jif.xxx) / (jif.total - prev_jif.total) * 100%
+     */
+    /* using (unsigned) casts to make operations cheaper */
+    total_diff = ((unsigned)(jif.total - prev_jif.total) ? : 1);
+#if ENABLE_FEATURE_TOP_DECIMALS
+/* Generated code is approx +0.3k */
+#define CALC_STAT(xxx) char xxx[8]
+#define SHOW_STAT(xxx) fmt_100percent_8(xxx, (unsigned)(jif.xxx - prev_jif.xxx), total_diff)
+#define FMT "%s"
+#else
+#define CALC_STAT(xxx) unsigned xxx = 100 * (unsigned)(jif.xxx - prev_jif.xxx) / total_diff
+#define SHOW_STAT(xxx) xxx
+#define FMT "%4u%% "
+#endif
+    { /* need block: CALC_STAT are declarations */
+        CALC_STAT(usr);
+        CALC_STAT(sys);
+        CALC_STAT(nic);
+        CALC_STAT(idle);
+        CALC_STAT(iowait);
+        CALC_STAT(irq);
+        CALC_STAT(softirq);
+        //CALC_STAT(steal);
+
+        snprintf(scrbuf, scr_width,
+            /* Barely fits in 79 chars when in "decimals" mode. */
+            "CPU:"FMT"usr"FMT"sys"FMT"nice"FMT"idle"FMT"io"FMT"irq"FMT"softirq",
+            SHOW_STAT(usr), SHOW_STAT(sys), SHOW_STAT(nic), SHOW_STAT(idle),
+            SHOW_STAT(iowait), SHOW_STAT(irq), SHOW_STAT(softirq)
+            //, SHOW_STAT(steal) - what is this 'steal' thing?
+            // I doubt anyone wants to know it
+        );
+    }
+    puts(scrbuf);
+#undef SHOW_STAT
+#undef CALC_STAT
+#undef FMT
+#endif
+
+    /* read load average as a string */
+    buf[0] = '\0';
+    open_read_close("loadavg", buf, sizeof("N.NN N.NN N.NN")-1);
+    buf[sizeof("N.NN N.NN N.NN")-1] = '\0';
+    snprintf(scrbuf, scr_width, "Load average: %s", buf);
+    puts(scrbuf);
 
     return total;
 }
-
 
 /* display process statuses */
@@ -278 +361 @@
 {
     enum {
-        bits_per_int = sizeof(int)*8
+        BITS_PER_INT = sizeof(int)*8
     };
 
-    procps_status_t *s = top;
-    char rss_str_buf[8];
-    unsigned long total_memory = display_generic(scr_width); /* or use total_rss? */
-    unsigned pmem_shift, pmem_scale;
-
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
-    unsigned pcpu_shift, pcpu_scale;
+    top_status_t *s = top;
+    char vsz_str_buf[8];
+    unsigned long total_memory = display_generic(scr_width); /* or use total_vsz? */
+    /* xxx_shift and xxx_scale variables allow us to replace
+     * expensive divides with multiply and shift */
+    unsigned pmem_shift, pmem_scale, pmem_half;
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+    unsigned pcpu_shift, pcpu_scale, pcpu_half;
+    unsigned busy_jifs;
 
     /* what info of the processes is shown */
-    printf("\e[7m%.*s\e[0m", scr_width,
-        "  PID USER     STATUS   RSS  PPID %CPU %MEM COMMAND");
+    printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width,
+        "  PID  PPID USER     STAT   VSZ %MEM %CPU COMMAND");
 #define MIN_WIDTH \
-    sizeof( "  PID USER     STATUS   RSS  PPID %CPU %MEM C")
-#else
-    printf("\e[7m%.*s\e[0m", scr_width,
-        "  PID USER     STATUS   RSS  PPID %MEM COMMAND");
+    sizeof( "  PID  PPID USER     STAT   VSZ %MEM %CPU C")
+#else
+
+    /* !CPU_USAGE_PERCENTAGE */
+    printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width,
+        "  PID  PPID USER     STAT   VSZ %MEM COMMAND");
 #define MIN_WIDTH \
-    sizeof( "  PID USER     STATUS   RSS  PPID %MEM C")
-#endif
-
+    sizeof( "  PID  PPID USER     STAT   VSZ %MEM C")
+#endif
+
+#if ENABLE_FEATURE_TOP_DECIMALS
+#define UPSCALE 1000
+#define CALC_STAT(name, val) div_t name = div((val), 10)
+#define SHOW_STAT(name) name.quot, '0'+name.rem
+#define FMT "%3u.%c"
+#else
+#define UPSCALE 100
+#define CALC_STAT(name, val) unsigned name = (val)
+#define SHOW_STAT(name) name
+#define FMT "%4u%%"
+#endif
     /*
-     * MEM% = s->rss/MemTotal
+     * MEM% = s->vsz/MemTotal
      */
-    pmem_shift = bits_per_int-11;
-    pmem_scale = 1000*(1U<<(bits_per_int-11)) / total_memory;
-    /* s->rss is in kb. we want (s->rss * pmem_scale) to never overflow */
+    pmem_shift = BITS_PER_INT-11;
+    pmem_scale = UPSCALE*(1U<<(BITS_PER_INT-11)) / total_memory;
+    /* s->vsz is in kb. we want (s->vsz * pmem_scale) to never overflow */
     while (pmem_scale >= 512) {
         pmem_scale /= 4;
         pmem_shift -= 2;
     }
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+    pmem_half = (1U << pmem_shift) / (ENABLE_FEATURE_TOP_DECIMALS? 20 : 2);
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+    busy_jifs = jif.busy - prev_jif.busy;
+    /* This happens if there were lots of short-lived processes
+     * between two top updates (e.g. compilation) */
+    if (total_pcpu < busy_jifs) total_pcpu = busy_jifs;
+
     /*
      * CPU% = s->pcpu/sum(s->pcpu) * busy_cpu_ticks/total_cpu_ticks
@@ -321 +425 @@
      */
     pcpu_shift = 6;
-    pcpu_scale = (1000*64*(uint16_t)(jif.busy-prev_jif.busy) ? : 1);
-    while (pcpu_scale < (1U<<(bits_per_int-2))) {
+    pcpu_scale = (UPSCALE*64*(uint16_t)busy_jifs ? : 1);
+    while (pcpu_scale < (1U<<(BITS_PER_INT-2))) {
         pcpu_scale *= 4;
         pcpu_shift += 2;
@@ -332 +436 @@
         pcpu_shift -= 2;
     }
+    pcpu_half = (1U << pcpu_shift) / (ENABLE_FEATURE_TOP_DECIMALS? 20 : 2);
     /* printf(" pmem_scale=%u pcpu_scale=%u ", pmem_scale, pcpu_scale); */
 #endif
 
-    while (count--) {
-        div_t pmem = div( (s->rss*pmem_scale) >> pmem_shift, 10);
-        int col = scr_width+1;
-        USE_FEATURE_TOP_CPU_USAGE_PERCENTAGE(div_t pcpu;)
-
-        if (s->rss >= 100*1024)
-            sprintf(rss_str_buf, "%6ldM", s->rss/1024);
+    /* Ok, all prelim data is ready, go thru the list */
+    while (count-- > 0) {
+        int col = scr_width;
+        CALC_STAT(pmem, (s->vsz*pmem_scale + pmem_half) >> pmem_shift);
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+        CALC_STAT(pcpu, (s->pcpu*pcpu_scale + pcpu_half) >> pcpu_shift);
+#endif
+
+        if (s->vsz >= 100*1024)
+            sprintf(vsz_str_buf, "%6ldM", s->vsz/1024);
         else
-            sprintf(rss_str_buf, "%7ld", s->rss);
-        USE_FEATURE_TOP_CPU_USAGE_PERCENTAGE(pcpu = div((s->pcpu*pcpu_scale) >> pcpu_shift, 10);)
-        col -= printf("\n%5d %-8s %s  %s%6d%3u.%c" \
-                USE_FEATURE_TOP_CPU_USAGE_PERCENTAGE("%3u.%c") " ",
-                s->pid, s->user, s->state, rss_str_buf, s->ppid,
-                USE_FEATURE_TOP_CPU_USAGE_PERCENTAGE(pcpu.quot, '0'+pcpu.rem,)
-                pmem.quot, '0'+pmem.rem);
-        if (col>0)
-            printf("%.*s", col, s->short_cmd);
+            sprintf(vsz_str_buf, "%7ld", s->vsz);
+        // PID PPID USER STAT VSZ %MEM [%CPU] COMMAND
+        col -= printf("\n" "%5u%6u %-8.8s %s%s" FMT
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+                FMT
+#endif
+                " ",
+                s->pid, s->ppid, get_cached_username(s->uid),
+                s->state, vsz_str_buf,
+                SHOW_STAT(pmem)
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+                , SHOW_STAT(pcpu)
+#endif
+        );
+        if (col > 0) {
+            char buf[col + 1];
+            read_cmdline(buf, col, s->pid, s->comm);
+            fputs(buf, stdout);
+        }
         /* printf(" %d/%d %lld/%lld", s->pcpu, total_pcpu,
             jif.busy - prev_jif.busy, jif.total - prev_jif.total); */
@@ -357 +475 @@
     }
     /* printf(" %d", hist_iterations); */
-    putchar('\r');
+    putchar(OPT_BATCH_MODE ? '\n' : '\r');
     fflush(stdout);
 }
+#undef UPSCALE
+#undef SHOW_STAT
+#undef CALC_STAT
+#undef FMT
+
 
 static void clearmems(void)
 {
+    clear_username_cache();
     free(top);
     top = 0;
@@ -368 +492 @@
 }
 
-#ifdef CONFIG_FEATURE_USE_TERMIOS
+
+#if ENABLE_FEATURE_USE_TERMIOS
 #include <termios.h>
 #include <signal.h>
 
-
-static struct termios initial_settings;
-
 static void reset_term(void)
 {
     tcsetattr(0, TCSANOW, (void *) &initial_settings);
-#ifdef CONFIG_FEATURE_CLEAN_UP
+#if ENABLE_FEATURE_CLEAN_UP
     clearmems();
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
     free(prev_hist);
 #endif
-#endif /* CONFIG_FEATURE_CLEAN_UP */
+#endif /* FEATURE_CLEAN_UP */
 }
 
@@ -391 +513 @@
     exit(1);
 }
-#endif /* CONFIG_FEATURE_USE_TERMIOS */
-
-
+#endif /* FEATURE_USE_TERMIOS */
+
+
+int top_main(int argc, char **argv);
 int top_main(int argc, char **argv)
 {
-    int opt, interval, lines, col;
-    char *sinterval;
-#ifdef CONFIG_FEATURE_USE_TERMIOS
+    int count, lines, col;
+    unsigned interval = 5; /* default update rate is 5 seconds */
+    unsigned iterations = UINT_MAX; /* 2^32 iterations by default :) */
+    char *sinterval, *siterations;
+#if ENABLE_FEATURE_USE_TERMIOS
     struct termios new_settings;
     struct timeval tv;
     fd_set readfds;
     unsigned char c;
-#endif /* CONFIG_FEATURE_USE_TERMIOS */
+#endif /* FEATURE_USE_TERMIOS */
+
+    interval = 5;
 
     /* do normal option parsing */
-    opt = bb_getopt_ulflags(argc, argv, "d:", &sinterval);
-    if ((opt & 1)) {
-        interval = atoi(sinterval);
-    } else {
-        /* Default update rate is 5 seconds */
-        interval = 5;
-    }
+    opt_complementary = "-";
+    getopt32(argv, "d:n:b", &sinterval, &siterations);
+    if (option_mask32 & 0x1) interval = xatou(sinterval); // -d
+    if (option_mask32 & 0x2) iterations = xatou(siterations); // -n
+    //if (option_mask32 & 0x4) // -b
 
     /* change to /proc */
-    bb_xchdir("/proc");
-#ifdef CONFIG_FEATURE_USE_TERMIOS
+    xchdir("/proc");
+#if ENABLE_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);
+    /* unbuffered input, turn off echo */
+    new_settings.c_lflag &= ~(ISIG | ICANON | ECHO | ECHONL);
 
     signal(SIGTERM, sig_catcher);
@@ -427 +551 @@
     tcsetattr(0, TCSANOW, (void *) &new_settings);
     atexit(reset_term);
-#endif /* CONFIG_FEATURE_USE_TERMIOS */
-
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+#endif /* FEATURE_USE_TERMIOS */
+
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
     sort_function[0] = pcpu_sort;
     sort_function[1] = mem_sort;
@@ -435 +559 @@
 #else
     sort_function = mem_sort;
-#endif /* CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE */
+#endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
 
     while (1) {
-        procps_status_t *p;
+        procps_status_t *p = NULL;
 
         /* Default to 25 lines - 5 lines for status */
-        lines = 24 - 3;
+        lines = 24 - 3 USE_FEATURE_TOP_CPU_GLOBAL_PERCENTS( - 1);
         col = 79;
-#ifdef CONFIG_FEATURE_USE_TERMIOS
+#if ENABLE_FEATURE_USE_TERMIOS
         get_terminal_width_height(0, &col, &lines);
         if (lines < 5 || col < MIN_WIDTH) {
@@ -449 +573 @@
             continue;
         }
-        lines -= 3;
-#endif /* CONFIG_FEATURE_USE_TERMIOS */
+        lines -= 3 USE_FEATURE_TOP_CPU_GLOBAL_PERCENTS( + 1);
+#endif /* FEATURE_USE_TERMIOS */
 
         /* read process IDs & status for all the processes */
-        while ((p = procps_scan(0)) != 0) {
+        while ((p = procps_scan(p, 0
+                | PSSCAN_PID
+                | PSSCAN_PPID
+                | PSSCAN_VSZ
+                | PSSCAN_STIME
+                | PSSCAN_UTIME
+                | PSSCAN_STATE
+                | PSSCAN_COMM
+                | PSSCAN_SID
+                | PSSCAN_UIDGID
+        ))) {
             int n = ntop;
-
-            top = xrealloc(top, (++ntop)*sizeof(procps_status_t));
-            memcpy(top + n, p, sizeof(procps_status_t));
+            top = xrealloc(top, (++ntop) * sizeof(*top));
+            top[n].pid = p->pid;
+            top[n].ppid = p->ppid;
+            top[n].vsz = p->vsz;
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+            top[n].ticks = p->stime + p->utime;
+#endif
+            top[n].uid = p->uid;
+            strcpy(top[n].state, p->state);
+            strcpy(top[n].comm, p->comm);
         }
         if (ntop == 0) {
-            bb_error_msg_and_die("Can't find process info in /proc");
+            bb_error_msg_and_die("no process info in /proc");
         }
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
         if (!prev_hist_count) {
             do_stats();
@@ -470 +611 @@
         }
         do_stats();
-        qsort(top, ntop, sizeof(procps_status_t), (void*)mult_lvl_cmp);
-#else
-        qsort(top, ntop, sizeof(procps_status_t), (void*)sort_function);
-#endif /* CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE */
-        opt = lines;
-        if (opt > ntop) {
-            opt = ntop;
+/* TODO: we don't need to sort all 10000 processes, we need to find top 24! */
+        qsort(top, ntop, sizeof(top_status_t), (void*)mult_lvl_cmp);
+#else
+        qsort(top, ntop, sizeof(top_status_t), (void*)sort_function);
+#endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
+        count = lines;
+        if (OPT_BATCH_MODE || count > ntop) {
+            count = ntop;
         }
         /* show status for each of the processes */
-        display_status(opt, col);
-#ifdef CONFIG_FEATURE_USE_TERMIOS
+        display_status(count, col);
+#if ENABLE_FEATURE_USE_TERMIOS
         tv.tv_sec = interval;
         tv.tv_usec = 0;
@@ -493 +635 @@
                 break;
             if (c == 'M') {
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
                 sort_function[0] = mem_sort;
                 sort_function[1] = pcpu_sort;
@@ -501 +643 @@
 #endif
             }
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
             if (c == 'P') {
                 sort_function[0] = pcpu_sort;
@@ -514 +656 @@
 #endif
             if (c == 'N') {
-#ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+#if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
                 sort_function[0] = pid_sort;
 #else
@@ -521 +663 @@
             }
         }
+        if (!--iterations)
+            break;
 #else
         sleep(interval);
-#endif /* CONFIG_FEATURE_USE_TERMIOS */
+#endif /* FEATURE_USE_TERMIOS */
         clearmems();
     }

branches/2.2.5/mindi-busybox/procps/uptime.c

@@ -5 +5 @@
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under the GPL version 2, see the file LICENSE in this tarball.
  */
 
@@ -16 +16 @@
 /* getopt not needed */
 
-#include "busybox.h"
-#include <stdio.h>
-#include <time.h>
-#include <errno.h>
-#include <stdlib.h>
+#include "libbb.h"
 
 #ifndef FSHIFT
@@ -30 +26 @@
 
 
+int uptime_main(int argc, char **argv);
 int uptime_main(int argc, char **argv)
 {
@@ -50 +47 @@
     uphours = (upminutes / 60) % 24;
     upminutes %= 60;
-    if(uphours)
+    if (uphours)
         printf("%2d:%02d, ", uphours, upminutes);
     else