netdev-dpdk: fix mbuf leaks

[cascardo/ovs.git] / lib / fatal-signal.c

diff --git a/lib/fatal-signal.c b/lib/fatal-signal.c
index 40daf5a..62acea0 100644 (file)
--- a/lib/fatal-signal.c
+++ b/lib/fatal-signal.c
@@ -30,7 +30,7 @@
 #include "signals.h"
 #include "socket-util.h"
 #include "util.h"
-#include "vlog.h"
+#include "openvswitch/vlog.h"
 
 #include "type-props.h"
 
@@ -41,7 +41,11 @@
 VLOG_DEFINE_THIS_MODULE(fatal_signal);
 
 /* Signals to catch. */
+#ifndef _WIN32
 static const int fatal_signals[] = { SIGTERM, SIGINT, SIGHUP, SIGALRM };
+#else
+static const int fatal_signals[] = { SIGTERM };
+#endif
 
 /* Hooks to call upon catching a signal */
 struct hook {
@@ -57,10 +61,16 @@ static size_t n_hooks;
 static int signal_fds[2];
 static volatile sig_atomic_t stored_sig_nr = SIG_ATOMIC_MAX;
 
-static pthread_mutex_t mutex;
+#ifdef _WIN32
+static HANDLE wevent;
+#endif
+
+static struct ovs_mutex mutex;
 
-static void atexit_handler(void);
 static void call_hooks(int sig_nr);
+#ifdef _WIN32
+static BOOL WINAPI ConsoleHandlerRoutine(DWORD dwCtrlType);
+#endif
 
 /* Initializes the fatal signal handling module.  Calling this function is
  * optional, because calling any other function in the module will also
@@ -72,21 +82,28 @@ fatal_signal_init(void)
     static bool inited = false;
 
     if (!inited) {
-        pthread_mutexattr_t attr;
         size_t i;
 
         assert_single_threaded();
         inited = true;
 
-        xpthread_mutexattr_init(&attr);
-        xpthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-        xpthread_mutex_init(&mutex, &attr);
-        xpthread_mutexattr_destroy(&attr);
-
+        ovs_mutex_init_recursive(&mutex);
+#ifndef _WIN32
         xpipe_nonblocking(signal_fds);
+#else
+        wevent = CreateEvent(NULL, TRUE, FALSE, NULL);
+        if (!wevent) {
+            char *msg_buf = ovs_lasterror_to_string();
+            VLOG_FATAL("Failed to create a event (%s).", msg_buf);
+        }
+
+        /* Register a function to handle Ctrl+C. */
+        SetConsoleCtrlHandler(ConsoleHandlerRoutine, true);
+#endif
 
         for (i = 0; i < ARRAY_SIZE(fatal_signals); i++) {
             int sig_nr = fatal_signals[i];
+#ifndef _WIN32
             struct sigaction old_sa;
 
             xsigaction(sig_nr, NULL, &old_sa);
@@ -94,8 +111,13 @@ fatal_signal_init(void)
                 && signal(sig_nr, fatal_signal_handler) == SIG_ERR) {
                 VLOG_FATAL("signal failed (%s)", ovs_strerror(errno));
             }
+#else
+            if (signal(sig_nr, fatal_signal_handler) == SIG_ERR) {
+                VLOG_FATAL("signal failed (%s)", ovs_strerror(errno));
+            }
+#endif
         }
-        atexit(atexit_handler);
+        atexit(fatal_signal_atexit_handler);
     }
 }
 
