top,pmap: do not use common code for reading /proc/PID/smaps

The logic is in fact quite far from common.

While at it, stop accounting "---p" mappings as mapped (e.g. VSZ in top).
Nothing is mapped there (why would kernel waste RAM to map pages
which can't be accessed?).

function                                             old     new   delta
read_smaps                                             -     562    +562
read_cmdline                                         315     326     +11
print_smaprec                                         97     101      +4
procps_scan                                         1219    1211      -8
.rodata                                           115541  115533      -8
skip_whitespace_if_prefixed_with                      25       -     -25
procps_read_smaps                                    864     577    -287
------------------------------------------------------------------------------
(add/remove: 1/1 grow/shrink: 2/3 up/down: 577/-328)          Total: 249 bytes

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

2 files changed, 118 insertions, 20 deletions

diff --git a/procps/pmap.c b/procps/pmap.c
index 49f7688d9..de58f3304 100644
--- a/procps/pmap.c
+++ b/procps/pmap.c
@@ -29,10 +29,14 @@
 
 #if ULLONG_MAX == 0xffffffff
 # define TABS "\t"
+# define SIZEWIDTHx "7"
+# define SIZEWIDTH  "9"
 # define AFMTLL "8"
 # define DASHES ""
 #else
 # define TABS "\t\t"
+# define SIZEWIDTHx "15"
+# define SIZEWIDTH  "17"
 # define AFMTLL "16"
 # define DASHES "--------"
 #endif
@@ -42,22 +46,114 @@ enum {
         OPT_q = 1 << 1,
 };
 
-static void print_smaprec(struct smaprec *currec, void *data)
-{
-        unsigned opt = (uintptr_t)data;
+struct smaprec {
+        // For mixed 32/64 userspace, 32-bit pmap still needs
+        // 64-bit field here to correctly show 64-bit processes:
+        unsigned long long smap_start;
+        // Make size wider too:
+        // I've seen 1203765248 kb large "---p" mapping in a browser,
+        // this cuts close to 4 terabytes.
+        unsigned long long smap_size;
+        // (strictly speaking, other fields need to be wider too,
+        // but they are in kbytes, not bytes, and they hold sizes,
+        // not start addresses, sizes tend to be less than 4 terabytes)
+        unsigned long private_dirty;
+        unsigned long smap_pss, smap_swap;
+        char smap_mode[5];
+        char *smap_name;
+};
 
+static void print_smaprec(struct smaprec *currec)
+{
         printf("%0" AFMTLL "llx ", currec->smap_start);
 
-        if (opt & OPT_x)
-                printf("%7lu %7lu %7lu %7lu ",
+        if (option_mask32 & OPT_x)
+                printf("%7llu %7lu %7lu %7lu ",
                         currec->smap_size,
                         currec->smap_pss,
                         currec->private_dirty,
                         currec->smap_swap);
         else
-                printf("%7luK", currec->smap_size);
+                printf("%7lluK", currec->smap_size);
+
+        printf(" %.4s  %s\n", currec->smap_mode, currec->smap_name ? : "  [ anon ]");
+}
+
+/* libbb's procps_read_smaps() looks somewhat similar,
+ * but the collected information is sufficiently different
+ * that merging them into one function is not a good idea
+ * (unless you feel masochistic today).
+ */
+static int read_smaps(pid_t pid, struct smaprec *total)
+{
+        FILE *file;
+        struct smaprec currec;
+        char filename[sizeof("/proc/%u/smaps") + sizeof(int)*3];
+        char buf[4096]; // how long the max filenames we expect?
+
+        sprintf(filename, "/proc/%u/smaps", (int)pid);
+
+        file = fopen_for_read(filename);
+        if (!file)
+                return 1;
+
+        memset(&currec, 0, sizeof(currec));
+        while (fgets(buf, sizeof(buf), file)) {
+                // Each mapping datum has this form:
+                // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
+                // Size:                nnn kB
+                // Rss:                 nnn kB
+                // .....
+
+                char *tp, *p;
+
+                if (buf[0] == 'S' || buf[0] == 'P') {
+#define SCAN(S, X) \
+                        if (memcmp(buf, S, sizeof(S)-1) == 0) { \
+                                tp = skip_whitespace(buf + sizeof(S)-1); \
+                                total->X += currec.X = fast_strtoul_10(&tp); \
+                                continue; \
+                        }
+                        SCAN("Pss:"          , smap_pss     );
+                        SCAN("Swap:"         , smap_swap    );
+                        SCAN("Private_Dirty:", private_dirty);
+#undef SCAN
+                }
+                tp = strchr(buf, '-');
+                if (tp) {
+                        // We reached next mapping - the line of this form:
+                        // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
+
+                        // If we have a previous record, there's nothing more
+                        // for it, print and clear currec
+                        if (currec.smap_size)
+                                print_smaprec(&currec);
+                        free(currec.smap_name);
+                        memset(&currec, 0, sizeof(currec));
+
+                        *tp = ' ';
+                        tp = buf;
+                        currec.smap_start = fast_strtoull_16(&tp);
+                        currec.smap_size = (fast_strtoull_16(&tp) - currec.smap_start) >> 10;
+                        strncpy(currec.smap_mode, tp, sizeof(currec.smap_mode)-1);
+
+                        // skipping "rw-s FILEOFS M:m INODE "
+                        tp = skip_fields(tp, 4);
+                        tp = skip_whitespace(tp); // there may be many spaces, can't just "tp++"
+                        p = strchrnul(tp, '\n');
+                        if (p != tp) {
+                                currec.smap_name = xstrndup(tp, p - tp);
+                        }
+                        total->smap_size += currec.smap_size;
+                }
+        } // while (got line)
+        fclose(file);
+
+        if (currec.smap_size)
+                print_smaprec(&currec);
+        free(currec.smap_name);
 
-        printf(" %.4s  %s\n", currec->smap_mode, currec->smap_name);
+        return 0;
 }
 
 static int procps_get_maps(pid_t pid, unsigned opt)
@@ -66,25 +162,27 @@ static int procps_get_maps(pid_t pid, unsigned opt)
         int ret;
         char buf[256];
 
-        read_cmdline(buf, sizeof(buf), pid, NULL);
+        ret = read_cmdline(buf, sizeof(buf), pid, NULL);
+        if (ret < 0)
+                return ret;
+
         printf("%u: %s\n", (int)pid, buf);
 
         if (!(opt & OPT_q) && (opt & OPT_x))
                 puts("Address" TABS "  Kbytes     PSS   Dirty    Swap  Mode  Mapping");
 
         memset(&total, 0, sizeof(total));
-
-        ret = procps_read_smaps(pid, &total, print_smaprec, (void*)(uintptr_t)opt);
+        ret = read_smaps(pid, &total);
         if (ret)
                 return ret;
 
         if (!(opt & OPT_q)) {
                 if (opt & OPT_x)
                         printf("--------" DASHES "  ------  ------  ------  ------\n"
-                                "total" TABS " %7lu %7lu %7lu %7lu\n",
+                                "total kB %"SIZEWIDTHx"llu %7lu %7lu %7lu\n",
                                 total.smap_size, total.smap_pss, total.private_dirty, total.smap_swap);
                 else
-                        printf("mapped: %luK\n", total.smap_size);
+                        printf(" total %"SIZEWIDTH"lluK\n", total.smap_size);
         }
 
         return 0;
diff --git a/procps/top.c b/procps/top.c
index a87fa0ae4..e0ebf7026 100644
--- a/procps/top.c
+++ b/procps/top.c
@@ -1302,20 +1302,20 @@ int top_main(int argc UNUSED_PARAM, char **argv)
                         }
 #if ENABLE_FEATURE_TOPMEM
                         else { /* TOPMEM */
-                                if (!(p->smaps.mapped_ro | p->smaps.mapped_rw))
+                                if (!(p->mapped_ro | p->mapped_rw))
                                         continue; /* kernel threads are ignored */
                                 n = ntop;
                                 /* No bug here - top and topmem are the same */
                                 top = xrealloc_vector(topmem, 6, ntop++);
                                 strcpy(topmem[n].comm, p->comm);
                                 topmem[n].pid      = p->pid;
-                                topmem[n].vsz      = p->smaps.mapped_rw + p->smaps.mapped_ro;
-                                topmem[n].vszrw    = p->smaps.mapped_rw;
-                                topmem[n].rss_sh   = p->smaps.shared_clean + p->smaps.shared_dirty;
-                                topmem[n].rss      = p->smaps.private_clean + p->smaps.private_dirty + topmem[n].rss_sh;
-                                topmem[n].dirty    = p->smaps.private_dirty + p->smaps.shared_dirty;
-                                topmem[n].dirty_sh = p->smaps.shared_dirty;
-                                topmem[n].stack    = p->smaps.stack;
+                                topmem[n].vsz      = p->mapped_rw + p->mapped_ro;
+                                topmem[n].vszrw    = p->mapped_rw;
+                                topmem[n].rss_sh   = p->shared_clean + p->shared_dirty;
+                                topmem[n].rss      = p->private_clean + p->private_dirty + topmem[n].rss_sh;
+                                topmem[n].dirty    = p->private_dirty + p->shared_dirty;
+                                topmem[n].dirty_sh = p->shared_dirty;
+                                topmem[n].stack    = p->stack;
                         }
 #endif
                 } /* end of "while we read /proc" */