[NaCl SDK] nacl_io: Add initial implementations of kill and signal

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>
 #include <poll.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/time.h>
+#include <unistd.h>
 
 #include <iterator>
 #include <string>
 
+#include "nacl_io/dbgprint.h"
 #include "nacl_io/host_resolver.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/kernel_wrap_real.h"
 #include "nacl_io/mount.h"
 #include "nacl_io/mount_dev.h"
 #include "nacl_io/mount_html5fs.h"
 #include "nacl_io/mount_http.h"
 #include "nacl_io/mount_mem.h"
 #include "nacl_io/mount_node.h"
 #include "nacl_io/mount_node_tcp.h"
 #include "nacl_io/mount_node_udp.h"
 #include "nacl_io/mount_passthrough.h"
 #include "nacl_io/osmman.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/osstat.h"
 #include "nacl_io/path.h"
 #include "nacl_io/pepper_interface.h"
 #include "nacl_io/typed_mount_factory.h"
 #include "sdk_util/auto_lock.h"
 #include "sdk_util/ref_object.h"
 
 #ifndef MAXPATHLEN
 #define MAXPATHLEN 256
 #endif
 
 namespace nacl_io {
 
-KernelProxy::KernelProxy() : dev_(0), ppapi_(NULL) {
+KernelProxy::KernelProxy() : dev_(0), ppapi_(NULL),
+                             sigwinch_handler_(SIG_IGN) {
 }
 
 KernelProxy::~KernelProxy() {
   // Clean up the MountFactories.
   for (MountFactoryMap_t::iterator i = factories_.begin();
        i != factories_.end();
        ++i) {
     delete i->second;
   }
 
@@ skipping 644 matching lines @@
 
   error = handle->node()->Tcsetattr(optional_actions, termios_p);
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
+int KernelProxy::kill(pid_t pid, int sig) {
+  // Currently we don't even pretend that other processes exist
+  // so we can only send a signal to outselves.  For kill(2)
+  // pid 0 means the current process group and -1 means all the
+  // processes we have permission to send signals to.
+  if (pid != getpid() && pid != -1 && pid != 0) {
+    errno = ESRCH;
+    return -1;
+  }
+
+  dbgprintf("raising event ...\n");
+  // Raise an event so that select/poll get interrupted.
+  RaiseEvent(POLLERR);
+  switch (sig) {
+    case SIGWINCH:
+      if (sigwinch_handler_ != SIG_IGN)
+        sigwinch_handler_(SIGWINCH);
+      break;
+
+    case SIGUSR1:
+    case SIGUSR2:
+      break;
+
+    default:
+      errno = EINVAL;
+      return -1;
+  }
+
+  return 0;
+}
+
+sighandler_t KernelProxy::sigset(int signum, sighandler_t handler) {
+  switch (signum) {
+    // Handled signals.
+    case SIGWINCH: {
+      sighandler_t old_value = sigwinch_handler_;
+      if (handler == SIG_DFL)
+        handler = SIG_IGN;
+      sigwinch_handler_ = handler;
+      return old_value;
+    }
+
+    // Known signals
+    case SIGHUP:
+    case SIGINT:
+    case SIGKILL:
+    case SIGPIPE:
+    case SIGPOLL:
+    case SIGPROF:
+    case SIGTERM:
+    case SIGCHLD:
+    case SIGURG:
+    case SIGFPE:
+    case SIGILL:
+    case SIGQUIT:
+    case SIGSEGV:
+    case SIGTRAP:
+      if (handler == SIG_DFL)
+        return SIG_DFL;
+      break;
+  }
+
+  errno = EINVAL;
+  return SIG_ERR;
+}
+
 #ifdef PROVIDES_SOCKET_API
 
 int KernelProxy::select(int nfds, fd_set* readfds, fd_set* writefds,
                         fd_set* exceptfds, struct timeval* timeout) {
   ScopedEventListener listener(new EventListener);
+
   std::vector<struct pollfd> fds;
 
   fd_set readout, writeout, exceptout;
 
   FD_ZERO(&readout);
   FD_ZERO(&writeout);
   FD_ZERO(&exceptout);
 
   int fd;
   size_t event_cnt = 0;
@@ skipping 65 matching lines @@
       if ((timeout->tv_sec < 0) || (timeout->tv_sec >= (INT_MAX / 1000)) ||
           (timeout->tv_usec < 0) || (timeout->tv_usec >= 1000000) ||
           (ms < 0) || (ms >= INT_MAX)) {
         errno = EINVAL;
         return -1;
       }
 
       ms_timeout = static_cast<int>(ms);
     }
 
+    // Add a special node to listen for events
+    // coming from the KernelProxy itself (kill will
+    // generated a SIGERR event).
+    listener->Track(-1, ScopedKernelProxy(this), POLLERR, -1);

[binji, 2013/08/22 18:09:36]

OK, I see why you want to use the kernel proxy for this, but I'd prefer if you
created a dummy EventEmitter class that the kernel proxy owns instead. That will
keep you from having to make the kernel proxy refcounted, an event emitter, etc.
which is pretty ugly, IMO.

[Sam Clegg, 2013/08/22 19:52:25]

Done.

+    event_track += 1;
+
     events.resize(event_track);
+
+    bool interrupted = false;
     listener->Wait(events.data(), event_track, ms_timeout, &ready_cnt);
     for (fd = 0; static_cast<int>(fd) < ready_cnt; fd++) {
+      if (events[fd].user_data == static_cast<uint64_t>(-1)) {
+        if (events[fd].events & POLLERR) {
+          interrupted = true;
+        }
+        continue;
+      }
+
       if (events[fd].events & POLLIN) {
         FD_SET(events[fd].user_data, &readout);
         event_cnt++;
       }
 
       if (events[fd].events & POLLOUT) {
         FD_SET(events[fd].user_data, &writeout);
         event_cnt++;
       }
 
       if (events[fd].events & (POLLERR | POLLHUP)) {
         FD_SET(events[fd].user_data, &exceptout);
         event_cnt++;
       }
     }
+
+    if (0 == event_cnt && interrupted) {
+      errno = EINTR;
+      return -1;
+    }
   }
 
   // Copy out the results
   if (readfds != NULL)
     *readfds = readout;
 
   if (writefds != NULL)
     *writefds = writeout;
 
   if (exceptfds != NULL)
     *exceptfds = exceptout;
 
   return event_cnt;
 }
 
 int KernelProxy::poll(struct pollfd *fds, nfds_t nfds, int timeout) {
   ScopedEventListener listener(new EventListener);
+  listener->Track(-1, ScopedKernelProxy(this), POLLERR, 0);
 
   int index;
   size_t event_cnt = 0;
-  size_t event_track = 0;
+  size_t event_track = 1;
   for (index = 0; static_cast<nfds_t>(index) < nfds; index++) {
     ScopedKernelHandle handle;
     struct pollfd* info = &fds[index];
     Error err = AcquireHandle(info->fd, &handle);
 
     // If the node isn't open, or somehow invalid, mark it so.
     if (err != 0) {
       info->revents = POLLNVAL;
       event_cnt++;
       continue;
@@ skipping 14 matching lines @@
       continue;
     }
     event_track++;
   }
 
   // If nothing is signaled, then we must wait.
   if (0 == event_cnt) {
     std::vector<EventData> events;
     int ready_cnt;
 
+    bool interrupted = false;
     events.resize(event_track);
     listener->Wait(events.data(), event_track, timeout, &ready_cnt);
     for (index = 0; index < ready_cnt; index++) {
       struct pollfd* info = &fds[events[index].user_data];
+      if (!info) {
+        interrupted = true;
+        continue;
+      }
 
       info->revents = events[index].events;
       event_cnt++;
     }
+    if (0 == event_cnt && interrupted) {
+      errno = EINTR;
+      return -1;
+    }
   }
 
   return event_cnt;
 }
 
 
 
 // Socket Functions
 int KernelProxy::accept(int fd, struct sockaddr* addr, socklen_t* len) {
   if (NULL == addr || NULL == len) {
@@ skipping 352 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io