[NaCl SDK] nacl_io: Change default root filesystem type from passthroughfs to memfs

native_client_sdk/src/tests/nacl_io_test/kernel_proxy_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 55 matching lines @@
   }
 
   void TearDown() { ki_uninit(); }
 
  protected:
   KernelProxyTest_KernelProxy kp_;
 };
 
 }  // namespace
 
+// Helper function for calling ki_fcntl without having
+// to construct a va_list.
 static int ki_fcntl_wrapper(int fd, int request, ...) {
   va_list ap;
   va_start(ap, request);
   int rtn = ki_fcntl(fd, request, ap);
   va_end(ap);
   return rtn;
 }
 
-/**
- * Test for fcntl commands F_SETFD and F_GETFD.  This
- * is tested here rather than in the mount_node tests
- * since the fd flags are not stored in the kernel_handle
- * or the filesystem node but directly in the FD mapping.
- */
+// Helper function for calling ki_ioctl without having
+// to construct a va_list.
+static int ki_ioctl_wrapper(int fd, int request, ...) {
+  va_list ap;
+  va_start(ap, request);
+  int rtn = ki_ioctl(fd, request, ap);
+  va_end(ap);
+  return rtn;
+}
+
+// Helper to verify directory contents using ki_getdents.
+// Verified that each of the 'count' elements in the 'expected' array
+// are present in the directory and that no other entries are present.
+// If count is -1 then no checking is done and enties are printed using
+// printf.
+static void CheckDirContents(const char* dirname, const char** expected,
+                             int count) {
+  int dir = ki_open(dirname, O_RDONLY, 0);
+  ASSERT_GE(dir, 0);
+  while (1) {
+    char buf[512];
+    int rtn = ki_getdents(dir, buf, sizeof(buf));
+    if (rtn <= 0)
+      break;
+    int offset = 0;
+    while (offset < rtn) {
+      struct dirent* entry = (struct dirent*)(buf + offset);
+      if (count == -1)
+        printf("entry: %s\n", entry->d_name);
+      offset += entry->d_reclen;
+      if (count == -1)
+        continue;
+      int i;
+      for (i = 0; i < count; i++) {
+        if (expected[i] && strcmp(expected[i], entry->d_name) == 0) {
+          expected[i] = NULL;
+          break;
+        }
+      }
+      if (i == count) {
+        FAIL() << "Unexpeected entry '" << entry->d_name
+          << "' in directory: " << dirname;
+      }
+    }
+  }
+
+  ASSERT_EQ(0, ki_close(dir));
+
+  if (count != -1) {
+    for (int i = 0; i < count; i++) {
+      if (expected[i] != NULL) {
+        FAIL() << "Expected entry '" << expected[i]
+          << "' not found in directory: " << dirname;
+      }
+    }
+  }
+}
+
+// Test for fcntl commands F_SETFD and F_GETFD.  This
+// is tested here rather than in the mount_node tests
+// since the fd flags are not stored in the kernel_handle
+// or the filesystem node but directly in the FD mapping.
 TEST_F(KernelProxyTest, Fcntl_GETFD) {
   int fd = ki_open("/test", O_RDWR | O_CREAT, 0777);
   ASSERT_NE(-1, fd);
 
   // FD flags should start as zero.
   ASSERT_EQ(0, ki_fcntl_wrapper(fd, F_GETFD));
 
   // Check that setting FD_CLOEXEC works
   int flags = FD_CLOEXEC;
   ASSERT_EQ(0, ki_fcntl_wrapper(fd, F_SETFD, flags))
@@ skipping 13 matching lines @@
 
   MemFs* filesystem = (MemFs*)kp_.RootFs();
   ScopedNode root;
 
   ASSERT_EQ(0, filesystem->Open(Path("/"), O_RDONLY, &root));
   ASSERT_EQ(0, root->ChildCount());
 
   for (int file_num = 0; file_num < 4096; file_num++) {
     sprintf(filename, "/foo%i.tmp", file_num++);
     int fd = ki_open(filename, O_WRONLY | O_CREAT, 0777);
-    ASSERT_GT(fd, -1);
+    ASSERT_GE(fd, 0);
     ASSERT_EQ(1, root->ChildCount());
     ASSERT_EQ(buffer_size, ki_write(fd, garbage, buffer_size));
     ki_close(fd);
     ASSERT_EQ(0, ki_remove(filename));
   }
   ASSERT_EQ(0, root->ChildCount());
 }
 
 static bool g_handler_called = false;
 static void sighandler(int) { g_handler_called = true; }
