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

native_client_sdk/src/tests/nacl_io_test/tty_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 <errno.h>
 #include <fcntl.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
 #include <sys/stat.h>
@@ skipping 170 matching lines @@
     return -3;  // error
   return 1;     // readable
 }
 
 TEST_F(TtyTest, TtySelect) {
   struct timeval timeout;
   fd_set readfds;
   fd_set writefds;
   fd_set errorfds;
 
-  int tty_fd = ki_open("/dev/tty", O_RDONLY);
+  int tty_fd = ki_open("/dev/tty", O_RDONLY, 0);
   ASSERT_GT(tty_fd, 0) << "tty open failed: " << errno;
 
   FD_ZERO(&readfds);
   FD_ZERO(&errorfds);
   FD_SET(tty_fd, &readfds);
   FD_SET(tty_fd, &errorfds);
   // 10 millisecond timeout
   timeout.tv_sec = 0;
   timeout.tv_usec = 10 * 1000;
   // Should timeout when no input is available.
@@ skipping 22 matching lines @@
   ASSERT_EQ(IsReadable(tty_fd), 0);
   ASSERT_EQ(0, TtyWrite(tty_fd, "input:\n"));
 
   // TTY should now be readable
   ASSERT_EQ(1, IsReadable(tty_fd));
 
   ki_close(tty_fd);
 }
 
 TEST_F(TtyTest, TtyICANON) {
-  int tty_fd = ki_open("/dev/tty", O_RDONLY);
+  int tty_fd = ki_open("/dev/tty", O_RDONLY, 0);
 
   ASSERT_EQ(0, IsReadable(tty_fd));
 
   struct termios tattr;
   ki_tcgetattr(tty_fd, &tattr);
   tattr.c_lflag &= ~(ICANON | ECHO); /* Clear ICANON and ECHO. */
   ki_tcsetattr(tty_fd, TCSAFLUSH, &tattr);
 
   ASSERT_EQ(0, IsReadable(tty_fd));
 
@@ skipping 12 matching lines @@
   ASSERT_EQ(0, IsReadable(tty_fd));
 }
 
 static int g_received_signal;
 
 static void sighandler(int sig) { g_received_signal = sig; }
 
 TEST_F(TtyTest, WindowSize) {
   // Get current window size
   struct winsize old_winsize = {0};
-  int tty_fd = ki_open("/dev/tty", O_RDONLY);
+  int tty_fd = ki_open("/dev/tty", O_RDONLY, 0);
   ASSERT_EQ(0, ki_ioctl_wrapper(tty_fd, TIOCGWINSZ, &old_winsize));
 
   // Install signal handler
   sighandler_t new_handler = sighandler;
   sighandler_t old_handler = ki_signal(SIGWINCH, new_handler);
   ASSERT_NE(SIG_ERR, old_handler) << "signal return error: " << errno;
 
   g_received_signal = 0;
 
   // Set a new windows size
@@ skipping 27 matching lines @@
   struct winsize winsize;
   winsize.ws_col = 100;
   winsize.ws_row = 200;
   ki_ioctl_wrapper(*tty_fd, TIOCSWINSZ, &winsize);
   return NULL;
 }
 
 TEST_F(TtyTest, ResizeDuringSelect) {
   // Test that a window resize during a call
   // to select(3) will cause it to fail with EINTR.
-  int tty_fd = ki_open("/dev/tty", O_RDONLY);
+  int tty_fd = ki_open("/dev/tty", O_RDONLY, 0);
 
   fd_set readfds;
   fd_set errorfds;
   FD_ZERO(&readfds);
   FD_ZERO(&errorfds);
   FD_SET(tty_fd, &readfds);
   FD_SET(tty_fd, &errorfds);
 
   pthread_t resize_thread;
   pthread_create(&resize_thread, NULL, resize_thread_main, &tty_fd);
@@ skipping 14 matching lines @@
 }
 
 /*
  * Sleep for 50ms then send some input to the /dev/tty.
  */
 static void* input_thread_main(void* arg) {
   TtyTest* thiz = static_cast<TtyTest*>(arg);
 
   usleep(50 * 1000);
 
-  int fd = ki_open("/dev/tty", O_RDONLY);
+  int fd = ki_open("/dev/tty", O_RDONLY, 0);
   thiz->TtyWrite(fd, "test\n");
   return NULL;
 }
 
 TEST_F(TtyTest, InputDuringSelect) {
   // Test that input which occurs while in select causes
   // select to return.
-  int tty_fd = ki_open("/dev/tty", O_RDONLY);
+  int tty_fd = ki_open("/dev/tty", O_RDONLY, 0);
 
   fd_set readfds;
   fd_set errorfds;
   FD_ZERO(&readfds);
   FD_ZERO(&errorfds);
   FD_SET(tty_fd, &readfds);
   FD_SET(tty_fd, &errorfds);
 
   pthread_t resize_thread;
   pthread_create(&resize_thread, NULL, input_thread_main, this);
 
   struct timeval timeout;
   timeout.tv_sec = 20;
   timeout.tv_usec = 0;
 
   int rtn = ki_select(tty_fd + 1, &readfds, NULL, &errorfds, &timeout);
   pthread_join(resize_thread, NULL);
 
   ASSERT_EQ(1, rtn);
 }
 
 }  // namespace