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

native_client_sdk/src/tests/nacl_io_test/fuse_fs_test.cc

 // Copyright 2013 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 <fcntl.h>
 
 #include <gtest/gtest.h>
 
 #include <string>
 #include <vector>
@@ skipping 18 matching lines @@
 };
 
 // Implementation of a simple flat memory filesystem.
 struct File {
   std::string name;
   std::vector<uint8_t> data;
 };
 
 typedef std::vector<File> Files;
 Files g_files;
+mode_t last_create_mode = 0666;
 
 bool IsValidPath(const char* path) {
   if (path == NULL)
     return false;
 
   if (strlen(path) <= 1)
     return false;
 
   if (path[0] != '/')
     return false;
@@ skipping 18 matching lines @@
 
   if (strcmp(path, "/") == 0) {
     stbuf->st_mode = S_IFDIR | 0755;
     return 0;
   }
 
   File* file = FindFile(path);
   if (file == NULL)
     return -ENOENT;
 
-  stbuf->st_mode = S_IFREG | 0666;
+  stbuf->st_mode = S_IFREG | last_create_mode;
   stbuf->st_size = file->data.size();
   return 0;
 }
 
 int testfs_readdir(const char* path,
                    void* buf,
                    fuse_fill_dir_t filler,
                    off_t offset,
                    struct fuse_file_info*) {
   if (strcmp(path, "/") != 0)
     return -ENOENT;
 
   filler(buf, ".", NULL, 0);
   filler(buf, "..", NULL, 0);
   for (Files::iterator iter = g_files.begin(); iter != g_files.end(); ++iter) {
     filler(buf, iter->name.c_str(), NULL, 0);
   }
   return 0;
 }
 
-int testfs_create(const char* path, mode_t, struct fuse_file_info* fi) {
+int testfs_create(const char* path, mode_t mode, struct fuse_file_info* fi) {
   if (!IsValidPath(path))
     return -ENOENT;
 
   File* file = FindFile(path);
   if (file != NULL) {
     if (fi->flags & O_EXCL)
       return -EEXIST;
   } else {
     g_files.push_back(File());
     file = &g_files.back();
     file->name = &path[1];  // Skip initial /
   }
+  last_create_mode = mode;
 
   return 0;
 }
 
 int testfs_open(const char* path, struct fuse_file_info*) {
   // open is only called to open an existing file, otherwise create is
   // called. We don't need to do any additional work here, the path will be
   // passed to any other operations.
   return FindFile(path) != NULL;
 }
@@ skipping 104 matching lines @@
   ASSERT_EQ(strlen(hello_world), bytes_read);
   ASSERT_STREQ(hello_world, buffer);
 
   // Try to read past the end of the file.
   attr.offs = strlen(hello_world) - 7;
   ASSERT_EQ(0, node->Read(attr, &buffer[0], sizeof(buffer), &bytes_read));
   ASSERT_EQ(7, bytes_read);
   ASSERT_STREQ("World!\n", buffer);
 }
 
+TEST_F(FuseFsTest, CreateWithMode) {
+  ScopedNode node;
+  struct stat statbuf;
+
+  ASSERT_EQ(0, fs_.OpenWithMode(Path("/hello"),
+                                O_RDWR | O_CREAT, 0723, &node));
+  EXPECT_EQ(0, node->GetStat(&statbuf));
+  EXPECT_EQ(S_IFREG, statbuf.st_mode & S_IFMT);
+  EXPECT_EQ(0723, statbuf.st_mode & ~S_IFMT);
+}
+
 TEST_F(FuseFsTest, CreateAndWrite) {
   ScopedNode node;
   ASSERT_EQ(0, fs_.Open(Path("/foobar"), O_RDWR | O_CREAT, &node));
 
   HandleAttr attr;
   const char message[] = "Something interesting";
   int bytes_written;
   ASSERT_EQ(0, node->Write(attr, &message[0], strlen(message), &bytes_written));
   ASSERT_EQ(bytes_written, strlen(message));
 
@@ skipping 89 matching lines @@
 
 void KernelProxyFuseTest::TearDown() {
   nacl_io_unregister_fs_type("flatfs");
   ki_uninit();
 }
 
 }  // namespace
 
 TEST_F(KernelProxyFuseTest, Basic) {
   // Write a file.
-  int fd = ki_open("/hello", O_WRONLY | O_CREAT);
+  int fd = ki_open("/hello", O_WRONLY | O_CREAT, 0777);
   ASSERT_GT(fd, -1);
   ASSERT_EQ(sizeof(hello_world),
             ki_write(fd, hello_world, sizeof(hello_world)));
   EXPECT_EQ(0, ki_close(fd));
 
   // Then read it back in.
-  fd = ki_open("/hello", O_RDONLY);
+  fd = ki_open("/hello", O_RDONLY, 0);
   ASSERT_GT(fd, -1);
 
   char buffer[30];
   memset(buffer, 0, sizeof(buffer));
   ASSERT_EQ(sizeof(hello_world), ki_read(fd, buffer, sizeof(buffer)));
   EXPECT_STREQ(hello_world, buffer);
   EXPECT_EQ(0, ki_close(fd));
 }