summaryrefslogtreecommitdiff
path: root/ACE/tests/Signal_Test.cpp
diff options
context:
space:
mode:
authorWilliam R. Otte <wotte@dre.vanderbilt.edu>2006-07-24 15:50:30 +0000
committerWilliam R. Otte <wotte@dre.vanderbilt.edu>2006-07-24 15:50:30 +0000
commitc44379cc7d9c7aa113989237ab0f56db12aa5219 (patch)
tree66a84b20d47f2269d8bdc6e0323f338763424d3a /ACE/tests/Signal_Test.cpp
parent3aff90f4a822fcf5d902bbfbcc9fa931d6191a8c (diff)
downloadATCD-c44379cc7d9c7aa113989237ab0f56db12aa5219.tar.gz
Repo restructuring
Diffstat (limited to 'ACE/tests/Signal_Test.cpp')
-rw-r--r--ACE/tests/Signal_Test.cpp499
1 files changed, 499 insertions, 0 deletions
diff --git a/ACE/tests/Signal_Test.cpp b/ACE/tests/Signal_Test.cpp
new file mode 100644
index 00000000000..49d05835568
--- /dev/null
+++ b/ACE/tests/Signal_Test.cpp
@@ -0,0 +1,499 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+// tests
+//
+// = FILENAME
+// Signal_Test.cpp
+//
+// = DESCRIPTION
+// This program tests the signal handling capabilities of ACE on
+// various OS platforms that support sending signals between
+// processes.
+//
+// = AUTHOR
+// Douglas C. Schmidt <schmidt@cs.wustl.edu>
+//
+// ============================================================================
+
+#include "test_config.h"
+#include "ace/Thread_Manager.h"
+#include "ace/Process.h"
+#include "ace/Signal.h"
+#include "ace/Get_Opt.h"
+#include "ace/ARGV.h"
+#include "ace/ACE.h"
+#include "ace/OS_NS_signal.h"
+#include "ace/OS_NS_stdio.h"
+#include "ace/OS_NS_unistd.h"
+
+ACE_RCSID(tests, Signal_Test, "$Id$")
+
+#if !defined (ACE_LACKS_UNIX_SIGNALS)
+
+// Global options.
+static size_t n_iterations = 100000;
+
+// Keeps track of whether we're the child or not.
+static int child = 0;
+
+// Keep track of the child pid.
+static pid_t child_pid = 0;
+
+// Keep track of the (original) parent pid.
+static pid_t parent_pid = 0;
+
+// Keep track of which test we're running.
+static int test_number = 0;
+
+// Coordinate the shutdown between threads.
+static sig_atomic_t shut_down = 0;
+
+static int
+handle_signal (int signum)
+{
+ // ACE_DEBUG / ACE_ERROR invocations have been #if'd out because
+ // they are "unsafe" when handler is invoked asynchronously. On
+ // NetBSD 3.X, calls to change the thread's signal mask block as
+ // a lock seems to be held by the signal trampoline code.
+
+#if 0
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) received signal %S\n"),
+ signum));
+#endif
+
+ switch (signum)
+ {
+ case SIGCHLD:
+ // Signal to the main thread to shut down.
+ shut_down = 1;
+
+ // This should only occur for the asynchronous case, so we don't
+ // need to return -1!
+ return 0;
+ case SIGINT:
+ /* FALLTHRU */
+ case SIGTERM:
+ // Shut down our thread using <ACE_Thread_Manager::exit>.
+#if 0
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) shutting down due to %S\n"),
+ signum));
+#endif
+
+ // Signal to the worker thread to shut down.
+ shut_down = 1;
+
+ // Bail out and close down.
+ return -1;
+ /* NOTREACHED */
+
+ case SIGHUP:
+ {
+ // Shutdown the child.
+
+#if 0
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) killing child pid %d \n"),
+ child_pid));
+#endif
+ int const result = ACE_OS::kill (child_pid,
+ SIGTERM);
+ ACE_ASSERT (result != -1);
+
+ return -1;
+ }
+ /* NOTREACHED */
+ case -1:
+#if 0
+ ACE_ERROR ((LM_ERROR,
+ ACE_TEXT ("(%P|%t) %p\n"),
+ "sigwait"));
+#endif
+ return -1;
+ /* NOTREACHED */
+ default:
+#if 0
+ ACE_ERROR ((LM_ERROR,
+ ACE_TEXT ("(%P|%t) signal %S unexpected\n"),
+ signum));
+#endif
+ return -1;
+ /* NOTREACHED */
+ }
+}
+
+// This function handles signals synchronously.
+
+static ACE_THR_FUNC_RETURN
+synchronous_signal_handler (void *)
+{
+ ACE_Sig_Set sigset;
+
+ // Register signal handlers.
+ if (child)
+ {
+ sigset.sig_add (SIGINT);
+ sigset.sig_add (SIGTERM);
+ }
+ else
+ sigset.sig_add (SIGHUP);
+
+ for (;;)
+ {
+ // Block waiting for SIGINT, SIGTERM, or SIGHUP, depending on
+ // whether we're the parent or child process.
+ if (handle_signal (ACE_OS::sigwait (sigset)) == -1)
+ break;
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) handled signal\n")));
+ }
+
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) synchronous signal handler done\n")));
+
+ return 0;
+}
+
+// This function arranges to handle signals asynchronously, which is
+// necessary if an OS platform lacks threads.
+
+static ACE_THR_FUNC_RETURN
+asynchronous_signal_handler (void *)
+{
+ ACE_Sig_Set sigset;
+
+ // Register signal handlers.
+ if (child)
+ {
+ sigset.sig_add (SIGINT);
+ sigset.sig_add (SIGTERM);
+ }
+ else
+ {
+ sigset.sig_add (SIGCHLD);
+ sigset.sig_add (SIGHUP);
+ }
+
+ // Register the <handle_signal> method to process all the signals in
+ // <sigset>.
+ ACE_Sig_Action sa (sigset,
+ (ACE_SignalHandler) handle_signal);
+ ACE_UNUSED_ARG (sa);
+
+ return 0;
+}
+
+// Function that runs in the child process in its own worker thread.
+
+static ACE_THR_FUNC_RETURN
+worker_child (void *arg)
+{
+ long handle_signals_synchronously =
+ reinterpret_cast <long> (arg);
+
+ for (size_t i = 0; i < n_iterations; i++)
+ {
+ if (shut_down > 0)
+ {
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) we've been shutdown!\n")));
+ break;
+ }
+
+ // Every 100 iterations sleep for 2 seconds.
+ if ((i % 100) == 0)
+ {
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) sleeping for 2 seconds\n")));
+ ACE_OS::sleep (2);
+ }
+
+ // After 1000 iterations sent a SIGHUP to our parent.
+ if ((i % 1000) == 0)
+ {
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) sending SIGHUP to parent process %d\n"),
+ parent_pid));
+ int const result = ACE_OS::kill (parent_pid,
+ SIGHUP);
+ if (result == -1)
+ {
+ ACE_ERROR ((LM_ERROR,
+ ACE_TEXT ("(%P|%t) %p\n"),
+ ACE_TEXT ("kill")));
+ ACE_ASSERT (result != -1);
+ }
+ }
+ }
+
+ if (handle_signals_synchronously)
+ {
+ if (!shut_down)
+ {
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) sending SIGINT to ourselves\n")));
+ // We need to do this to dislodge the signal handling thread if
+ // it hasn't shut down on its own accord yet.
+ int const result = ACE_OS::kill (ACE_OS::getpid (), SIGINT);
+ ACE_ASSERT (result != -1);
+ }
+ }
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) finished running child\n")));
+ return 0;
+}
+
+// This function runs the parent process in a separate worker thread.
+static ACE_THR_FUNC_RETURN
+worker_parent (void *arg)
+{
+ long handle_signals_synchronously =
+ reinterpret_cast <long> (arg);
+ ACE_Process_Options options;
+
+ ACE_TCHAR *l_argv[3];
+ ACE_TCHAR pid_str[100];
+ // Store the parent's process id so we can pass it to the child
+ // portably. Also, pass the test number, as well.
+ ACE_OS::sprintf (pid_str,
+ ACE_TEXT ("-p %ld -t %d"),
+ static_cast <long> (parent_pid),
+ test_number);
+
+ // We're going to create a new process that runs this program again,
+ // so we need to indicate that it's the child.
+ const ACE_TCHAR *t = ACE_TEXT (".")
+ ACE_DIRECTORY_SEPARATOR_STR
+ ACE_TEXT ("Signal_Test")
+ ACE_PLATFORM_EXE_SUFFIX
+ ACE_TEXT (" -c");
+ l_argv[0] = const_cast <ACE_TCHAR *> (t);
+ l_argv[1] = pid_str;
+ l_argv[2] = 0;
+
+ ACE_ARGV argv (l_argv);
+
+ // Generate a command-line!
+ options.command_line (argv.buf ());
+ ACE_Process pm;
+
+ child_pid = pm.spawn (options);
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) spawning child process %d\n"),
+ child_pid));
+
+ ACE_ASSERT (child_pid != -1);
+
+ // Perform a <wait> until our child process has exited.
+
+ if (handle_signals_synchronously)
+ {
+ int status;
+ // Wait for the child process to exit.
+ pm.wait (&status);
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) reaped child with status %d\n"),
+ status));
+ }
+ else
+ while (shut_down == 0)
+ {
+ // Wait for a signal to arrive.
+ if (ACE_OS::sigsuspend (0) == -1 && errno != EINTR)
+ ACE_ERROR ((LM_ERROR,
+ ACE_TEXT ("(%P|%t) %p\n"),
+ ACE_TEXT ("sigsuspend")));
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) got signal!\n")));
+ }
+
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) parent worker done\n")));
+ return 0;
+}
+
+// This is the driver function that spawns threads to run the test for
+// the parent and the child process.
+
+static void
+run_test (ACE_THR_FUNC worker,
+ long handle_signals_in_separate_thread,
+ long handle_signals_synchronously)
+{
+#if defined (ACE_HAS_THREADS)
+ if (handle_signals_synchronously)
+ {
+ // For the synchronous signal tests, block signals to prevent
+ // asynchronous delivery to default handler (at least necessary
+ // on linux and solaris; POSIX spec also states that signal(s)
+ // should be blocked before call to sigwait())
+ ACE_Sig_Guard guard;
+
+ int result;
+
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) spawning worker thread\n")));
+ result = ACE_Thread_Manager::instance ()->spawn
+ (worker,
+ reinterpret_cast <void *> (handle_signals_synchronously),
+ THR_DETACHED);
+ ACE_ASSERT (result != -1);
+
+ if (handle_signals_in_separate_thread)
+ {
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) spawning signal handler thread\n")));
+
+ result = ACE_Thread_Manager::instance ()->spawn
+ (synchronous_signal_handler,
+ 0,
+ THR_DETACHED);
+ ACE_ASSERT (result != -1);
+ }
+ else
+ {
+ synchronous_signal_handler (0);
+ }
+
+ // Wait for the thread(s) to finish.
+ result = ACE_Thread_Manager::instance ()->wait ();
+ ACE_ASSERT (result != -1);
+ }
+ else
+#else
+ // Don't remove this since otherwise some compilers give warnings
+ // when ACE_HAS_THREADS is disabled!
+ ACE_UNUSED_ARG (synchronous_signal_handler);
+#endif /* ACE_HAS_THREADS */
+ {
+ ACE_UNUSED_ARG (handle_signals_in_separate_thread);
+ // Arrange to handle signals asynchronously.
+ asynchronous_signal_handler (0);
+ (*worker) (reinterpret_cast <void *> (handle_signals_synchronously));
+ }
+}
+
+// Parse the command-line arguments and set options.
+
+static void
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+ ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("i:chp:t:"));
+
+ int c;
+
+ while ((c = get_opt ()) != -1)
+ switch (c)
+ {
+ case 'i':
+ n_iterations = ACE_OS::atoi (get_opt.opt_arg ());
+ break;
+ case 'c':
+ child = 1;
+ break;
+ case 'p':
+ parent_pid = ACE_OS::atoi (get_opt.opt_arg ());
+ break;
+ case 't':
+ test_number = ACE_OS::atoi (get_opt.opt_arg ());
+ break;
+ case 'h':
+ default:
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) usage:\n")
+ ACE_TEXT ("-i <iterations>\n")
+ ACE_TEXT ("-c\n")
+ ACE_TEXT ("-p <parent_pid>\n")
+ ACE_TEXT ("-t <test_number>\n")));
+ break;
+ }
+}
+
+int
+run_main (int argc, ACE_TCHAR *argv[])
+{
+ ACE_OS::signal(SIGHUP, SIG_DFL);
+
+ if (argc > 1)
+ {
+ ACE_APPEND_LOG (ACE_TEXT ("Signal_Test-child"));
+ parse_args (argc, argv);
+
+ if (test_number == 1)
+ {
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) **** test 1: handle signals synchronously in separate thread\n")));
+
+ // First, handle signals synchronously in separate thread.
+ run_test (worker_child, 1, 1);
+ }
+ else if (test_number == 2)
+ {
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) **** test 2: handle signals synchronously in this thread\n")));
+
+ // Next, handle signals synchronously in this thread.
+ run_test (worker_child, 0, 1);
+ }
+ else if (test_number == 3)
+ {
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) **** test 3: handle signals asynchronously in this thread\n")));
+
+ // Finally, handle signals asynchronously in this thread.
+ run_test (worker_child, 0, 0);
+ }
+
+ ACE_END_LOG;
+ }
+ else
+ {
+ ACE_START_TEST (ACE_TEXT ("Signal_Test"));
+ ACE_INIT_LOG (ACE_TEXT ("Signal_Test-child"));
+
+ // We need to get the process id here to work around "features"
+ // of Linux threads...
+ parent_pid = ACE_OS::getpid ();
+
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) **** test 1: handle signals synchronously in a separate thread\n")));
+
+ ++test_number;
+ // Run the parent logic for the signal test, first by handling
+ // signals synchronously in a separate thread.
+ run_test (worker_parent, 1L, 1L);
+
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) **** test 2: handle signals synchronously in this thread\n")));
+
+ ++test_number;
+ // And next by handling synchronously signals in this thread.
+ run_test (worker_parent, 0L, 1L);
+
+ ACE_DEBUG ((LM_DEBUG,
+ ACE_TEXT ("(%P|%t) **** test 3: handle signals asynchronously in this thread\n")));
+
+ ++test_number;
+ // And finally by handling asynchronously signals in this thread.
+ run_test (worker_parent, 0L, 0L);
+
+ ACE_END_TEST;
+ }
+ return 0;
+}
+
+#else
+int
+run_main (int, ACE_TCHAR *[])
+{
+ ACE_START_TEST (ACE_TEXT ("Signal_Test"));
+ ACE_ERROR ((LM_INFO,
+ ACE_TEXT ("The Unix Signals capability is not supported on this platform\n")));
+ ACE_END_TEST;
+ return 0;
+}
+#endif /* !defined (ACE_LACKS_UNIX_SIGNALS) */