Make M-x shell work in emacs.

ports/nacl-spawn/nacl_spawn.cc

 // Copyright (c) 2014 The Native Client Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Emulates spawning/waiting process by asking JavaScript to do so.
 
 // Include quoted spawn.h first so we can build in the presence of an installed
 // copy of nacl-spawn.
 #define IN_NACL_SPAWN_CC
 #include "spawn.h"
@@ skipping 336 matching lines @@
     } else if (S_ISDIR(st.st_mode)) {
       // TODO(bradnelson): Land nacl_io ioctl to support this.
     } else if (S_ISCHR(st.st_mode)) {
       // Unsupported.
     } else if (S_ISBLK(st.st_mode)) {
       // Unsupported.
     } else if (S_ISFIFO(st.st_mode)) {
       char entry[100];
       snprintf(entry, sizeof entry,
           "NACL_SPAWN_FD_SETUP_%d=pipe:%d:%d:%d", count++, fd,
-          static_cast<int>(st.st_ino), st.st_rdev == O_WRONLY);
+          static_cast<int>(st.st_ino),
+          (st.st_rdev & O_WRONLY) == O_WRONLY);
       nspawn_array_appendstring(envs_var, entry);
     } else if (S_ISLNK(st.st_mode)) {
       // Unsupported.
     } else if (S_ISSOCK(st.st_mode)) {
       // Unsupported.
     }
   }
   return 0;
 }
 
@@ skipping 311 matching lines @@
   if (data) {
     *data = static_cast<char*>(malloc(result_len + 1));
     assert(*data);
     memcpy(*data, result, result_len);
     (*data)[result_len] = '\0';
   }
   nspawn_var_release(result_var);
   nspawn_var_release(result_dict_var);
 }
 
-// Create a javascript pipe. pipefd[0] will be the read end of the pipe
-// and pipefd[1] the write end of the pipe.
-int nacl_spawn_pipe(int pipefd[2]) {
+// Same as above with flags.
+int nacl_spawn_pipe2(int pipefd[2], int flags) {
   if (pipefd == NULL) {
     errno = EFAULT;
     return -1;
   }
 
   struct PP_Var req_var = nspawn_dict_create();
   nspawn_dict_setstring(req_var, "command", "nacl_apipe");
 
   struct PP_Var result_var = nspawn_send_request(req_var);
   int id = nspawn_dict_getint(result_var, "pipe_id");
   nspawn_var_release(result_var);
 
   int read_fd;
   int write_fd;
   char path[100];
   sprintf(path, "/apipe/%d", id);
-  read_fd = open(path, O_RDONLY);
-  write_fd = open(path, O_WRONLY);
+  // The only flag supported is O_NONBLOCK.
+  // TODO(bradnelson): Drop this once nacl_io does the right thing:
+  // https://bugs.chromium.org/p/webports/issues/detail?id=247
+  // https://bugs.chromium.org/p/webports/issues/detail?id=248
+  assert(flags == 0 || flags == O_NONBLOCK);
+  read_fd = open(path, O_RDONLY | flags);
+  write_fd = open(path, O_WRONLY | flags);
   if (read_fd < 0 || write_fd < 0) {
     if (read_fd >= 0) {
       close(read_fd);
     }
     if (write_fd >= 0) {
       close(write_fd);
     }
     return -1;
   }
   pipefd[0] = read_fd;
   pipefd[1] = write_fd;
 
   return 0;
 }
 
+// Create a javascript pipe. pipefd[0] will be the read end of the pipe
+// and pipefd[1] the write end of the pipe.
+int nacl_spawn_pipe(int pipefd[2]) {
+  return nacl_spawn_pipe2(pipefd, 0);
+}
+
 void nacl_spawn_vfork_before(void) {
   assert(!vforking);
   vforking = 1;
   stash_file_descriptors();
 }
 
 pid_t nacl_spawn_vfork_after(int jmping) {
   if (jmping) {
     unstash_file_descriptors();
     vforking = 0;
@@ skipping 90 matching lines @@
 }
 
 int execlpe(const char *path, const char *arg, ...) {  /* char* const envp[] */
   NSPAWN_LOG("execlpe: %s", path);
   VARG_TO_ARGV_ENVP;
   // TODO(bradnelson): Limit path resolution to 'p' variants.
   return spawnve_impl(P_OVERLAY, path, argv, envp);
 }
 
 };  // extern "C"