Plumbing though mode parameter to open, since fusefs can make use of it.

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>
 
@@ skipping 67 matching lines @@
   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.
  */
 TEST_F(KernelProxyTest, Fcntl_GETFD) {
-  int fd = ki_open("/test", O_RDWR | O_CREAT);
+  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))
       << "fcntl failed with: " << strerror(errno);
   ASSERT_EQ(FD_CLOEXEC, ki_fcntl_wrapper(fd, F_GETFD));
@@ skipping 10 matching lines @@
   int garbage[buffer_size];
 
   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);
+    int fd = ki_open(filename, O_WRONLY | O_CREAT, 0777);
     ASSERT_GT(fd, -1);
     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;
@@ 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);
+  int file1 = ki_open("/test1.txt", O_RDWR | O_CREAT, 0777);
   ASSERT_GT(file1, -1);
   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 40 matching lines @@
 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);
+  fd1 = ki_open("/example", O_RDONLY, 0);
   EXPECT_NE(-1, fd1);
   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);
+  fd2 = ki_open("../example", O_RDONLY, 0);
   EXPECT_NE(-1, fd2);
   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);
+  fd3 = ki_open("../test", O_CREAT | O_RDWR, 0777);
   EXPECT_NE(-1, fd3);
   EXPECT_EQ(-1, ki_fchdir(fd3));
   EXPECT_EQ(ENOTDIR, errno);
 
   EXPECT_EQ(0, ki_chdir("/foo"));
-  fd4 = ki_open("bar", O_RDONLY);
+  fd4 = ki_open("bar", O_RDONLY, 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);
@@ skipping 26 matching lines @@
   EXPECT_EQ(-1, ki_mkdir("/foo", S_IREAD | S_IWRITE));
   EXPECT_EQ(EEXIST, errno);
 
   // Delete "/foo"
   EXPECT_EQ(0, ki_rmdir("/foo"));
 
   // Recreate "/foo"
   EXPECT_EQ(0, ki_mkdir("/foo", S_IREAD | S_IWRITE));
 
   // Fail to open "/foo/bar"
-  EXPECT_EQ(-1, ki_open("/foo/bar", O_RDONLY));
+  EXPECT_EQ(-1, ki_open("/foo/bar", O_RDONLY, 0));
   EXPECT_EQ(ENOENT, errno);
 
   // Create bar "/foo/bar"
-  fd1 = ki_open("/foo/bar", O_RDWR | O_CREAT);
+  fd1 = ki_open("/foo/bar", O_RDWR | O_CREAT, 0777);
   ASSERT_NE(-1, fd1);
 
   // Open (optionally create) bar "/foo/bar"
-  fd2 = ki_open("/foo/bar", O_RDWR | O_CREAT);
+  fd2 = ki_open("/foo/bar", O_RDWR | O_CREAT, 0777);
   ASSERT_NE(-1, fd2);
 
   // Fail to exclusively create bar "/foo/bar"
-  EXPECT_EQ(-1, ki_open("/foo/bar", O_RDONLY | O_CREAT | O_EXCL));
+  EXPECT_EQ(-1, ki_open("/foo/bar", O_RDONLY | O_CREAT | O_EXCL, 0777));
   EXPECT_EQ(EEXIST, errno);
 
   // Write hello and world to same node with different descriptors
   // so that we overwrite each other
   EXPECT_EQ(5, ki_write(fd2, "WORLD", 5));
   EXPECT_EQ(5, ki_write(fd1, "HELLO", 5));
 
-  fd3 = ki_open("/foo/bar", O_RDONLY);
+  fd3 = ki_open("/foo/bar", O_RDONLY, 0);
   ASSERT_NE(-1, fd3);
 
   len = ki_read(fd3, text, sizeof(text));
   ASSERT_EQ(5, len);
   text[len] = 0;
   EXPECT_STREQ("HELLO", text);
   EXPECT_EQ(0, ki_close(fd1));
   EXPECT_EQ(0, ki_close(fd2));
 
-  fd1 = ki_open("/foo/bar", O_WRONLY | O_APPEND);
+  fd1 = ki_open("/foo/bar", O_WRONLY | O_APPEND, 0);
   ASSERT_NE(-1, fd1);
   EXPECT_EQ(5, ki_write(fd1, "WORLD", 5));
 
   len = ki_read(fd3, text, sizeof(text));
   ASSERT_EQ(5, len);
   text[len] = 0;
   EXPECT_STREQ("WORLD", text);
 