@@ skipping 95 matching lines @@
   // Restore existing handler
   oldsig = ki_signal(SIGWINCH, oldsig);
 
   // Verify the our newsig was returned as previous handler
   ASSERT_EQ(oldsig, newsig);
 }
 
 TEST_F(KernelProxyTest, Rename) {
   // Create a dummy file
   int file1 = ki_open("/test1.txt", O_RDWR | O_CREAT, 0777);
-  ASSERT_GT(file1, -1);
+  ASSERT_GE(file1, 0);
   ASSERT_EQ(0, ki_close(file1));
 
   // Test the renaming works
   ASSERT_EQ(0, ki_rename("/test1.txt", "/test2.txt"));
 
   // Test that renaming across mount points fails
   ASSERT_EQ(0, ki_mount("", "/foo", "memfs", 0, ""));
   ASSERT_EQ(-1, ki_rename("/test2.txt", "/foo/test2.txt"));
   ASSERT_EQ(EXDEV, errno);
 }
@@ skipping 29 matching lines @@
 
   memset(text, 0, sizeof(text));
   EXPECT_EQ(-1, ki_chdir("foo"));
   EXPECT_EQ(ENOENT, errno);
   EXPECT_EQ(0, ki_chdir(".."));
   EXPECT_EQ(0, ki_chdir("/foo"));
   EXPECT_EQ(text, ki_getcwd(text, sizeof(text)));
   EXPECT_STREQ("/foo", text);
 }
 
+TEST_F(KernelProxyTest, Mkdir) {
+  ASSERT_EQ(0, ki_mkdir("/foo", S_IREAD | S_IWRITE));
+  ASSERT_EQ(-1, ki_mkdir("/foo", S_IREAD | S_IWRITE));
+  ASSERT_EQ(EEXIST, errno);
+
+  // Some component of parent directory does not exist
+  ASSERT_EQ(-1, ki_mkdir("/does_not_exist/foo", S_IREAD | S_IWRITE));
+  ASSERT_EQ(ENOENT, errno);
+
+  int fd = ki_open("/filename", O_CREAT | O_RDWR, 0777);
+  ASSERT_GE(fd, 0);
+
+  // Some component of parent directory is not actually a directory
+  ASSERT_EQ(-1, ki_mkdir("/filename/foo", S_IREAD | S_IWRITE));
+  ASSERT_EQ(ENOTDIR, errno);
+}
+
+TEST_F(KernelProxyTest, Rmdir) {
+  ASSERT_EQ(-1, ki_rmdir("/dev/fs"));
+  ASSERT_EQ(EPERM, errno);
+
+  ASSERT_EQ(-1, ki_rmdir("/foo"));
+  ASSERT_EQ(ENOENT, errno);
+}
+
 TEST_F(KernelProxyTest, FDPathMapping) {
   char text[1024];
 
   int fd1, fd2, fd3, fd4, fd5;
 
   EXPECT_EQ(0, ki_mkdir("/foo", S_IREAD | S_IWRITE));
   EXPECT_EQ(0, ki_mkdir("/foo/bar", S_IREAD | S_IWRITE));
   EXPECT_EQ(0, ki_mkdir("/example", S_IREAD | S_IWRITE));
   ki_chdir("/foo");
 
   fd1 = ki_open("/example", O_RDONLY, 0);
-  EXPECT_NE(-1, fd1);
+  ASSERT_GT(fd1, 0);
   EXPECT_EQ(ki_fchdir(fd1), 0);
   EXPECT_EQ(text, ki_getcwd(text, sizeof(text)));
   EXPECT_STREQ("/example", text);
 
   EXPECT_EQ(0, ki_chdir("/foo"));
   fd2 = ki_open("../example", O_RDONLY, 0);
-  EXPECT_NE(-1, fd2);
+  ASSERT_GE(fd2, 0);
   EXPECT_EQ(0, ki_fchdir(fd2));
   EXPECT_EQ(text, ki_getcwd(text, sizeof(text)));
   EXPECT_STREQ("/example", text);
 
   EXPECT_EQ(0, ki_chdir("/foo"));
   fd3 = ki_open("../test", O_CREAT | O_RDWR, 0777);
-  EXPECT_NE(-1, fd3);
+  ASSERT_GE(fd3, 0);
   EXPECT_EQ(-1, ki_fchdir(fd3));
   EXPECT_EQ(ENOTDIR, errno);
 
   EXPECT_EQ(0, ki_chdir("/foo"));
   fd4 = ki_open("bar", O_RDONLY, 0);
+  ASSERT_GE(fd4, 0);
   EXPECT_EQ(0, ki_fchdir(fd4));
   EXPECT_EQ(text, ki_getcwd(text, sizeof(text)));
   EXPECT_STREQ("/foo/bar", text);
   EXPECT_EQ(0, ki_chdir("/example"));
   EXPECT_EQ(0, ki_fchdir(fd4));
   EXPECT_EQ(text, ki_getcwd(text, sizeof(text)));
   EXPECT_STREQ("/foo/bar", text);
 
   EXPECT_EQ(0, ki_chdir("/example"));
   fd5 = ki_dup(fd4);
-  ASSERT_GT(fd5, -1);
+  ASSERT_GE(fd5, 0);
   ASSERT_NE(fd4, fd5);
   EXPECT_EQ(0, ki_fchdir(fd5));
   EXPECT_EQ(text, ki_getcwd(text, sizeof(text)));
   EXPECT_STREQ("/foo/bar", text);
 
   fd5 = 123;
 
   EXPECT_EQ(0, ki_chdir("/example"));
   EXPECT_EQ(fd5, ki_dup2(fd4, fd5));
   EXPECT_EQ(0, ki_fchdir(fd5));
   EXPECT_EQ(text, ki_getcwd(text, sizeof(text)));
   EXPECT_STREQ("/foo/bar", text);
 }
 
