X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fprocess.c;h=0aa18422d08353a4afe76fcd0eb3db3f7ac6908a;hb=3efb60637b9a6741e7e5b7f04e4daa4d2464d8b3;hp=55092f503653bd6261dbfe1d6ea66a2812a3ea85;hpb=279c9e030818e039bb1c26be76e2cc1e8f6b13a6;p=sliver-openvswitch.git

diff --git a/lib/process.c b/lib/process.c
index 55092f503..0aa18422d 100644
--- a/lib/process.c
+++ b/lib/process.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
 
 #include <config.h>
 #include "process.h"
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
@@ -82,9 +81,7 @@ process_init(void)
     inited = true;
 
     /* Create notification pipe. */
-    xpipe(fds);
-    set_nonblocking(fds[0]);
-    set_nonblocking(fds[1]);
+    xpipe_nonblocking(fds);
 
     /* Set up child termination signal handler. */
     memset(&sa, 0, sizeof sa);
@@ -161,7 +158,7 @@ process_register(const char *name, pid_t pid)
     struct process *p;
     const char *slash;
 
-    assert(sigchld_is_blocked());
+    ovs_assert(sigchld_is_blocked());
 
     p = xzalloc(sizeof *p);
     p->pid = pid;
@@ -310,7 +307,7 @@ process_exited(struct process *p)
 int
 process_status(const struct process *p)
 {
-    assert(p->exited);
+    ovs_assert(p->exited);
     return p->status;
 }
 
@@ -351,9 +348,15 @@ process_status_msg(int status)
     if (WIFEXITED(status)) {
         ds_put_format(&ds, "exit status %d", WEXITSTATUS(status));
     } else if (WIFSIGNALED(status)) {
-        ds_put_format(&ds, "killed (%s)", signal_name(WTERMSIG(status)));
+        char namebuf[SIGNAL_NAME_BUFSIZE];
+
+        ds_put_format(&ds, "killed (%s)",
+                      signal_name(WTERMSIG(status), namebuf, sizeof namebuf));
     } else if (WIFSTOPPED(status)) {
-        ds_put_format(&ds, "stopped (%s)", signal_name(WSTOPSIG(status)));
+        char namebuf[SIGNAL_NAME_BUFSIZE];
+
+        ds_put_format(&ds, "stopped (%s)",
+                      signal_name(WSTOPSIG(status), namebuf, sizeof namebuf));
     } else {
         ds_put_format(&ds, "terminated abnormally (%x)", status);
     }
@@ -403,20 +406,28 @@ process_search_path(const char *name)
 /* process_run_capture() and supporting functions. */
 
 struct stream {
+    size_t max_size;
     struct ds log;
     int fds[2];
 };
 
 static int
-stream_open(struct stream *s)
+stream_open(struct stream *s, size_t max_size)
 {
+    int error;
+
+    s->max_size = max_size;
     ds_init(&s->log);
     if (pipe(s->fds)) {
         VLOG_WARN("failed to create pipe: %s", strerror(errno));
         return errno;
     }
-    set_nonblocking(s->fds[0]);
-    return 0;
+    error = set_nonblocking(s->fds[0]);
+    if (error) {
+        close(s->fds[0]);
+        close(s->fds[1]);
+    }
+    return error;
 }
 
 static void
@@ -443,9 +454,9 @@ stream_read(struct stream *s)
                 }
                 break;
             }
-        } else if (s->log.length > PROCESS_MAX_CAPTURE) {
-            VLOG_WARN("subprocess output overflowed %d-byte buffer",
-                      PROCESS_MAX_CAPTURE);
+        } else if (s->log.length > s->max_size) {
+            VLOG_WARN("subprocess output overflowed %zu-byte buffer",
+                      s->max_size);
             break;
         }
     }
@@ -480,7 +491,7 @@ stream_close(struct stream *s)
  * '*status'.
  *
  * If 'stdout_log' is nonnull, then the subprocess's output to stdout (up to a
- * limit of PROCESS_MAX_CAPTURE bytes) is captured in a memory buffer, which
+ * limit of 'log_max' bytes) is captured in a memory buffer, which
  * when this function returns 0 is stored as a null-terminated string in
  * '*stdout_log'.  The caller is responsible for freeing '*stdout_log' (by
  * passing it to free()).  When this function returns an error, '*stdout_log'
@@ -490,7 +501,7 @@ stream_close(struct stream *s)
  * that it captures the subprocess's output to stderr. */
 int
 process_run_capture(char **argv, char **stdout_log, char **stderr_log,
-                    int *status)
+                    size_t max_log, int *status)
 {
     struct stream s_stdout, s_stderr;
     sigset_t oldsigs;
@@ -510,12 +521,12 @@ process_run_capture(char **argv, char **stdout_log, char **stderr_log,
         return error;
     }
 
-    error = stream_open(&s_stdout);
+    error = stream_open(&s_stdout, max_log);
     if (error) {
         return error;
     }
 
-    error = stream_open(&s_stderr);
+    error = stream_open(&s_stderr, max_log);
     if (error) {
         stream_close(&s_stdout);
         return error;
@@ -635,7 +646,7 @@ sigchld_is_blocked(void)
 {
     sigset_t sigs;
 
-    xsigprocmask(SIG_SETMASK, NULL, &sigs);
+    xpthread_sigmask(SIG_SETMASK, NULL, &sigs);
     return sigismember(&sigs, SIGCHLD);
 }
 
@@ -646,11 +657,11 @@ block_sigchld(sigset_t *oldsigs)
 
     sigemptyset(&sigchld);
     sigaddset(&sigchld, SIGCHLD);
-    xsigprocmask(SIG_BLOCK, &sigchld, oldsigs);
+    xpthread_sigmask(SIG_BLOCK, &sigchld, oldsigs);
 }
 
 static void
 unblock_sigchld(const sigset_t *oldsigs)
 {
-    xsigprocmask(SIG_SETMASK, oldsigs, NULL);
+    xpthread_sigmask(SIG_SETMASK, oldsigs, NULL);
 }