-  fd2 = ki_open("/foo/bar", O_RDONLY);
+  fd2 = ki_open("/foo/bar", O_RDONLY, 0);
   ASSERT_NE(-1, fd2);
   len = ki_read(fd2, text, sizeof(text));
   if (len > 0)
     text[len] = 0;
   EXPECT_EQ(10, len);
   EXPECT_STREQ("HELLOWORLD", text);
 }
 
 TEST_F(KernelProxyTest, MemMountFTruncate) {
   char text[1024];
   int fd1, fd2;
 
   // Open a file write only, write some text, then test that using a
   // separate file descriptor pointing to it that it is correctly
   // truncated at a specified number of bytes (2).
-  fd1 = ki_open("/trunc", O_WRONLY | O_CREAT);
+  fd1 = ki_open("/trunc", O_WRONLY | O_CREAT, 0777);
   ASSERT_NE(-1, fd1);
-  fd2 = ki_open("/trunc", O_RDONLY);
+  fd2 = ki_open("/trunc", O_RDONLY, 0);
   ASSERT_NE(-1, fd2);
   EXPECT_EQ(5, ki_write(fd1, "HELLO", 5));
   EXPECT_EQ(0, ki_ftruncate(fd1, 2));
   // Verify the remaining file (using fd2, opened pre-truncation) is
   // only 2 bytes in length.
   EXPECT_EQ(2, ki_read(fd2, text, sizeof(text)));
   EXPECT_EQ(0, ki_close(fd1));
   EXPECT_EQ(0, ki_close(fd2));
 }
 
 TEST_F(KernelProxyTest, MemMountTruncate) {
   char text[1024];
   int fd1;
 
   // Open a file write only, write some text, then test that by
   // referring to it by its path and truncating it we correctly truncate
   // it at a specified number of bytes (2).
-  fd1 = ki_open("/trunc", O_WRONLY | O_CREAT);
+  fd1 = ki_open("/trunc", O_WRONLY | O_CREAT, 0777);
   ASSERT_NE(-1, fd1);
   EXPECT_EQ(5, ki_write(fd1, "HELLO", 5));
   EXPECT_EQ(0, ki_close(fd1));
   EXPECT_EQ(0, ki_truncate("/trunc", 2));
   // Verify the text is only 2 bytes long with new file descriptor.
-  fd1 = ki_open("/trunc", O_RDONLY);
+  fd1 = ki_open("/trunc", O_RDONLY, 0);
   ASSERT_NE(-1, fd1);
   EXPECT_EQ(2, ki_read(fd1, text, sizeof(text)));
   EXPECT_EQ(0, ki_close(fd1));
 }
 
 TEST_F(KernelProxyTest, MemMountLseek) {
-  int fd = ki_open("/foo", O_CREAT | O_RDWR);
+  int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
   ASSERT_GT(fd, -1);
   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);
+  int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
   ASSERT_GT(fd, -1);
 
   EXPECT_EQ(9, ki_write(fd, "Some text", 9));
 
   int fd2 = ki_dup(fd);
   ASSERT_GT(fd2, -1);
 
   EXPECT_EQ(0, ki_close(fd));
   EXPECT_EQ(0, ki_close(fd2));
 }
 
 TEST_F(KernelProxyTest, MemMountDup) {
-  int fd = ki_open("/foo", O_CREAT | O_RDWR);
+  int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
   ASSERT_GT(fd, -1);
 
   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));
   ASSERT_EQ(9, ki_lseek(dup2_fd, 0, SEEK_CUR));
 
-  int new_fd = ki_open("/bar", O_CREAT | O_RDWR);
+  int new_fd = ki_open("/bar", O_CREAT | O_RDWR, 0777);
 
   ASSERT_EQ(fd, ki_dup2(new_fd, fd));
   // fd, new_fd -> "/bar"
   // dup_fd, dup2_fd -> "/foo"
 
   // We should still be able to write to dup_fd (i.e. it should not be closed).
   ASSERT_EQ(4, ki_write(dup_fd, "more", 4));
 
   ASSERT_EQ(0, ki_close(dup2_fd));
   // fd, new_fd -> "/bar"
   // dup_fd -> "/foo"
 
   ASSERT_EQ(dup_fd, ki_dup2(fd, dup_fd));
   // fd, new_fd, dup_fd -> "/bar"
 }
 
 TEST_F(KernelProxyTest, Lstat) {
-  int fd = ki_open("/foo", O_CREAT | O_RDWR);
+  int fd = ki_open("/foo", O_CREAT | O_RDWR, 0777);
   ASSERT_GT(fd, -1);
   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));
 
   EXPECT_EQ(-1, ki_lstat("/no-such-file", &buf));
   EXPECT_EQ(ENOENT, errno);
 }
 
