1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include <sys/types.h>
42: #include <sys/param.h>
43: #include <sys/queue.h>
44: #include <sys/time.h>
45:
46: #include <netinet/in.h>
47:
48: #include <stdarg.h>
49: #include <stdio.h>
50: #include <syslog.h>
51: #include <string.h>
52: #include <errno.h>
53: #include <assert.h>
54: #include <unistd.h>
55: #include <poll.h>
56: #include <sched.h>
57: #include <pthread.h>
58:
59: #include "structs/structs.h"
60: #include "structs/type/array.h"
61: #include "util/typed_mem.h"
62: #include "util/mesg_port.h"
63: #include "util/pevent.h"
64: #include "sys/alog.h"
65:
66: #include "internal.h"
67: #include "debug/debug.h"
68:
69: #define PEVENT_MAGIC 0x31d7699b
70: #define PEVENT_CTX_MAGIC 0x7842f901
71:
72: /* Private flags */
73: #define PEVENT_OCCURRED 0x8000 /* event has occurred */
74: #define PEVENT_CANCELED 0x4000 /* event canceled or done */
75: #define PEVENT_ENQUEUED 0x2000 /* in the ctx->events queue */
76: #define PEVENT_GOT_MUTEX 0x1000 /* user mutex acquired */
77:
78: #define PEVENT_USER_FLAGS (PEVENT_RECURRING | PEVENT_OWN_THREAD)
79:
80: #define READABLE_EVENTS (POLLIN | POLLRDNORM | POLLERR \
81: | POLLHUP | POLLNVAL)
82: #define WRITABLE_EVENTS (POLLOUT | POLLWRNORM | POLLWRBAND \
83: | POLLERR | POLLHUP | POLLNVAL)
84:
85: /* Event context */
86: struct pevent_ctx {
87: u_int32_t magic; /* magic number */
88: pthread_mutex_t mutex; /* mutex for context */
89: #if PDEL_DEBUG
90: int mutex_count; /* mutex count */
91: #endif
92: pthread_attr_t attr; /* event thread attributes */
93: pthread_t thread; /* event thread */
94: TAILQ_HEAD(, pevent) events; /* pending event list */
95: u_int nevents; /* length of 'events' list */
96: u_int nrwevents; /* number read/write events */
97: struct pollfd *fds; /* poll(2) fds array */
98: u_int fds_alloc; /* allocated size of 'fds' */
99: const char *mtype; /* typed_mem(3) memory type */
100: char mtype_buf[TYPED_MEM_TYPELEN];
101: int pipe[2]; /* event thread notify pipe */
102: u_char notified; /* data in the pipe */
103: u_char has_attr; /* 'attr' is valid */
104: u_int refs; /* references to this context */
105: };
106:
107: /* Event object */
108: struct pevent {
109: u_int32_t magic; /* magic number */
110: struct pevent_ctx *ctx; /* pointer to event context */
111: struct pevent **peventp; /* user handle to this event */
112: pevent_handler_t *handler; /* event handler function */
113: void *arg; /* event handler function arg */
114: int flags; /* event flags */
115: int poll_idx; /* index in poll(2) fds array */
116: pthread_mutex_t *mutex; /* user mutex, if any */
117: #if PDEL_DEBUG
118: int mutex_count; /* mutex count */
119: #endif
120: enum pevent_type type; /* type of this event */
121: struct timeval when; /* expiration for time events */
122: u_int refs; /* references to this event */
123: union {
124: int fd; /* file descriptor */
125: int millis; /* time delay */
126: struct mesg_port *port; /* mesg_port */
127: } u;
128: TAILQ_ENTRY(pevent) next; /* next in ctx->events */
129: };
130:
131: /* Macros */
132: #define PEVENT_ENQUEUE(ctx, ev) \
133: do { \
134: assert(((ev)->flags & PEVENT_ENQUEUED) == 0); \
135: TAILQ_INSERT_TAIL(&(ctx)->events, (ev), next); \
136: (ev)->flags |= PEVENT_ENQUEUED; \
137: (ctx)->nevents++; \
138: if ((ev)->type == PEVENT_READ \
139: || (ev)->type == PEVENT_WRITE) \
140: (ctx)->nrwevents++; \
141: DBG(PEVENT, "ev %p refs %d -> %d (enqueued)", \
142: (ev), (ev)->refs, (ev)->refs + 1); \
143: (ev)->refs++; \
144: } while (0)
145:
146: #define PEVENT_DEQUEUE(ctx, ev) \
147: do { \
148: assert(((ev)->flags & PEVENT_ENQUEUED) != 0); \
149: TAILQ_REMOVE(&(ctx)->events, (ev), next); \
150: (ctx)->nevents--; \
151: if ((ev)->type == PEVENT_READ \
152: || (ev)->type == PEVENT_WRITE) \
153: (ctx)->nrwevents--; \
154: (ev)->flags &= ~PEVENT_ENQUEUED; \
155: _pevent_unref(ev); \
156: } while (0)
157:
158: #define PEVENT_SET_OCCURRED(ctx, ev) \
159: do { \
160: (ev)->flags |= PEVENT_OCCURRED; \
161: if ((ev) != TAILQ_FIRST(&ctx->events)) { \
162: TAILQ_REMOVE(&(ctx)->events, (ev), next); \
163: TAILQ_INSERT_HEAD(&(ctx)->events, (ev), next); \
164: } \
165: } while (0)
166:
167: /* Internal functions */
168: static void pevent_ctx_service(struct pevent *ev);
169: static void *pevent_ctx_main(void *arg);
170: static void pevent_ctx_main_cleanup(void *arg);
171: static void *pevent_ctx_execute(void *arg);
172: static void pevent_ctx_execute_cleanup(void *arg);
173: static void pevent_ctx_notify(struct pevent_ctx *ctx);
174: static void pevent_ctx_unref(struct pevent_ctx *ctx);
175: static void pevent_cancel(struct pevent *ev);
176:
177: /* Internal variables */
178: static char pevent_byte;
179:
180: /*
181: * Create a new event context.
182: */
183: struct pevent_ctx *
184: pevent_ctx_create(const char *mtype, const pthread_attr_t *attr)
185: {
186: pthread_mutexattr_t mutexattr;
187: struct pevent_ctx *ctx;
188: int got_mutexattr = 0;
189: int got_mutex = 0;
190:
191: /* Create context object */
192: if ((ctx = MALLOC(mtype, sizeof(*ctx))) == NULL)
193: return (NULL);
194: memset(ctx, 0, sizeof(*ctx));
195: if (mtype != NULL) {
196: strlcpy(ctx->mtype_buf, mtype, sizeof(ctx->mtype_buf));
197: ctx->mtype = ctx->mtype_buf;
198: }
199: TAILQ_INIT(&ctx->events);
200:
201: /* Copy thread attributes */
202: if (attr != NULL) {
203: struct sched_param param;
204: int value;
205:
206: if ((errno = pthread_attr_init(&ctx->attr)) != 0)
207: goto fail;
208: ctx->has_attr = 1;
209: pthread_attr_getinheritsched(attr, &value);
210: pthread_attr_setinheritsched(&ctx->attr, value);
211: pthread_attr_getschedparam(attr, ¶m);
212: pthread_attr_setschedparam(&ctx->attr, ¶m);
213: pthread_attr_getschedpolicy(attr, &value);
214: pthread_attr_setschedpolicy(&ctx->attr, value);
215: pthread_attr_getscope(attr, &value);
216: pthread_attr_setscope(&ctx->attr, value);
217: }
218:
219: /* Initialize mutex */
220: if ((errno = pthread_mutexattr_init(&mutexattr) != 0))
221: goto fail;
222: got_mutexattr = 1;
223: pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE);
224: if ((errno = pthread_mutex_init(&ctx->mutex, &mutexattr)) != 0)
225: goto fail;
226: got_mutex = 1;
227:
228: /* Initialize notify pipe */
229: if (pipe(ctx->pipe) == -1)
230: goto fail;
231:
232: /* Finish up */
233: pthread_mutexattr_destroy(&mutexattr);
234: ctx->magic = PEVENT_CTX_MAGIC;
235: ctx->refs = 1;
236: DBG(PEVENT, "created ctx %p", ctx);
237: return (ctx);
238:
239: fail:
240: /* Clean up after failure */
241: if (got_mutex)
242: pthread_mutex_destroy(&ctx->mutex);
243: if (got_mutexattr)
244: pthread_mutexattr_destroy(&mutexattr);
245: if (ctx->has_attr)
246: pthread_attr_destroy(&ctx->attr);
247: FREE(mtype, ctx);
248: return (NULL);
249: }
250:
251: /*
252: * Destroy an event context.
253: *
254: * All events are unregistered.
255: */
256: void
257: pevent_ctx_destroy(struct pevent_ctx **ctxp)
258: {
259: struct pevent_ctx *const ctx = *ctxp;
260:
261: /* Allow NULL context */
262: if (ctx == NULL)
263: return;
264: *ctxp = NULL;
265: DBG(PEVENT, "destroying ctx %p", ctx);
266:
267: /* Lock context */
268: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
269:
270: /* Sanity check */
271: assert(ctx->magic == PEVENT_CTX_MAGIC);
272:
273: /* Unregister all events */
274: while (!TAILQ_EMPTY(&ctx->events))
275: pevent_unregister(TAILQ_FIRST(&ctx->events)->peventp);
276:
277: /* Decrement context reference count and unlock context */
278: pevent_ctx_unref(ctx);
279: }
280:
281: /*
282: * Return the number of registered events.
283: */
284: u_int
285: pevent_ctx_count(struct pevent_ctx *ctx)
286: {
287: u_int nevents;
288:
289: assert(ctx->magic == PEVENT_CTX_MAGIC);
290: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
291: nevents = ctx->nevents;
292: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
293: return (nevents);
294: }
295:
296: /*
297: * Create a new schedule item.
298: */
299: int
300: pevent_register(struct pevent_ctx *ctx, struct pevent **peventp, int flags,
301: pthread_mutex_t *mutex, pevent_handler_t *handler, void *arg,
302: enum pevent_type type, ...)
303: {
304: struct pevent *ev;
305: va_list args;
306:
307: /* Sanity check */
308: if (*peventp != NULL) {
309: errno = EBUSY;
310: return (-1);
311: }
312:
313: /* Check flags */
314: if ((flags & ~PEVENT_USER_FLAGS) != 0) {
315: errno = EINVAL;
316: return (-1);
317: }
318:
319: /* Create new event */
320: if ((ev = MALLOC(ctx->mtype, sizeof(*ev))) == NULL)
321: return (-1);
322: memset(ev, 0, sizeof(*ev));
323: ev->magic = PEVENT_MAGIC;
324: ev->ctx = ctx;
325: ev->handler = handler;
326: ev->arg = arg;
327: ev->flags = flags;
328: ev->poll_idx = -1;
329: ev->mutex = mutex;
330: ev->type = type;
331: ev->refs = 1; /* the caller's reference */
332: DBG(PEVENT, "new ev %p in ctx %p", ev, ctx);
333:
334: /* Add type-specific info */
335: switch (type) {
336: case PEVENT_READ:
337: case PEVENT_WRITE:
338: va_start(args, type);
339: ev->u.fd = va_arg(args, int);
340: va_end(args);
341: break;
342: case PEVENT_TIME:
343: va_start(args, type);
344: ev->u.millis = va_arg(args, int);
345: va_end(args);
346: if (ev->u.millis < 0)
347: ev->u.millis = 0;
348: gettimeofday(&ev->when, NULL);
349: ev->when.tv_sec += ev->u.millis / 1000;
350: ev->when.tv_usec += (ev->u.millis % 1000) * 1000;
351: if (ev->when.tv_usec > 1000000) {
352: ev->when.tv_sec++;
353: ev->when.tv_usec -= 1000000;
354: }
355: break;
356: case PEVENT_MESG_PORT:
357: va_start(args, type);
358: ev->u.port = va_arg(args, struct mesg_port *);
359: va_end(args);
360: if (ev->u.port == NULL)
361: goto invalid;
362: break;
363: case PEVENT_USER:
364: break;
365: default:
366: invalid:
367: errno = EINVAL;
368: _pevent_unref(ev);
369: return (-1);
370: }
371:
372: /* Lock context */
373: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
374:
375: /* Link to related object (if appropriate) */
376: switch (ev->type) {
377: case PEVENT_MESG_PORT:
378: if (_mesg_port_set_event(ev->u.port, ev) == -1) {
379: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
380: _pevent_unref(ev);
381: return (-1);
382: }
383: DBG(PEVENT, "ev %p refs %d -> %d (mesg port)",
384: ev, ev->refs, ev->refs + 1);
385: ev->refs++; /* the mesg_port's reference */
386: break;
387: default:
388: break;
389: }
390:
391: /* Start or notify event thread */
392: if (ctx->thread == 0) {
393: if ((errno = pthread_create(&ctx->thread,
394: ctx->has_attr ? &ctx->attr : NULL,
395: pevent_ctx_main, ctx)) != 0) {
396: ctx->thread = 0;
397: alogf(LOG_ERR, "%s: %m", "pthread_create");
398: ev->flags |= PEVENT_CANCELED;
399: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
400: _pevent_unref(ev);
401: return (-1);
402: }
403: pthread_detach(ctx->thread);
404: DBG(PEVENT, "created tid %p for ctx %p, refs -> %d",
405: ctx->thread, ctx, ctx->refs + 1);
406: ctx->refs++; /* add reference for thread */
407: } else
408: pevent_ctx_notify(ctx);
409:
410: /* Caller gets the one reference */
411: ev->peventp = peventp;
412: *peventp = ev;
413:
414: /* Add event to the pending event list */
415: PEVENT_ENQUEUE(ctx, ev);
416:
417: /* Unlock context */
418: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
419:
420: return (0);
421: }
422:
423: /*
424: * Unregister an event.
425: */
426: void
427: pevent_unregister(struct pevent **peventp)
428: {
429: struct pevent *const ev = *peventp;
430: struct pevent_ctx *ctx;
431:
432: /* Allow NULL event */
433: if (ev == NULL)
434: return;
435: ctx = ev->ctx;
436: DBG(PEVENT, "unregister ev %p in ctx %p", ev, ctx);
437:
438: /* Sanity checks */
439: assert(ev->magic == PEVENT_MAGIC);
440: assert(ctx->magic == PEVENT_CTX_MAGIC);
441: assert(ev->peventp == peventp);
442:
443: /* Lock context */
444: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
445: DBG(PEVENT, "unregister ev %p in ctx %p: lock", ev, ctx);
446:
447: /* Dequeue event if queued */
448: if ((ev->flags & PEVENT_ENQUEUED) != 0) {
449: PEVENT_DEQUEUE(ctx, ev);
450: pevent_ctx_notify(ctx); /* wakeup thread */
451: }
452:
453: /* Cancel the event */
454: pevent_cancel(ev);
455:
456: /* Unlock context */
457: DBG(PEVENT, "unregister ev %p in ctx %p: unlock", ev, ctx);
458: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
459: }
460:
461: /*
462: * Trigger an event.
463: */
464: void
465: pevent_trigger(struct pevent *ev)
466: {
467: struct pevent_ctx *ctx;
468:
469: /* Sanity check */
470: if (ev == NULL)
471: return;
472:
473: /* Get context */
474: ctx = ev->ctx;
475: DBG(PEVENT, "trigger ev %p in ctx %p", ev, ctx);
476: assert(ev->magic == PEVENT_MAGIC);
477:
478: /* Lock context */
479: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
480:
481: /* If event already canceled, bail */
482: if ((ev->flags & PEVENT_CANCELED) != 0)
483: goto done;
484:
485: /* Mark event as having occurred */
486: PEVENT_SET_OCCURRED(ctx, ev);
487:
488: /* Wake up thread if event is still in the queue */
489: if ((ev->flags & PEVENT_ENQUEUED) != 0)
490: pevent_ctx_notify(ctx);
491:
492: done:
493: /* Unlock context */
494: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
495: }
496:
497: /*
498: * Get event info.
499: */
500: int
501: pevent_get_info(struct pevent *ev, struct pevent_info *info)
502: {
503: if (ev == NULL) {
504: errno = ENXIO;
505: return (-1);
506: }
507: assert(ev->magic == PEVENT_MAGIC);
508: memset(info, 0, sizeof(*info));
509: info->type = ev->type;
510: switch (ev->type) {
511: case PEVENT_READ:
512: case PEVENT_WRITE:
513: info->u.fd = ev->u.fd;
514: break;
515: case PEVENT_TIME:
516: info->u.millis = ev->u.millis;
517: break;
518: case PEVENT_MESG_PORT:
519: info->u.port = ev->u.port;
520: break;
521: case PEVENT_USER:
522: break;
523: default:
524: errno = EINVAL;
525: return (-1);
526: }
527: return (0);
528: }
529:
530: /*
531: * Event thread entry point.
532: */
533: static void *
534: pevent_ctx_main(void *arg)
535: {
536: struct pevent_ctx *const ctx = arg;
537: struct timeval now;
538: struct pollfd *fd;
539: struct pevent *ev;
540: struct pevent *next_ev;
541: int poll_idx;
542: int timeout;
543: int r;
544:
545: /* Push cleanup hook */
546: pthread_cleanup_push(pevent_ctx_main_cleanup, ctx);
547: assert(ctx->magic == PEVENT_CTX_MAGIC);
548:
549: /* Lock context */
550: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
551:
552: /* Safety belts */
553: pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
554:
555: /* Get current time */
556: gettimeofday(&now, NULL);
557: DBG(PEVENT, "ctx %p thread starting", ctx);
558:
559: loop:
560: /* Are there any events left? */
561: if (TAILQ_EMPTY(&ctx->events)) {
562: DBG(PEVENT, "ctx %p thread exiting", ctx);
563: goto done;
564: }
565:
566: /* Make sure ctx->fds array is long enough */
567: if (ctx->fds_alloc < 1 + ctx->nrwevents) {
568: const u_int new_alloc = roundup(1 + ctx->nrwevents, 16);
569: void *mem;
570:
571: if ((mem = REALLOC(ctx->mtype, ctx->fds,
572: new_alloc * sizeof(*ctx->fds))) == NULL)
573: alogf(LOG_ERR, "%s: %m", "realloc");
574: else {
575: ctx->fds = mem;
576: ctx->fds_alloc = new_alloc;
577: }
578: }
579:
580: /* If we were intentionally woken up, read the wakeup byte */
581: if (ctx->notified) {
582: DBG(PEVENT, "ctx %p thread was notified", ctx);
583: (void)read(ctx->pipe[0], &pevent_byte, 1);
584: ctx->notified = 0;
585: }
586:
587: /* Add event for the notify pipe */
588: poll_idx = 0;
589: if (ctx->fds_alloc > 0) {
590: fd = &ctx->fds[poll_idx++];
591: memset(fd, 0, sizeof(*fd));
592: fd->fd = ctx->pipe[0];
593: fd->events = POLLRDNORM;
594: }
595:
596: /* Fill in rest of poll() array */
597: timeout = INFTIM;
598: TAILQ_FOREACH(ev, &ctx->events, next) {
599: switch (ev->type) {
600: case PEVENT_READ:
601: case PEVENT_WRITE:
602: {
603: if (poll_idx >= ctx->fds_alloc) {
604: ev->poll_idx = -1;
605: break;
606: }
607: ev->poll_idx = poll_idx++;
608: fd = &ctx->fds[ev->poll_idx];
609: memset(fd, 0, sizeof(*fd));
610: fd->fd = ev->u.fd;
611: fd->events = (ev->type == PEVENT_READ) ?
612: POLLRDNORM : POLLWRNORM;
613: break;
614: }
615: case PEVENT_TIME:
616: {
617: struct timeval remain;
618: int millis;
619:
620: /* Compute milliseconds until event */
621: if (timercmp(&ev->when, &now, <=))
622: millis = 0;
623: else {
624: timersub(&ev->when, &now, &remain);
625: millis = remain.tv_sec * 1000;
626: millis += remain.tv_usec / 1000;
627: }
628:
629: /* Remember the minimum delay */
630: if (timeout == INFTIM || millis < timeout)
631: timeout = millis;
632: break;
633: }
634: default:
635: break;
636: }
637: }
638:
639: /* Mark non-poll() events that have occurred */
640: TAILQ_FOREACH(ev, &ctx->events, next) {
641: assert(ev->magic == PEVENT_MAGIC);
642: switch (ev->type) {
643: case PEVENT_MESG_PORT:
644: if (mesg_port_qlen(ev->u.port) > 0)
645: PEVENT_SET_OCCURRED(ctx, ev);
646: break;
647: default:
648: break;
649: }
650: if ((ev->flags & PEVENT_OCCURRED) != 0)
651: timeout = 0; /* don't delay */
652: }
653:
654: #if PDEL_DEBUG
655: /* Debugging */
656: DBG(PEVENT, "ctx %p thread event list:", ctx);
657: TAILQ_FOREACH(ev, &ctx->events, next)
658: DBG(PEVENT, "\tev %p", ev);
659: #endif
660:
661: /* Wait for something to happen */
662: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
663: DBG(PEVENT, "ctx %p thread sleeping", ctx);
664: r = poll(ctx->fds, poll_idx, timeout);
665: DBG(PEVENT, "ctx %p thread woke up", ctx);
666: assert(ctx->magic == PEVENT_CTX_MAGIC);
667: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
668:
669: /* Check for errors */
670: if (r == -1 && errno != EINTR) {
671: alogf(LOG_CRIT, "%s: %m", "poll");
672: assert(0);
673: }
674:
675: /* Update current time */
676: gettimeofday(&now, NULL);
677:
678: /* Mark poll() events that have occurred */
679: for (ev = TAILQ_FIRST((&ctx->events)); ev != NULL; ev = next_ev) {
680: next_ev = TAILQ_NEXT(ev, next);
681: assert(ev->magic == PEVENT_MAGIC);
682: switch (ev->type) {
683: case PEVENT_READ:
684: case PEVENT_WRITE:
685: if (ev->poll_idx == -1)
686: break;
687: fd = &ctx->fds[ev->poll_idx];
688: if ((fd->revents & ((ev->type == PEVENT_READ) ?
689: READABLE_EVENTS : WRITABLE_EVENTS)) != 0)
690: PEVENT_SET_OCCURRED(ctx, ev);
691: break;
692: case PEVENT_TIME:
693: if (timercmp(&ev->when, &now, <=))
694: PEVENT_SET_OCCURRED(ctx, ev);
695: break;
696: default:
697: break;
698: }
699: }
700:
701: /* Service all events that are marked as having occurred */
702: while (1) {
703:
704: /* Find next event that needs service */
705: ev = TAILQ_FIRST(&ctx->events);
706: if (ev == NULL || (ev->flags & PEVENT_OCCURRED) == 0)
707: break;
708: DBG(PEVENT, "ctx %p thread servicing ev %p", ctx, ev);
709:
710: /* Detach event and service it while keeping a reference */
711: DBG(PEVENT, "ev %p refs %d -> %d (for servicing)",
712: ev, ev->refs, ev->refs + 1);
713: ev->refs++;
714: PEVENT_DEQUEUE(ctx, ev);
715: pevent_ctx_service(ev);
716: }
717:
718: /* Spin again */
719: DBG(PEVENT, "ctx %p thread spin again", ctx);
720: goto loop;
721:
722: done:;
723: /* Done */
724: pthread_cleanup_pop(1);
725: return (NULL);
726: }
727:
728: /*
729: * Cleanup routine for event thread.
730: */
731: static void
732: pevent_ctx_main_cleanup(void *arg)
733: {
734: struct pevent_ctx *const ctx = arg;
735:
736: DBG(PEVENT, "ctx %p thread cleanup", ctx);
737: ctx->thread = 0;
738: pevent_ctx_unref(ctx); /* release thread's reference */
739: }
740:
741: /*
742: * Service an event.
743: *
744: * This is called with an extra reference on the event which is
745: * removed by pevent_ctx_execute().
746: */
747: static void
748: pevent_ctx_service(struct pevent *ev)
749: {
750: struct pevent_ctx *const ctx = ev->ctx;
751: pthread_t tid;
752:
753: /* Does handler want to run in its own thread? */
754: if ((ev->flags & PEVENT_OWN_THREAD) != 0) {
755: if ((errno = pthread_create(&tid,
756: NULL, pevent_ctx_execute, ev)) != 0) {
757: alogf(LOG_ERR,
758: "can't spawn thread for event %p: %m", ev);
759: pevent_cancel(ev); /* removes the reference */
760: return;
761: }
762: pthread_detach(tid);
763: DBG(PEVENT, "dispatched thread %p for ev %p", tid, ev);
764: return;
765: }
766:
767: /* Execute handler with context unlocked */
768: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
769: pevent_ctx_execute(ev);
770: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
771: }
772:
773: /*
774: * Execute an event handler.
775: *
776: * Grab the user mutex, if any, check if event was canceled,
777: * execute handler, release mutex.
778: *
779: * This is called with an extra reference on the event, which is
780: * removed by this function.
781: *
782: * This should be NOT be called with a lock on the event context.
783: */
784: static void *
785: pevent_ctx_execute(void *arg)
786: {
787: struct pevent *const ev = arg;
788: struct pevent_ctx *const ctx = ev->ctx;
789: int r;
790:
791: /* Sanity check */
792: assert(ev->magic == PEVENT_MAGIC);
793:
794: /* Register cleanup hook */
795: DBG(PEVENT, "ev %p being executed", ev);
796: pthread_cleanup_push(pevent_ctx_execute_cleanup, ev);
797:
798: try_again:
799: /* Acquire context mutex */
800: DBG(PEVENT, "locking ctx %p for ev %p", ctx, ev);
801: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
802:
803: /* Check for cancellation to close the cancel/timeout race */
804: if ((ev->flags & PEVENT_CANCELED) != 0) {
805: DBG(PEVENT, "ev %p was canceled", ev);
806: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
807: goto done;
808: }
809:
810: /*
811: * Acquire user mutex but avoid two potential problems:
812: *
813: * - Race window: other thread could call timer_cancel()
814: * and destroy the user mutex just before we try to
815: * acquire it; we must hold context lock to prevent this.
816: *
817: * - Lock reversal deadlock: other threads acquire the
818: * user lock before the context lock, we do the reverse.
819: *
820: * Once we've acquire both locks, we drop the context lock.
821: */
822: if (ev->mutex != NULL) {
823: MUTEX_TRYLOCK(ev->mutex, ev->mutex_count);
824: if (errno != 0) {
825: if (errno != EBUSY) {
826: alogf(LOG_ERR,
827: "can't lock mutex for event %p: %m", ev);
828: pevent_cancel(ev);
829: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
830: goto done;
831: }
832: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
833: sched_yield();
834: goto try_again;
835: }
836: ev->flags |= PEVENT_GOT_MUTEX;
837: }
838:
839: /* Remove user's event reference (we still have one though) */
840: pevent_cancel(ev);
841:
842: /* Release context mutex */
843: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
844:
845: /* Reschedule a new event if recurring */
846: if ((ev->flags & PEVENT_RECURRING) != 0) {
847: switch (ev->type) {
848: case PEVENT_READ:
849: case PEVENT_WRITE:
850: r = pevent_register(ev->ctx, ev->peventp,
851: (ev->flags & PEVENT_USER_FLAGS), ev->mutex,
852: ev->handler, ev->arg, ev->type, ev->u.fd);
853: break;
854: case PEVENT_TIME:
855: r = pevent_register(ev->ctx, ev->peventp,
856: (ev->flags & PEVENT_USER_FLAGS), ev->mutex,
857: ev->handler, ev->arg, ev->type, ev->u.millis);
858: break;
859: case PEVENT_MESG_PORT:
860: r = pevent_register(ev->ctx, ev->peventp,
861: (ev->flags & PEVENT_USER_FLAGS), ev->mutex,
862: ev->handler, ev->arg, ev->type, ev->u.port);
863: break;
864: case PEVENT_USER:
865: r = pevent_register(ev->ctx, ev->peventp,
866: (ev->flags & PEVENT_USER_FLAGS), ev->mutex,
867: ev->handler, ev->arg, ev->type);
868: break;
869: default:
870: r = -1;
871: assert(0);
872: }
873: if (r == -1) {
874: alogf(LOG_ERR,
875: "can't re-register recurring event %p: %m", ev);
876: }
877: }
878:
879: /* Execute the handler */
880: (*ev->handler)(ev->arg);
881:
882: done:;
883: /* Release user mutex and event reference */
884: pthread_cleanup_pop(1);
885: return (NULL);
886: }
887:
888: /*
889: * Clean up for pevent_ctx_execute()
890: */
891: static void
892: pevent_ctx_execute_cleanup(void *arg)
893: {
894: struct pevent *const ev = arg;
895:
896: DBG(PEVENT, "ev %p cleanup", ev);
897: assert(ev->magic == PEVENT_MAGIC);
898: if ((ev->flags & PEVENT_GOT_MUTEX) != 0)
899: MUTEX_UNLOCK(ev->mutex, ev->mutex_count);
900: _pevent_unref(ev);
901: }
902:
903: /*
904: * Wakeup event thread because the event list has changed.
905: *
906: * This assumes the mutex is locked.
907: */
908: static void
909: pevent_ctx_notify(struct pevent_ctx *ctx)
910: {
911: DBG(PEVENT, "ctx %p being notified", ctx);
912: if (!ctx->notified) {
913: (void)write(ctx->pipe[1], &pevent_byte, 1);
914: ctx->notified = 1;
915: }
916: }
917:
918: /*
919: * Cancel an event (make it so that it never gets triggered) and
920: * remove the user reference to it.
921: *
922: * This assumes the lock is held.
923: */
924: static void
925: pevent_cancel(struct pevent *ev)
926: {
927: DBG(PEVENT, "canceling ev %p", ev);
928: assert((ev->flags & PEVENT_CANCELED) == 0);
929: ev->flags |= PEVENT_CANCELED;
930: *ev->peventp = NULL;
931: _pevent_unref(ev);
932: }
933:
934: /*
935: * Returns true if the event has been canceled.
936: */
937: int
938: _pevent_canceled(struct pevent *ev)
939: {
940: assert(ev->magic == PEVENT_MAGIC);
941: return ((ev->flags & PEVENT_CANCELED) != 0);
942: }
943:
944: /*
945: * Drop a reference on an event.
946: */
947: void
948: _pevent_unref(struct pevent *ev)
949: {
950: struct pevent_ctx *const ctx = ev->ctx;
951:
952: DBG(PEVENT, "ev %p refs %d -> %d", ev, ev->refs, ev->refs - 1);
953: assert(ev->refs > 0);
954: assert(ev->magic == PEVENT_MAGIC);
955: MUTEX_LOCK(&ctx->mutex, ctx->mutex_count);
956: if (--ev->refs > 0) {
957: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
958: return;
959: }
960: assert((ev->flags & PEVENT_ENQUEUED) == 0);
961: ev->magic = ~0; /* invalidate magic number */
962: DBG(PEVENT, "freeing ev %p", ev);
963: FREE(ctx->mtype, ev);
964: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
965: }
966:
967: /*
968: * Release context lock and drop a context reference.
969: *
970: * This assumes the mutex is locked. Upon return it will be unlocked.
971: */
972: static void
973: pevent_ctx_unref(struct pevent_ctx *ctx)
974: {
975: DBG(PEVENT, "ctx %p refs %d -> %d", ctx, ctx->refs, ctx->refs - 1);
976: assert(ctx->refs > 0);
977: assert(ctx->magic == PEVENT_CTX_MAGIC);
978: if (--ctx->refs > 0) {
979: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
980: return;
981: }
982: assert(TAILQ_EMPTY(&ctx->events));
983: assert(ctx->nevents == 0);
984: assert(ctx->thread == 0);
985: (void)close(ctx->pipe[0]);
986: (void)close(ctx->pipe[1]);
987: MUTEX_UNLOCK(&ctx->mutex, ctx->mutex_count);
988: pthread_mutex_destroy(&ctx->mutex);
989: if (ctx->has_attr)
990: pthread_attr_destroy(&ctx->attr);
991: ctx->magic = ~0; /* invalidate magic number */
992: DBG(PEVENT, "freeing ctx %p", ctx);
993: FREE(ctx->mtype, ctx->fds);
994: FREE(ctx->mtype, ctx);
995: }
996:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pevent.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / util