sys/platform/vkernel64/platform/kqueue.c

   1 /*
   2  * Copyright (c) 2006 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/types.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/malloc.h>
  39 #include <sys/systimer.h>
  40 #include <sys/sysctl.h>
  41 #include <sys/signal.h>
  42 #include <sys/interrupt.h>
  43 #include <sys/bus.h>
  44 #include <sys/time.h>
  45 #include <sys/event.h>
  46 #include <machine/cpu.h>
  47 #include <machine/globaldata.h>
  48 #include <machine/md_var.h>
  49
  50 #include <unistd.h>
  51 #include <signal.h>
  52 #include <stdlib.h>
  53 #include <fcntl.h>
  54
  55 struct kqueue_info {
  56         void (*func)(void *, struct intrframe *);
  57         void *data;
  58         int fd;
  59 };
  60
  61 static int KQueueFd = -1;
  62
  63 /*
  64  * Initialize kqueue based I/O
  65  *
  66  * Use SIGIO to get an immediate event when the kqueue has something waiting
  67  * for us.  Setup the SIGIO signal as a mailbox signal for efficiency.
  68  *
  69  * Currently only read events are supported.
  70  */
  71 void
  72 init_kqueue(void)
  73 {
  74 #if 0
  75         struct sigaction sa;
  76         bzero(&sa, sizeof(sa));
  77         /*sa.sa_mailbox = &mdcpu->gd_mailbox;*/
  78         sa.sa_flags = 0;
  79         sa.sa_handler = kqueuesig;
  80         sigemptyset(&sa.sa_mask);
  81         sigaction(SIGIO, &sa, NULL);
  82 #endif
  83         KQueueFd = kqueue();
  84         if (fcntl(KQueueFd, F_SETOWN, getpid()) < 0)
  85                 panic("Cannot configure kqueue for SIGIO, update your kernel");
  86         if (fcntl(KQueueFd, F_SETFL, O_ASYNC) < 0)
  87                 panic("Cannot configure kqueue for SIGIO, update your kernel");
  88 }
  89
  90 #if 0
  91 /*
  92  * Signal handler dispatches interrupt thread.  Use interrupt #1
  93  */
  94 static void
  95 kqueuesig(int signo)
  96 {
  97         signalintr(1);
  98 }
  99
 100 #endif
 101
 102 /*
 103  * Generic I/O event support
 104  */
 105 struct kqueue_info *
 106 kqueue_add(int fd, void (*func)(void *, struct intrframe *), void *data)
 107 {
 108         struct timespec ts = { 0, 0 };
 109         struct kqueue_info *info;
 110         struct kevent kev;
 111
 112         info = kmalloc(sizeof(*info), M_DEVBUF, M_ZERO|M_INTWAIT);
 113         info->func = func;
 114         info->data = data;
 115         info->fd = fd;
 116         EV_SET(&kev, fd, EVFILT_READ, EV_ADD|EV_ENABLE|EV_CLEAR, 0, 0, info);
 117         if (kevent(KQueueFd, &kev, 1, NULL, 0, &ts) < 0)
 118                 panic("kqueue: kevent() call could not add descriptor");
 119         return(info);
 120 }
 121
 122 #if 0
 123 /*
 124  * Medium resolution timer support
 125  */
 126 struct kqueue_info *
 127 kqueue_add_timer(void (*func)(void *, struct intrframe *), void *data)
 128 {
 129         struct kqueue_info *info;
 130
 131         info = kmalloc(sizeof(*info), M_DEVBUF, M_ZERO|M_INTWAIT);
 132         info->func = func;
 133         info->data = data;
 134         info->fd = (uintptr_t)info;
 135
 136         return(info);
 137 }
 138
 139 void
 140 kqueue_reload_timer(struct kqueue_info *info, int ms)
 141 {
 142         struct timespec ts = { 0, 0 };
 143         struct kevent kev;
 144
 145         KKASSERT(ms > 0);
 146
 147         EV_SET(&kev, info->fd, EVFILT_TIMER,
 148                 EV_ADD|EV_ENABLE|EV_ONESHOT|EV_CLEAR, 0, (uintptr_t)ms, info);
 149         if (kevent(KQueueFd, &kev, 1, NULL, 0, &ts) < 0)
 150                 panic("kqueue_reload_timer: Failed");
 151 }
 152 #endif
 153
 154 /*
 155  * Destroy a previously added kqueue event
 156  */
 157 void
 158 kqueue_del(struct kqueue_info *info)
 159 {
 160         struct timespec ts = { 0, 0 };
 161         struct kevent kev;
 162
 163         KKASSERT(info->fd >= 0);
 164         EV_SET(&kev, info->fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
 165         if (kevent(KQueueFd, &kev, 1, NULL, 0, &ts) < 0)
 166                 panic("kevent: failed to delete descriptor %d", info->fd);
 167         info->fd = -1;
 168         kfree(info, M_DEVBUF);
 169 }
 170
 171 /*
 172  * Safely called via DragonFly's normal interrupt handling mechanism.
 173  *
 174  * Calleld with the MP lock held.  Note that this is still an interrupt
 175  * thread context.
 176  */
 177 void
 178 kqueue_intr(struct intrframe *frame)
 179 {
 180         struct timespec ts;
 181         struct kevent kevary[8];
 182         int n;
 183         int i;
 184
 185         ts.tv_sec = 0;
 186         ts.tv_nsec = 0;
 187         do {
 188                 n = kevent(KQueueFd, NULL, 0, kevary, 8, &ts);
 189                 for (i = 0; i < n; ++i) {
 190                         struct kevent *kev = &kevary[i];
 191                         struct kqueue_info *info = (void *)kev->udata;
 192
 193                         info->func(info->data, frame);
 194                 }
 195         } while (n == 8);
 196 }