@@ -119,14 +141,14 @@ fatal_signal_add_hook(void (*hook_cb)(void *aux), void (*cancel_cb)(void *aux),
 {
     fatal_signal_init();
 
-    xpthread_mutex_lock(&mutex);
+    ovs_mutex_lock(&mutex);
     ovs_assert(n_hooks < MAX_HOOKS);
     hooks[n_hooks].hook_cb = hook_cb;
     hooks[n_hooks].cancel_cb = cancel_cb;
     hooks[n_hooks].aux = aux;
     hooks[n_hooks].run_at_exit = run_at_exit;
     n_hooks++;
-    xpthread_mutex_unlock(&mutex);
+    ovs_mutex_unlock(&mutex);
 }
 
 /* Handles fatal signal number 'sig_nr'.
@@ -141,7 +163,11 @@ fatal_signal_add_hook(void (*hook_cb)(void *aux), void (*cancel_cb)(void *aux),
 void
 fatal_signal_handler(int sig_nr)
 {
+#ifndef _WIN32
     ignore(write(signal_fds[1], "", 1));
+#else
+    SetEvent(wevent);
+#endif
     stored_sig_nr = sig_nr;
 }
 
@@ -167,19 +193,24 @@ fatal_signal_run(void)
     if (sig_nr != SIG_ATOMIC_MAX) {
         char namebuf[SIGNAL_NAME_BUFSIZE];
 
-        xpthread_mutex_lock(&mutex);
+        ovs_mutex_lock(&mutex);
 
+#ifndef _WIN32
         VLOG_WARN("terminating with signal %d (%s)",
                   (int)sig_nr, signal_name(sig_nr, namebuf, sizeof namebuf));
+#else
+        VLOG_WARN("terminating with signal %d", (int)sig_nr);
+#endif
         call_hooks(sig_nr);
+        fflush(stderr);
 
         /* Re-raise the signal with the default handling so that the program
          * termination status reflects that we were killed by this signal */
         signal(sig_nr, SIG_DFL);
         raise(sig_nr);
 
-        xpthread_mutex_unlock(&mutex);
-        NOT_REACHED();
+        ovs_mutex_unlock(&mutex);
+        OVS_NOT_REACHED();
     }
 }
 
@@ -187,11 +218,23 @@ void
 fatal_signal_wait(void)
 {
     fatal_signal_init();
+#ifdef _WIN32
+    poll_wevent_wait(wevent);
+#else
     poll_fd_wait(signal_fds[0], POLLIN);
+#endif
 }
 
-static void
-atexit_handler(void)
+void
+fatal_ignore_sigpipe(void)
+{
+#ifndef _WIN32
+    signal(SIGPIPE, SIG_IGN);
+#endif
+}
+
+void
+fatal_signal_atexit_handler(void)
 {
     call_hooks(0);
 }
@@ -213,6 +256,15 @@ call_hooks(int sig_nr)
         }
     }
 }
+
+#ifdef _WIN32
+BOOL WINAPI ConsoleHandlerRoutine(DWORD dwCtrlType)
+{
+    stored_sig_nr = SIGINT;
+    SetEvent(wevent);
+    return true;
+}
+#endif
 \f
 /* Files to delete on exit. */
 static struct sset files = SSET_INITIALIZER(&files);
@@ -232,14 +284,14 @@ fatal_signal_add_file_to_unlink(const char *file)
 {
     fatal_signal_init();
 
-    xpthread_mutex_lock(&mutex);
+    ovs_mutex_lock(&mutex);
     if (!added_hook) {
         added_hook = true;
         fatal_signal_add_hook(unlink_files, cancel_files, NULL, true);
     }
 
     sset_add(&files, file);
-    xpthread_mutex_unlock(&mutex);
+    ovs_mutex_unlock(&mutex);
 }
 
 /* Unregisters 'file' from being unlinked when the program terminates via
@@ -249,9 +301,9 @@ fatal_signal_remove_file_to_unlink(const char *file)
 {
     fatal_signal_init();
 
-    xpthread_mutex_lock(&mutex);
+    ovs_mutex_lock(&mutex);
     sset_find_and_delete(&files, file);
-    xpthread_mutex_unlock(&mutex);
+    ovs_mutex_unlock(&mutex);
 }
 
 /* Like fatal_signal_remove_file_to_unlink(), but also unlinks 'file'.
@@ -263,7 +315,7 @@ fatal_signal_unlink_file_now(const char *file)
 
     fatal_signal_init();
 
-    xpthread_mutex_lock(&mutex);
+    ovs_mutex_lock(&mutex);
 
     error = unlink(file) ? errno : 0;
     if (error) {
@@ -272,7 +324,7 @@ fatal_signal_unlink_file_now(const char *file)
 
     fatal_signal_remove_file_to_unlink(file);
 
-    xpthread_mutex_unlock(&mutex);
+    ovs_mutex_unlock(&mutex);
 
     return error;
 }
@@ -329,3 +381,21 @@ fatal_signal_fork(void)
         raise(stored_sig_nr);
     }
 }
+
+#ifndef _WIN32
+/* Blocks all fatal signals and returns previous signal mask into
+ * 'prev_mask'. */
+void
+fatal_signal_block(sigset_t *prev_mask)
+{
+    int i;
+    sigset_t block_mask;
+
+    sigemptyset(&block_mask);
+    for (i = 0; i < ARRAY_SIZE(fatal_signals); i++) {
+        int sig_nr = fatal_signals[i];
+        sigaddset(&block_mask, sig_nr);
+    }
+    xpthread_sigmask(SIG_BLOCK, &block_mask, prev_mask);
+}
+#endif