+TEST_F(KernelProxyTest, OpenWithMode) {
+  int fd = ki_open("/foo", O_CREAT | O_RDWR, 0723);
+  ASSERT_GT(fd, -1);
+
+  struct stat buf;
+  EXPECT_EQ(0, ki_lstat("/foo", &buf));
+  EXPECT_EQ(0723, buf.st_mode & ~S_IFMT);
+}
+
 TEST_F(KernelProxyTest, UseAfterClose) {
-  int fd = ki_open("/dummy", O_CREAT | O_WRONLY);
+  int fd = ki_open("/dummy", O_CREAT | O_WRONLY, 0777);
   ASSERT_GT(fd, -1);
   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);
 }
 
 namespace {
 
 StringMap_t g_string_map;
@@ skipping 75 matching lines @@
   EXPECT_EQ("y", g_string_map["x"]);
 }
 
 TEST_F(KernelProxyMountTest, MountAndIoctl) {
   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);
 
-  int fd = ki_open(path, O_RDONLY);
+  int fd = ki_open(path, O_RDONLY, 0);
   ASSERT_GT(fd, -1);
 
   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,
@@ skipping 53 matching lines @@
 
     return 0;
   }
 
  private:
   int node_mmap_count_;
 };
 
 class KernelProxyMMapTest_Filesystem : public Filesystem {
  public:
-  virtual Error Open(const Path& path, int mode, ScopedNode* out_node) {
+  virtual Error OpenWithMode(const Path& path, int open_flags,
+                             mode_t mode, ScopedNode* out_node) {
     out_node->reset(new KernelProxyMMapTest_Node(this));
     return 0;
   }
 
   virtual Error OpenResource(const Path& path, ScopedNode* out_node) {
     out_node->reset(NULL);
     return ENOSYS;
   }
   virtual Error Unlink(const Path& path) { return ENOSYS; }
   virtual Error Mkdir(const Path& path, int permissions) { return ENOSYS; }
@@ skipping 25 matching lines @@
 
  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);
+  int fd = ki_open("/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 61 matching lines @@
 
  private:
   KernelProxyErrorTest_KernelProxy kp_;
 };
 
 }  // namespace
 
 TEST_F(KernelProxyErrorTest, WriteError) {
   ScopedRef<MockFs> mock_fs(fs());
   ScopedRef<MockNode> mock_node(new MockNode(&*mock_fs));
-  EXPECT_CALL(*mock_fs, Open(_, _, _))
-      .WillOnce(DoAll(SetArgPointee<2>(mock_node), Return(0)));
+  EXPECT_CALL(*mock_fs, OpenWithMode(_, _, _, _))
+      .WillOnce(DoAll(SetArgPointee<3>(mock_node), Return(0)));
 
   EXPECT_CALL(*mock_node, Write(_, _, _, _))
       .WillOnce(DoAll(SetArgPointee<3>(0),  // Wrote 0 bytes.
                       Return(1234)));       // Returned error 1234.
 
   EXPECT_CALL(*mock_node, Destroy()).Times(1);
 
-  int fd = ki_open("/dummy", O_WRONLY);
+  int fd = ki_open("/dummy", O_WRONLY, 0);
   EXPECT_NE(0, fd);
 
   char buf[20];
   EXPECT_EQ(-1, ki_write(fd, &buf[0], 20));
   // The Filesystem should be able to return whatever error it wants and have it
   // propagate through.
   EXPECT_EQ(1234, errno);
 }
 
 TEST_F(KernelProxyErrorTest, ReadError) {
   ScopedRef<MockFs> mock_fs(fs());
   ScopedRef<MockNode> mock_node(new MockNode(&*mock_fs));
-  EXPECT_CALL(*mock_fs, Open(_, _, _))
-      .WillOnce(DoAll(SetArgPointee<2>(mock_node), Return(0)));
+  EXPECT_CALL(*mock_fs, OpenWithMode(_, _, _, _))
+      .WillOnce(DoAll(SetArgPointee<3>(mock_node), Return(0)));
 
   EXPECT_CALL(*mock_node, Read(_, _, _, _))
       .WillOnce(DoAll(SetArgPointee<3>(0),  // Read 0 bytes.
                       Return(1234)));       // Returned error 1234.
 
   EXPECT_CALL(*mock_node, Destroy()).Times(1);
 
-  int fd = ki_open("/dummy", O_RDONLY);
+  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);
 }