+TEST_F(KernelProxyTest, Getdents) {
+  const char* expected[] = { "..", "." };
+  CheckDirContents("/", expected, 2);
+
+  ASSERT_GE(ki_open("/foo", O_RDWR | O_CREAT, 0777), 0);
+  const char* expected1[] = { "foo", "..", "." };
+  CheckDirContents("/", expected1, 3);
+}
+
 TEST_F(KernelProxyTest, BasicReadWrite) {
   char text[1024];
   int fd1, fd2, fd3;
   int len;
 
   // Fail to delete non existant "/foo"
   EXPECT_EQ(-1, ki_rmdir("/foo"));
   EXPECT_EQ(ENOENT, errno);
 
   // Create "/foo"
@@ skipping 102 matching lines @@
   EXPECT_EQ(0, ki_close(fd1));
 
   // Truncate should fail if the file is not writable.
   EXPECT_EQ(0, ki_chmod("/trunc", 0444));
   EXPECT_EQ(-1, ki_truncate("/trunc",  0));
   EXPECT_EQ(EACCES, errno);
 }
 
 TEST_F(KernelProxyTest, Lseek) {
   int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
   ASSERT_EQ(9, ki_write(fd, "Some text", 9));
 
   ASSERT_EQ(9, ki_lseek(fd, 0, SEEK_CUR));
   ASSERT_EQ(9, ki_lseek(fd, 0, SEEK_END));
   ASSERT_EQ(-1, ki_lseek(fd, -1, SEEK_SET));
   ASSERT_EQ(EINVAL, errno);
 
   // Seek past end of file.
   ASSERT_EQ(13, ki_lseek(fd, 13, SEEK_SET));
   char buffer[4];
   memset(&buffer[0], 0xfe, 4);
   ASSERT_EQ(9, ki_lseek(fd, -4, SEEK_END));
   ASSERT_EQ(9, ki_lseek(fd, 0, SEEK_CUR));
   ASSERT_EQ(4, ki_read(fd, &buffer[0], 4));
   ASSERT_EQ(0, memcmp("\0\0\0\0", buffer, 4));
 }
 
 TEST_F(KernelProxyTest, CloseTwice) {
   int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
 
   EXPECT_EQ(9, ki_write(fd, "Some text", 9));
 
   int fd2 = ki_dup(fd);
-  ASSERT_GT(fd2, -1);
+  ASSERT_GE(fd2, 0);
 
   EXPECT_EQ(0, ki_close(fd));
   EXPECT_EQ(0, ki_close(fd2));
 }
 
 TEST_F(KernelProxyTest, Dup) {
   int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
 
   int dup_fd = ki_dup(fd);
   ASSERT_NE(-1, dup_fd);
 
   ASSERT_EQ(9, ki_write(fd, "Some text", 9));
   ASSERT_EQ(9, ki_lseek(fd, 0, SEEK_CUR));
   ASSERT_EQ(9, ki_lseek(dup_fd, 0, SEEK_CUR));
 
   int dup2_fd = 123;
   ASSERT_EQ(dup2_fd, ki_dup2(fd, dup2_fd));
@@ skipping 17 matching lines @@
 }
 
 TEST_F(KernelProxyTest, DescriptorAllocationConsistency) {
   // Check that the descriptor free list returns the expected ones,
   // as the order is mandated by POSIX.
 
   // Open a file to a get a descriptor to copy for this test.
   // The test makes the assumption at all descriptors
   // open by default are contiguous starting from zero.
   int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
 
   // The next descriptor allocated should follow the first.
   int dup_fd = ki_dup(fd);
   ASSERT_EQ(fd + 1, dup_fd);
 
   // Allocate a high descriptor number.
   ASSERT_EQ(100, ki_dup2(fd, 100));
 
   // The next descriptor allocate should still come 2 places
   // after the first.
   int dup_fd2 = ki_dup(fd);
   ASSERT_EQ(fd + 2, dup_fd2);
 }
 
 TEST_F(KernelProxyTest, Lstat) {
   int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
   ASSERT_EQ(0, ki_mkdir("/bar", S_IREAD | S_IWRITE));
 
   struct stat buf;
   EXPECT_EQ(0, ki_lstat("/foo", &buf));
   EXPECT_EQ(0, buf.st_size);
   EXPECT_TRUE(S_ISREG(buf.st_mode));
 
   EXPECT_EQ(0, ki_lstat("/bar", &buf));
   EXPECT_EQ(0, buf.st_size);
   EXPECT_TRUE(S_ISDIR(buf.st_mode));
@@ skipping 45 matching lines @@
   // is ignored.
   ASSERT_EQ(0, ki_fchmod(fd, S_IFBLK | 0222));
   ASSERT_EQ(0, ki_stat("/foo", &buf));
   EXPECT_TRUE(S_ISREG(buf.st_mode));
   ASSERT_EQ(0222, buf.st_mode & 0777);
 }
 
 TEST_F(KernelProxyTest, OpenDirectory) {
   // Opening a directory for read should succeed.
   int fd = ki_open("/", O_RDONLY, 0);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
 
   // Opening a directory for write should fail.
   EXPECT_EQ(-1, ki_open("/", O_RDWR, 0));
   EXPECT_EQ(errno, EISDIR);
   EXPECT_EQ(-1, ki_open("/", O_WRONLY, 0));
   EXPECT_EQ(errno, EISDIR);
 }
 
 TEST_F(KernelProxyTest, OpenWithMode) {
   int fd = ki_open("/foo", O_CREAT | O_RDWR, 0723);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
 
   struct stat buf;
   EXPECT_EQ(0, ki_lstat("/foo", &buf));
   EXPECT_EQ(0723, buf.st_mode & 0777);
 }
 
 TEST_F(KernelProxyTest, CreateWronlyWithReadOnlyMode) {
   int fd = ki_open("/foo", O_CREAT | O_WRONLY, 0444);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
 }
 
 TEST_F(KernelProxyTest, UseAfterClose) {
   int fd = ki_open("/dummy", O_CREAT | O_WRONLY, 0777);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
   EXPECT_EQ(5, ki_write(fd, "hello", 5));
   EXPECT_EQ(0, ki_close(fd));
   EXPECT_EQ(-1, ki_write(fd, "hello", 5));
   EXPECT_EQ(EBADF, errno);
 }
 
 TEST_F(KernelProxyTest, Utimes) {
   struct timeval times[2];
   times[0].tv_sec = 1000;
   times[0].tv_usec = 2000;
   times[1].tv_sec = 3000;
   times[1].tv_usec = 4000;
 
   int fd = ki_open("/dummy", O_CREAT | O_WRONLY, 0222);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
   EXPECT_EQ(0, ki_close(fd));
 
   // utime should work if the file is write-only.
   EXPECT_EQ(0, ki_utimes("/dummy", times));
 
   // utime should work on directories (which can never be opened for write)
   EXPECT_EQ(0, ki_utimes("/", times));
 
   // or if the file is read-only.
   EXPECT_EQ(0, ki_chmod("/dummy", 0444));
@@ skipping 18 matching lines @@
       buf.st_mtime > tm.tv_sec ||
       (buf.st_mtime == tm.tv_sec && buf.st_mtimensec >= tm.tv_usec * 1000));
 }
 
 TEST_F(KernelProxyTest, Utime) {
   struct utimbuf times;
   times.actime = 1000;
   times.modtime = 2000;
 
   int fd = ki_open("/dummy", O_CREAT | O_WRONLY, 0222);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
   EXPECT_EQ(0, ki_close(fd));
 
   // utime should work if the file is write-only.
   EXPECT_EQ(0, ki_utime("/dummy", &times));
 
   // or if the file is read-only.
   EXPECT_EQ(0, ki_chmod("/dummy", 0444));
   EXPECT_EQ(0, ki_utime("/dummy", &times));
 
   // times can be NULL. In that case the access/mod times will be set to the
@@ skipping 14 matching lines @@
   EXPECT_TRUE(
       buf.st_mtime > tm.tv_sec ||
       (buf.st_mtime == tm.tv_sec && buf.st_mtimensec >= tm.tv_usec * 1000));
 }
 
 TEST_F(KernelProxyTest, Umask) {
   mode_t oldmask = ki_umask(0222);
   EXPECT_EQ(0, oldmask);
 
   int fd = ki_open("/foo", O_CREAT | O_RDONLY, 0666);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
   ki_close(fd);
 
   EXPECT_EQ(0, ki_mkdir("/dir", 0777));
 
   struct stat buf;
   EXPECT_EQ(0, ki_stat("/foo", &buf));
   EXPECT_EQ(0444, buf.st_mode & 0777);
 
   EXPECT_EQ(0, ki_stat("/dir", &buf));
   EXPECT_EQ(0555, buf.st_mode & 0777);
@@ skipping 51 matching lines @@
 
   void TearDown() {
     g_string_map.clear();
     ki_uninit();
   }
 
  protected:
   KernelProxyMountTest_KernelProxy kp_;
 };
 
