tests/sys/kqueue/libkqueue/main.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  * $FreeBSD$
  17  */
  18
  19 #include <sys/types.h>
  20
  21 #include "config.h"
  22 #include "common.h"
  23
  24 int testnum = 1;
  25 char *cur_test_id = NULL;
  26 int kqfd;
  27
  28 extern void test_evfilt_read();
  29 extern void test_evfilt_signal();
  30 extern void test_evfilt_vnode();
  31 extern void test_evfilt_timer();
  32 extern void test_evfilt_proc();
  33 #if HAVE_EVFILT_USER
  34 extern void test_evfilt_user();
  35 #endif
  36
  37 /* Checks if any events are pending, which is an error. */
  38 void
  39 test_no_kevents(void)
  40 {
  41     int nfds;
  42     struct timespec timeo;
  43     struct kevent kev;
  44
  45     puts("confirming that there are no events pending");
  46     memset(&timeo, 0, sizeof(timeo));
  47     nfds = kevent(kqfd, NULL, 0, &kev, 1, &timeo);
  48     if (nfds != 0) {
  49         puts("\nUnexpected event:");
  50         puts(kevent_to_str(&kev));
  51         errx(1, "%d event(s) pending, but none expected:", nfds);
  52     }
  53 }
  54
  55 /* Retrieve a single kevent */
  56 struct kevent *
  57 kevent_get(int kqfd)
  58 {
  59     int nfds;
  60     struct kevent *kev;
  61
  62     if ((kev = calloc(1, sizeof(*kev))) == NULL)
  63         err(1, "out of memory");
  64
  65     nfds = kevent(kqfd, NULL, 0, kev, 1, NULL);
  66     if (nfds < 1)
  67         err(1, "kevent(2)");
  68
  69     return (kev);
  70 }
  71
  72 /* Retrieve a single kevent, specifying a maximum time to wait for it. */
  73 struct kevent *
  74 kevent_get_timeout(int kqfd, int seconds)
  75 {
  76     int nfds;
  77     struct kevent *kev;
  78     struct timespec timeout = {seconds, 0};
  79
  80     if ((kev = calloc(1, sizeof(*kev))) == NULL)
  81         err(1, "out of memory");
  82
  83     nfds = kevent(kqfd, NULL, 0, kev, 1, &timeout);
  84     if (nfds < 0) {
  85         err(1, "kevent(2)");
  86     } else if (nfds == 0) {
  87         free(kev);
  88         kev = NULL;
  89     }
  90
  91     return (kev);
  92 }
  93
  94 char *
  95 kevent_fflags_dump(struct kevent *kev)
  96 {
  97     char *buf;
  98
  99 #define KEVFFL_DUMP(attrib) \
 100     if (kev->fflags & attrib) \
 101         strncat(buf, #attrib" ", 64);
 102
 103     if ((buf = calloc(1, 1024)) == NULL)
 104         abort();
 105
 106     /* Not every filter has meaningful fflags */
 107     if (kev->filter == EVFILT_PROC) {
 108         snprintf(buf, 1024, "fflags = %x (", kev->fflags);
 109         KEVFFL_DUMP(NOTE_EXIT);
 110         KEVFFL_DUMP(NOTE_FORK);
 111         KEVFFL_DUMP(NOTE_EXEC);
 112         KEVFFL_DUMP(NOTE_CHILD);
 113         KEVFFL_DUMP(NOTE_TRACKERR);
 114         KEVFFL_DUMP(NOTE_TRACK);
 115         buf[strlen(buf) - 1] = ')';
 116     } else if (kev->filter == EVFILT_PROCDESC) {
 117         snprintf(buf, 1024, "fflags = %x (", kev->fflags);
 118         KEVFFL_DUMP(NOTE_EXIT);
 119         KEVFFL_DUMP(NOTE_FORK);
 120         KEVFFL_DUMP(NOTE_EXEC);
 121         buf[strlen(buf) - 1] = ')';
 122     } else if (kev->filter == EVFILT_VNODE) {
 123         snprintf(buf, 1024, "fflags = %x (", kev->fflags);
 124         KEVFFL_DUMP(NOTE_DELETE);
 125         KEVFFL_DUMP(NOTE_WRITE);
 126         KEVFFL_DUMP(NOTE_EXTEND);
 127 #if HAVE_NOTE_TRUNCATE
 128         KEVFFL_DUMP(NOTE_TRUNCATE);
 129 #endif
 130         KEVFFL_DUMP(NOTE_ATTRIB);
 131         KEVFFL_DUMP(NOTE_LINK);
 132         KEVFFL_DUMP(NOTE_RENAME);
 133 #if HAVE_NOTE_REVOKE
 134         KEVFFL_DUMP(NOTE_REVOKE);
 135 #endif
 136         buf[strlen(buf) - 1] = ')';
 137     } else {
 138         snprintf(buf, 1024, "fflags = %x", kev->fflags);
 139     }
 140
 141     return (buf);
 142 }
 143
 144 char *
 145 kevent_flags_dump(struct kevent *kev)
 146 {
 147     char *buf;
 148
 149 #define KEVFL_DUMP(attrib) \
 150     if (kev->flags & attrib) \
 151         strncat(buf, #attrib" ", 64);
 152
 153     if ((buf = calloc(1, 1024)) == NULL)
 154         abort();
 155
 156     snprintf(buf, 1024, "flags = %d (", kev->flags);
 157     KEVFL_DUMP(EV_ADD);
 158     KEVFL_DUMP(EV_ENABLE);
 159     KEVFL_DUMP(EV_DISABLE);
 160     KEVFL_DUMP(EV_DELETE);
 161     KEVFL_DUMP(EV_ONESHOT);
 162     KEVFL_DUMP(EV_CLEAR);
 163     KEVFL_DUMP(EV_EOF);
 164     KEVFL_DUMP(EV_ERROR);
 165 #if HAVE_EV_DISPATCH
 166     KEVFL_DUMP(EV_DISPATCH);
 167 #endif
 168 #if HAVE_EV_RECEIPT
 169     KEVFL_DUMP(EV_RECEIPT);
 170 #endif
 171     buf[strlen(buf) - 1] = ')';
 172
 173     return (buf);
 174 }
 175
 176 /* Copied from ../kevent.c kevent_dump() and improved */
 177 const char *
 178 kevent_to_str(struct kevent *kev)
 179 {
 180     char buf[512];
 181
 182     snprintf(&buf[0], sizeof(buf),
 183             "[ident=%d, filter=%d, %s, %s, data=%d, udata=%p]",
 184             (u_int) kev->ident,
 185             kev->filter,
 186             kevent_flags_dump(kev),
 187             kevent_fflags_dump(kev),
 188             (int) kev->data,
 189             kev->udata);
 190
 191     return (strdup(buf));
 192 }
 193
 194 void
 195 kevent_add(int kqfd, struct kevent *kev,
 196         uintptr_t ident,
 197         short     filter,
 198         u_short   flags,
 199         u_int     fflags,
 200         intptr_t  data,
 201         void      *udata)
 202 {
 203     EV_SET(kev, ident, filter, flags, fflags, data, NULL);
 204     if (kevent(kqfd, kev, 1, NULL, 0, NULL) < 0) {
 205         printf("Unable to add the following kevent:\n%s\n",
 206                 kevent_to_str(kev));
 207         err(1, "kevent(): %s", strerror(errno));
 208     }
 209 }
 210
 211 void
 212 kevent_cmp(struct kevent *k1, struct kevent *k2)
 213 {
 214 /* XXX-
 215    Workaround for inconsistent implementation of kevent(2)
 216  */
 217 #ifdef __FreeBSD__
 218     if (k1->flags & EV_ADD)
 219         k2->flags |= EV_ADD;
 220 #endif
 221     if (memcmp(k1, k2, sizeof(*k1)) != 0) {
 222         printf("kevent_cmp: mismatch:\n  %s !=\n  %s\n",
 223               kevent_to_str(k1), kevent_to_str(k2));
 224         abort();
 225     }
 226 }
 227
 228 void
 229 test_begin(const char *func)
 230 {
 231     if (cur_test_id)
 232         free(cur_test_id);
 233     cur_test_id = strdup(func);
 234     if (!cur_test_id)
 235         err(1, "strdup failed");
 236
 237     printf("\n\nTest %d: %s\n", testnum++, func);
 238 }
 239
 240 void
 241 success(void)
 242 {
 243     printf("%-70s %s\n", cur_test_id, "passed");
 244     free(cur_test_id);
 245     cur_test_id = NULL;
 246 }
 247
 248 void
 249 test_kqueue(void)
 250 {
 251     test_begin("kqueue()");
 252     if ((kqfd = kqueue()) < 0)
 253         err(1, "kqueue()");
 254     test_no_kevents();
 255     success();
 256 }
 257
 258 void
 259 test_kqueue_close(void)
 260 {
 261     test_begin("close(kq)");
 262     if (close(kqfd) < 0)
 263         err(1, "close()");
 264     success();
 265 }
 266
 267 int
 268 main(int argc, char **argv)
 269 {
 270     int test_proc = 1;
 271     int test_socket = 1;
 272     int test_signal = 1;
 273     int test_vnode = 1;
 274     int test_timer = 1;
 275 #ifdef __FreeBSD__
 276     int test_user = 1;
 277 #else
 278     /* XXX-FIXME temporary */
 279     int test_user = 0;
 280 #endif
 281
 282     while (argc) {
 283         if (strcmp(argv[0], "--no-proc") == 0)
 284             test_proc = 0;
 285         if (strcmp(argv[0], "--no-socket") == 0)
 286             test_socket = 0;
 287         if (strcmp(argv[0], "--no-timer") == 0)
 288             test_timer = 0;
 289         if (strcmp(argv[0], "--no-signal") == 0)
 290             test_signal = 0;
 291         if (strcmp(argv[0], "--no-vnode") == 0)
 292             test_vnode = 0;
 293         if (strcmp(argv[0], "--no-user") == 0)
 294             test_user = 0;
 295         argv++;
 296         argc--;
 297     }
 298
 299     /*
 300      * Some tests fork.  If output is fully buffered,
 301      * the children inherit some buffered data and flush
 302      * it when they exit, causing some data to be printed twice.
 303      * Use line buffering to avoid this problem.
 304      */
 305     setlinebuf(stdout);
 306     setlinebuf(stderr);
 307
 308     test_kqueue();
 309     test_kqueue_close();
 310
 311     if (test_socket)
 312         test_evfilt_read();
 313     if (test_signal)
 314         test_evfilt_signal();
 315     if (test_vnode)
 316         test_evfilt_vnode();
 317 #if HAVE_EVFILT_USER
 318     if (test_user)
 319         test_evfilt_user();
 320 #endif
 321     if (test_timer)
 322         test_evfilt_timer();
 323     if (test_proc)
 324         test_evfilt_proc();
 325
 326     printf("\n---\n"
 327             "+OK All %d tests completed.\n", testnum - 1);
 328     return (0);
 329 }