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

native_client_sdk/src/libraries/nacl_io/kernel_proxy.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 "nacl_io/kernel_proxy.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
@@ skipping 86 matching lines @@
   rtn = CreateFsNode(root_fs);
   if (rtn != 0)
     assert(false);
 
   rtn = CreateFsNode(dev_fs_);
   if (rtn != 0)
     assert(false);
 
   // Open the first three in order to get STDIN, STDOUT, STDERR
   int fd;
-  fd = open("/dev/stdin", O_RDONLY);
+  fd = open("/dev/stdin", O_RDONLY, 0);
   assert(fd == 0);
   if (fd < 0)
     rtn = errno;
 
-  fd = open("/dev/stdout", O_WRONLY);
+  fd = open("/dev/stdout", O_WRONLY, 0);
   assert(fd == 1);
   if (fd < 0)
     rtn = errno;
 
-  fd = open("/dev/stderr", O_WRONLY);
+  fd = open("/dev/stderr", O_WRONLY, 0);
   assert(fd == 2);
   if (fd < 0)
     rtn = errno;
 
 #ifdef PROVIDES_SOCKET_API
   host_resolver_.Init(ppapi_);
 #endif
 
   FsInitArgs args;
   args.dev = dev_++;
@@ skipping 64 matching lines @@
   ScopedKernelHandle handle(new KernelHandle(fs, node));
   error = handle->Init(O_RDONLY);
   if (error) {
     errno = error;
     return -1;
   }
 
   return AllocateFD(handle, path);
 }
 
-int KernelProxy::open(const char* path, int open_flags) {
+int KernelProxy::open(const char* path, int open_flags, mode_t mode) {
   ScopedFilesystem fs;
   ScopedNode node;
 
-  Error error = AcquireFsAndNode(path, open_flags, &fs, &node);
+  Error error = AcquireFsAndNode(path, open_flags, mode, &fs, &node);
   if (error) {
     errno = error;
     return -1;
   }
 
   ScopedKernelHandle handle(new KernelHandle(fs, node));
   error = handle->Init(open_flags);
   if (error) {
     errno = error;
     return -1;
@@ skipping 100 matching lines @@
 
 char* KernelProxy::getwd(char* buf) {
   if (NULL == buf) {
     errno = EFAULT;
     return NULL;
   }
   return getcwd(buf, MAXPATHLEN);
 }
 
 int KernelProxy::chmod(const char* path, mode_t mode) {
-  int fd = KernelProxy::open(path, O_RDONLY);
+  int fd = KernelProxy::open(path, O_RDONLY, mode);
   if (-1 == fd)
     return -1;
 
   int result = fchmod(fd, mode);
   close(fd);
   return result;
 }
 
 int KernelProxy::chown(const char* path, uid_t owner, gid_t group) {
   return 0;
@@ skipping 43 matching lines @@
   error = fs->Rmdir(rel);
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
 int KernelProxy::stat(const char* path, struct stat* buf) {
-  int fd = open(path, O_RDONLY);
+  int fd = open(path, O_RDONLY, 0);
   if (-1 == fd)
     return -1;
 
   int result = fstat(fd, buf);
   close(fd);
   return result;
 }
 
 int KernelProxy::mount(const char* source,
                        const char* target,
@@ skipping 309 matching lines @@
   error = fs->Unlink(rel);
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
 int KernelProxy::truncate(const char* path, off_t len) {
-  int fd = KernelProxy::open(path, O_WRONLY);
+  int fd = KernelProxy::open(path, O_WRONLY, 0);
   if (-1 == fd)
     return -1;
 
   int result = ftruncate(fd, len);
   close(fd);
   return result;
 }
 
 int KernelProxy::lstat(const char* path, struct stat* buf) {
   return stat(path, buf);
@@ skipping 985 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io