-// Helper function for calling ki_ioctl without having
-// to construct a va_list.
-int ki_ioctl_wrapper(int fd, int request, ...) {
-  va_list ap;
-  va_start(ap, request);
-  int rtn = ki_ioctl(fd, request, ap);
-  va_end(ap);
-  return rtn;
-}
-
 }  // namespace
 
 TEST_F(KernelProxyMountTest, MountInit) {
-  int res1 = ki_mount("/", "/mnt1", "initfs", 0, "false,foo=bar");
+  ASSERT_EQ(0, ki_mkdir("/mnt1", 0777));
+  int res1 = ki_mount("", "/mnt1", "initfs", 0, "false,foo=bar");
 
   EXPECT_EQ("bar", g_string_map["foo"]);
   EXPECT_EQ(-1, res1);
   EXPECT_EQ(EINVAL, errno);
 
-  int res2 = ki_mount("/", "/mnt2", "initfs", 0, "true,bar=foo,x=y");
+  ASSERT_EQ(0, ki_mkdir("/mnt2", 0777));
+  int res2 = ki_mount("", "/mnt2", "initfs", 0, "true,bar=foo,x=y");
   EXPECT_NE(-1, res2);
   EXPECT_EQ("y", g_string_map["x"]);
+
+}
+
+TEST_F(KernelProxyMountTest, Passthroughfs) {
+  ASSERT_EQ(0, ki_mkdir("/passthrough", 0777));
+  int res1 = ki_mount("", "/passthrough", "passthroughfs", 0, "");
+  EXPECT_NE(-1, res1);
+  CheckDirContents("/passthrough", NULL, -1);
 }
 
 TEST_F(KernelProxyMountTest, MountAndIoctl) {
-  ASSERT_EQ(0, ki_mount("/", "/mnt1", "initfs", 0, ""));
+  ASSERT_EQ(0, ki_mkdir("/mnt1", 0777));
+  ASSERT_EQ(0, ki_mount("", "/mnt1", "initfs", 0, ""));
   ASSERT_NE(-1, g_fs_dev);
 
   char path[100];
-  snprintf(path, 100, "dev/fs/%d", g_fs_dev);
+  snprintf(path, 100, "/dev/fs/%d", g_fs_dev);
 
   int fd = ki_open(path, O_RDONLY, 0);
-  ASSERT_GT(fd, -1);
+  ASSERT_GE(fd, 0);
 
   EXPECT_EQ(0, ki_ioctl_wrapper(fd, 0xdeadbeef));
   EXPECT_EQ(true, g_fs_ioctl_called);
 }
 
 static void mount_callback(const char* source,
                            const char* target,
                            const char* filesystemtype,
                            unsigned long mountflags,
                            const void* data,
                            dev_t dev,
                            void* user_data) {
-  EXPECT_STREQ("/", source);
+  EXPECT_STREQ("dummy", source);
   EXPECT_STREQ("/mnt1", target);
   EXPECT_STREQ("initfs", filesystemtype);
   EXPECT_EQ(0, mountflags);
   EXPECT_STREQ("", (const char*) data);
   EXPECT_EQ(g_fs_dev, dev);
 
   bool* callback_called = static_cast<bool*>(user_data);
   *callback_called = true;
 }
 
 TEST_F(KernelProxyMountTest, MountCallback) {
   bool callback_called = false;
   kp_.SetMountCallback(&mount_callback, &callback_called);
-  ASSERT_EQ(0, ki_mount("/", "/mnt1", "initfs", 0, ""));
+  ASSERT_EQ(0, ki_mkdir("/mnt1", 0777));
+  ASSERT_EQ(0, ki_mount("dummy", "/mnt1", "initfs", 0, ""));
   ASSERT_NE(-1, g_fs_dev);
   EXPECT_EQ(true, callback_called);
 }
 
 namespace {
 
 int g_MMapCount = 0;
 
 class KernelProxyMMapTest_Node : public Node {
  public:
@@ skipping 70 matching lines @@
 
   void TearDown() { ki_uninit(); }
 
  private:
   KernelProxyMMapTest_KernelProxy kp_;
 };
 
 }  // namespace
 
 TEST_F(KernelProxyMMapTest, MMap) {
-  ASSERT_EQ(0, ki_umount("/"));
-  ASSERT_EQ(0, ki_mount("", "/", "mmapfs", 0, NULL));
-  int fd = ki_open("/file", O_RDWR | O_CREAT, 0777);
+  ASSERT_EQ(0, ki_mkdir("/mmap", 0777));
+  ASSERT_EQ(0, ki_mount("", "/mmap", "mmapfs", 0, NULL));
+  int fd = ki_open("/mmap/file", O_RDWR | O_CREAT, 0777);
   ASSERT_NE(-1, fd);
 
   void* addr1 = ki_mmap(NULL, 0x800, PROT_READ, MAP_PRIVATE, fd, 0);
   ASSERT_EQ(reinterpret_cast<void*>(0x1000), addr1);
   ASSERT_EQ(1, g_MMapCount);
 
   void* addr2 = ki_mmap(NULL, 0x800, PROT_READ, MAP_PRIVATE, fd, 0);
   ASSERT_EQ(reinterpret_cast<void*>(0x2000), addr2);
   ASSERT_EQ(2, g_MMapCount);
 
@@ skipping 43 matching lines @@
   ScopedRef<MockFs> fs_;
 };
 
 class KernelProxyErrorTest : public ::testing::Test {
  public:
   KernelProxyErrorTest() {}
 
   void SetUp() {
     ASSERT_EQ(0, ki_push_state_for_testing());
     ASSERT_EQ(0, ki_init(&kp_));
-    // Unmount the passthrough FS and mount a testfs.
+    // Unmount root fs and mount a testfs.
     EXPECT_EQ(0, kp_.umount("/"));
     EXPECT_EQ(0, kp_.mount("", "/", "testfs", 0, NULL));
   }
 
   void TearDown() { ki_uninit(); }
 
   ScopedRef<MockFs> fs() { return kp_.fs(); }
 
  private:
   KernelProxyErrorTest_KernelProxy kp_;
@@ skipping 38 matching lines @@
 
   int fd = ki_open("/dummy", O_RDONLY, 0);
   EXPECT_NE(0, fd);
 
   char buf[20];
   EXPECT_EQ(-1, ki_read(fd, &buf[0], 20));
   // The Filesystem should be able to return whatever error it wants and have it
   // propagate through.
   EXPECT_EQ(1234, errno);
 }