uml: Fix which_tmpdir failure when /dev/shm is a symlink, and in other edge cases

which_tmpdir did the wrong thing if /dev/shm was a symlink (e.g., to /run/shm),
if there were multiple mounts on top of each other, if the mount(s) were
obscured by a later mount, or if /dev/shm was a prefix of another mount point.
This fixes these cases. Applies to 3.9.6.

Signed-off-by: Tristan Schmelcher <tschmelcher@google.com>
Signed-off-by: Richard Weinberger <richard@nod.at>

1 files changed, 189 insertions, 41 deletions

diff --git a/arch/um/os-Linux/mem.c b/arch/um/os-Linux/mem.c
index ba4398056fe9..3c4af77e51a2 100644
--- a/arch/um/os-Linux/mem.c
+++ b/arch/um/os-Linux/mem.c
@@ -53,6 +53,25 @@ static void __init find_tempdir(void)
 }
 
 /*
+ * Remove bytes from the front of the buffer and refill it so that if there's a
+ * partial string that we care about, it will be completed, and we can recognize
+ * it.
+ */
+static int pop(int fd, char *buf, size_t size, size_t npop)
+{
+        ssize_t n;
+        size_t len = strlen(&buf[npop]);
+
+        memmove(buf, &buf[npop], len + 1);
+        n = read(fd, &buf[len], size - len - 1);
+        if (n < 0)
+                return -errno;
+
+        buf[len + n] = '\0';
+        return 1;
+}
+
+/*
  * This will return 1, with the first character in buf being the
  * character following the next instance of c in the file.  This will
  * read the file as needed.  If there's an error, -errno is returned;
@@ -61,7 +80,6 @@ static void __init find_tempdir(void)
 static int next(int fd, char *buf, size_t size, char c)
 {
         ssize_t n;
-        size_t len;
         char *ptr;
 
         while ((ptr = strchr(buf, c)) == NULL) {
@@ -74,20 +92,129 @@ static int next(int fd, char *buf, size_t size, char c)
                 buf[n] = '\0';
         }
 
-        ptr++;
-        len = strlen(ptr);
-        memmove(buf, ptr, len + 1);
+        return pop(fd, buf, size, ptr - buf + 1);
+}
+
+/*
+ * Decode an octal-escaped and space-terminated path of the form used by
+ * /proc/mounts. May be used to decode a path in-place. "out" must be at least
+ * as large as the input. The output is always null-terminated. "len" gets the
+ * length of the output, excluding the trailing null. Returns 0 if a full path
+ * was successfully decoded, otherwise an error.
+ */
+static int decode_path(const char *in, char *out, size_t *len)
+{
+        char *first = out;
+        int c;
+        int i;
+        int ret = -EINVAL;
+        while (1) {
+                switch (*in) {
+                case '\0':
+                        goto out;
+
+                case ' ':
+                        ret = 0;
+                        goto out;
+
+                case '\\':
+                        in++;
+                        c = 0;
+                        for (i = 0; i < 3; i++) {
+                                if (*in < '0' || *in > '7')
+                                        goto out;
+                                c = (c << 3) | (*in++ - '0');
+                        }
+                        *(unsigned char *)out++ = (unsigned char) c;
+                        break;
+
+                default:
+                        *out++ = *in++;
+                        break;
+                }
+        }
+
+out:
+        *out = '\0';
+        *len = out - first;
+        return ret;
+}
+
+/*
+ * Computes the length of s when encoded with three-digit octal escape sequences
+ * for the characters in chars.
+ */
+static size_t octal_encoded_length(const char *s, const char *chars)
+{
+        size_t len = strlen(s);
+        while ((s = strpbrk(s, chars)) != NULL) {
+                len += 3;
+                s++;
+        }
+
+        return len;
+}
+
+enum {
+        OUTCOME_NOTHING_MOUNTED,
+        OUTCOME_TMPFS_MOUNT,
+        OUTCOME_NON_TMPFS_MOUNT,
+};
+
+/* Read a line of /proc/mounts data looking for a tmpfs mount at "path". */
+static int read_mount(int fd, char *buf, size_t bufsize, const char *path,
+                      int *outcome)
+{
+        int found;
+        int match;
+        char *space;
+        size_t len;
+
+        enum {
+                MATCH_NONE,
+                MATCH_EXACT,
+                MATCH_PARENT,
+        };
+
+        found = next(fd, buf, bufsize, ' ');
+        if (found != 1)
+                return found;
 
         /*
-         * Refill the buffer so that if there's a partial string that we care
-         * about, it will be completed, and we can recognize it.
+         * If there's no following space in the buffer, then this path is
+         * truncated, so it can't be the one we're looking for.
          */
-        n = read(fd, &buf[len], size - len - 1);
-        if (n < 0)
-                return -errno;
+        space = strchr(buf, ' ');
+        if (space) {
+                match = MATCH_NONE;
+                if (!decode_path(buf, buf, &len)) {
+                        if (!strcmp(buf, path))
+                                match = MATCH_EXACT;
+                        else if (!strncmp(buf, path, len)
+                                 && (path[len] == '/' || !strcmp(buf, "/")))
+                                match = MATCH_PARENT;
+                }
+
+                found = pop(fd, buf, bufsize, space - buf + 1);
+                if (found != 1)
+                        return found;
+
+                switch (match) {
+                case MATCH_EXACT:
+                        if (!strncmp(buf, "tmpfs", strlen("tmpfs")))
+                                *outcome = OUTCOME_TMPFS_MOUNT;
+                        else
+                                *outcome = OUTCOME_NON_TMPFS_MOUNT;
+                        break;
 
-        buf[len + n] = '\0';
-        return 1;
+                case MATCH_PARENT:
+                        /* This mount obscures any previous ones. */
+                        *outcome = OUTCOME_NOTHING_MOUNTED;
+                        break;
+                }
+        }
+
+        return next(fd, buf, bufsize, '\n');
 }
 
 /* which_tmpdir is called only during early boot */
@@ -106,8 +233,12 @@ static int checked_tmpdir = 0;
  */
 static void which_tmpdir(void)
 {
-        int fd, found;
-        char buf[128] = { '\0' };
+        int fd;
+        int found;
+        int outcome;
+        char *path;
+        char *buf;
+        size_t bufsize;
 
         if (checked_tmpdir)
                 return;