kqueue-1.0.4/test/proc.c

   1 /*
   2  * Copyright (c) 2009 Mark Heily <mark@heily.com>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "common.h"
  18
  19 static int sigusr1_caught = 0;
  20 static pid_t pid;
  21 static int __thread kqfd;
  22
  23 static void
  24 sig_handler(int signum)
  25 {
  26     sigusr1_caught = 1;
  27 }
  28
  29 static void
  30 test_kevent_proc_add(void)
  31 {
  32     struct kevent kev;
  33
  34     test_no_kevents(kqfd);
  35     kevent_add(kqfd, &kev, pid, EVFILT_PROC, EV_ADD, 0, 0, NULL);
  36     test_no_kevents(kqfd);
  37 }
  38
  39 static void
  40 test_kevent_proc_delete(void)
  41 {
  42     struct kevent kev;
  43
  44     test_no_kevents(kqfd);
  45     kevent_add(kqfd, &kev, pid, EVFILT_PROC, EV_DELETE, 0, 0, NULL);
  46     if (kill(pid, SIGKILL) < 0)
  47         die("kill");
  48     sleep(1);
  49     test_no_kevents(kqfd);
  50 }
  51
  52 static void
  53 test_kevent_proc_get(void)
  54 {
  55     struct kevent kev;
  56
  57     /* Create a child that waits to be killed and then exits */
  58     pid = fork();
  59     if (pid == 0) {
  60         pause();
  61         printf(" -- child caught signal, exiting\n");
  62         exit(2);
  63     }
  64     printf(" -- child created (pid %d)\n", (int) pid);
  65
  66     test_no_kevents(kqfd);
  67     kevent_add(kqfd, &kev, pid, EVFILT_PROC, EV_ADD, 0, 0, NULL);
  68
  69     /* Cause the child to exit, then retrieve the event */
  70     printf(" -- killing process %d\n", (int) pid);
  71     if (kill(pid, SIGUSR1) < 0)
  72         die("kill");
  73     kevent_cmp(&kev, kevent_get(kqfd));
  74     test_no_kevents(kqfd);
  75 }
  76
  77 #ifdef TODO
  78 void
  79 test_kevent_signal_disable(void)
  80 {
  81     const char *test_id = "kevent(EVFILT_SIGNAL, EV_DISABLE)";
  82     struct kevent kev;
  83
  84     test_begin(test_id);
  85
  86     EV_SET(&kev, SIGUSR1, EVFILT_SIGNAL, EV_DISABLE, 0, 0, NULL);
  87     if (kevent(kqfd, &kev, 1, NULL, 0, NULL) < 0)
  88         die("%s", test_id);
  89
  90     /* Block SIGUSR1, then send it to ourselves */
  91     sigset_t mask;
  92     sigemptyset(&mask);
  93     sigaddset(&mask, SIGUSR1);
  94     if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
  95         die("sigprocmask");
  96     if (kill(getpid(), SIGKILL) < 0)
  97         die("kill");
  98
  99     test_no_kevents();
 100
 101     success();
 102 }
 103
 104 void
 105 test_kevent_signal_enable(void)
 106 {
 107     const char *test_id = "kevent(EVFILT_SIGNAL, EV_ENABLE)";
 108     struct kevent kev;
 109
 110     test_begin(test_id);
 111
 112     EV_SET(&kev, SIGUSR1, EVFILT_SIGNAL, EV_ENABLE, 0, 0, NULL);
 113     if (kevent(kqfd, &kev, 1, NULL, 0, NULL) < 0)
 114         die("%s", test_id);
 115
 116     /* Block SIGUSR1, then send it to ourselves */
 117     sigset_t mask;
 118     sigemptyset(&mask);
 119     sigaddset(&mask, SIGUSR1);
 120     if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
 121         die("sigprocmask");
 122     if (kill(getpid(), SIGUSR1) < 0)
 123         die("kill");
 124
 125     kev.flags = EV_ADD | EV_CLEAR;
 126 #if LIBKQUEUE
 127     kev.data = 1; /* WORKAROUND */
 128 #else
 129     kev.data = 2; // one extra time from test_kevent_signal_disable()
 130 #endif
 131     kevent_cmp(&kev, kevent_get(kqfd));
 132
 133     /* Delete the watch */
 134     kev.flags = EV_DELETE;
 135     if (kevent(kqfd, &kev, 1, NULL, 0, NULL) < 0)
 136         die("%s", test_id);
 137
 138     success();
 139 }
 140
 141 void
 142 test_kevent_signal_del(void)
 143 {
 144     const char *test_id = "kevent(EVFILT_SIGNAL, EV_DELETE)";
 145     struct kevent kev;
 146
 147     test_begin(test_id);
 148
 149     /* Delete the kevent */
 150     EV_SET(&kev, SIGUSR1, EVFILT_SIGNAL, EV_DELETE, 0, 0, NULL);
 151     if (kevent(kqfd, &kev, 1, NULL, 0, NULL) < 0)
 152         die("%s", test_id);
 153
 154     /* Block SIGUSR1, then send it to ourselves */
 155     sigset_t mask;
 156     sigemptyset(&mask);
 157     sigaddset(&mask, SIGUSR1);
 158     if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
 159         die("sigprocmask");
 160     if (kill(getpid(), SIGUSR1) < 0)
 161         die("kill");
 162
 163     test_no_kevents();
 164     success();
 165 }
 166
 167 void
 168 test_kevent_signal_oneshot(void)
 169 {
 170     const char *test_id = "kevent(EVFILT_SIGNAL, EV_ONESHOT)";
 171     struct kevent kev;
 172
 173     test_begin(test_id);
 174
 175     EV_SET(&kev, SIGUSR1, EVFILT_SIGNAL, EV_ADD | EV_ONESHOT, 0, 0, NULL);
 176     if (kevent(kqfd, &kev, 1, NULL, 0, NULL) < 0)
 177         die("%s", test_id);
 178
 179     /* Block SIGUSR1, then send it to ourselves */
 180     sigset_t mask;
 181     sigemptyset(&mask);
 182     sigaddset(&mask, SIGUSR1);
 183     if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
 184         die("sigprocmask");
 185     if (kill(getpid(), SIGUSR1) < 0)
 186         die("kill");
 187
 188     kev.flags |= EV_CLEAR;
 189     kev.data = 1;
 190     kevent_cmp(&kev, kevent_get(kqfd));
 191
 192     /* Send another one and make sure we get no events */
 193     if (kill(getpid(), SIGUSR1) < 0)
 194         die("kill");
 195     test_no_kevents();
 196
 197     success();
 198 }
 199 #endif
 200
 201 void
 202 test_evfilt_proc(int _kqfd)
 203 {
 204     kqfd = _kqfd;
 205
 206     signal(SIGUSR1, sig_handler);
 207
 208     /* Create a child that waits to be killed and then exits */
 209     pid = fork();
 210     if (pid == 0) {
 211         pause();
 212         exit(2);
 213     }
 214     printf(" -- child created (pid %d)\n", (int) pid);
 215
 216     test(kevent_proc_add);
 217     test(kevent_proc_delete);
 218     test(kevent_proc_get);
 219
 220     signal(SIGUSR1, SIG_DFL);
 221
 222 #if TODO
 223     test_kevent_signal_add();
 224     test_kevent_signal_del();
 225     test_kevent_signal_get();
 226     test_kevent_signal_disable();
 227     test_kevent_signal_enable();
 228     test_kevent_signal_oneshot();
 229 #endif
 230 }