Below is the file 'src/comm_kqueue.c' from this revision. You can also download the file.

/* FreeBSD kqueue support - Adrian Chadd */
/* [insert GPL copyright here] */

/*
 * For now this is #include'd from comm_select.c - this'll happen until
 * I or someone duplicates benno's work and breaks out the poll/select/epoll
 * support into separate files.
 */


#include "squid.h"
#include <sys/event.h>

#define KE_LENGTH        128

/* jlemon goofed up and didn't add EV_SET until fbsd 4.3 */

#ifndef EV_SET
#define EV_SET(kevp, a, b, c, d, e, f) do {     \
        (kevp)->ident = (a);                    \
        (kevp)->filter = (b);                   \
        (kevp)->flags = (c);                    \
        (kevp)->fflags = (d);                   \
        (kevp)->data = (e);                     \
        (kevp)->udata = (f);                    \
} while(0)
#endif

static void kq_update_events(int, short, PF *);
static int kq;

static struct timespec zero_timespec;

static struct kevent *kqlst;        /* kevent buffer */
static int kqmax;                /* max structs to buffer */
static int kqoff;                /* offset into the buffer */
static int max_poll_time = 1000;


void checkTimeouts(void);
int commDeferRead(int fd);


/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
/* Private functions */

void
kq_update_events(int fd, short filter, PF * handler)
{
    PF *cur_handler;
    int kep_flags;

#if 0

    int retval;
#endif

    switch (filter) {

    case EVFILT_READ:
        cur_handler = fd_table[fd].read_handler;
        break;

    case EVFILT_WRITE:
        cur_handler = fd_table[fd].write_handler;
        break;

    default:
        /* XXX bad! -- adrian */
        return;
        break;
    }

    if ((cur_handler == NULL && handler != NULL)
            || (cur_handler != NULL && handler == NULL)) {

        struct kevent *kep;

        kep = kqlst + kqoff;

        if (handler != NULL) {
            kep_flags = (EV_ADD | EV_ONESHOT);
        } else {
            kep_flags = EV_DELETE;
        }

        EV_SET(kep, (uintptr_t) fd, filter, kep_flags, 0, 0, 0);

        if (kqoff == kqmax) {
            int ret;

            ret = kevent(kq, kqlst, kqoff, NULL, 0, &zero_timespec);
            /* jdc -- someone needs to do error checking... */

            if (ret == -1) {
                perror("kq_update_events(): kevent()");
                return;
            }

            kqoff = 0;
        } else {
            kqoff++;
        }

#if 0
        if (retval < 0) {
            /* Error! */

            if (ke.flags & EV_ERROR) {
                errno = ke.data;
            }
        }

#endif

    }
}



/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
/* Public functions */


/*
 * comm_select_init
 *
 * This is a needed exported function which will be called to initialise
 * the network loop code.
 */
void
comm_select_init(void)
{
    kq = kqueue();

    if (kq < 0) {
        fatal("comm_select_init: Couldn't open kqueue fd!\n");
    }

    kqmax = getdtablesize();

    kqlst = (struct kevent *)xmalloc(sizeof(*kqlst) * kqmax);
    zero_timespec.tv_sec = 0;
    zero_timespec.tv_nsec = 0;
    bzero(backoff_fds, sizeof(backoff_fds));
}

/*
 * comm_setselect
 *
 * This is a needed exported function which will be called to register
 * and deregister interest in a pending IO state for a given FD.
 */
void
commSetSelect(int fd, unsigned int type, PF * handler,
              void *client_data, time_t timeout)
{
    fde *F = &fd_table[fd];
    assert(fd >= 0);
    assert(F->flags.open);

    if ((! F->comm_backoff) && type & COMM_SELECT_READ) {
        /* Don't add the read handler if the FD is backed off */
        kq_update_events(fd, EVFILT_READ, handler);
        F->read_handler = handler;
        F->read_data = client_data;
    }

    if (type & COMM_SELECT_WRITE) {
        kq_update_events(fd, EVFILT_WRITE, handler);
        F->write_handler = handler;
        F->write_data = client_data;
    }

    if (timeout)
        F->timeout = squid_curtime + timeout;

}

/*
 * Check all connections for new connections and input data that is to be
 * processed. Also check for connections with data queued and whether we can
 * write it out.
 */

/*
 * comm_select
 *
 * Called to do the new-style IO, courtesy of of squid (like most of this
 * new IO code). This routine handles the stuff we've hidden in
 * comm_setselect and fd_table[] and calls callbacks for IO ready
 * events.
 */

int
comm_kqueue(int msec)
{
    int num, i;
    static time_t last_timeout = 0;

    static struct kevent ke[KE_LENGTH];

    struct timespec poll_time;

    /*
     * remember we are doing NANOseconds here, not micro/milli. God knows
     * why jlemon used a timespec, but hey, he wrote the interface, not I
     *   -- Adrian
     */

    if (msec > max_poll_time)
        msec = max_poll_time;

    poll_time.tv_sec = msec / 1000;

    poll_time.tv_nsec = (msec % 1000) * 1000000;

    for (;;) {
        num = kevent(kq, kqlst, kqoff, ke, KE_LENGTH, &poll_time);
        statCounter.select_loops++;
        kqoff = 0;

        if (num >= 0)
            break;

        if (ignoreErrno(errno))
            break;

        getCurrentTime();

        return COMM_ERROR;

        /* NOTREACHED */
    }
    getCurrentTime();
    if (squid_curtime > last_timeout) {
        last_timeout = squid_curtime;
        checkTimeouts();
        commBackon();
    }
    if (num == 0)
        return COMM_OK;		/* No error.. */

    for (i = 0; i < num; i++) {
        int fd = (int) ke[i].ident;
        PF *hdl = NULL;
        fde *F = &fd_table[fd];

        if (ke[i].flags & EV_ERROR) {
            errno = ke[i].data;
            /* XXX error == bad! -- adrian */
            continue;        /* XXX! */
        }

        switch (ke[i].filter) {

        case EVFILT_READ:

            if ((hdl = F->read_handler) != NULL) {
                F->read_handler = NULL;
                hdl(fd, F->read_data);
            }

            break;

        case EVFILT_WRITE:

            if ((hdl = F->write_handler) != NULL) {
                F->write_handler = NULL;
                hdl(fd, F->write_data);
            }

            break;

        default:
            /* Bad! -- adrian */
            debug(5, 1) ("comm_select: kevent returned %d!\n", ke[i].filter);
            break;
        }
    }

    return COMM_OK;
}

void
commDeferFD(int fd)
{
	int i;
	fde *F;

	assert(fd >= 0);
	F = &fd_table[fd];
	debug(5, 3) ("commDeferFD: %d\n", fd);

	/* Find a free slot in the backoff_fds list */
	for (i = 0; i < FD_SETSIZE; i++) {
		if (!(backoff_fds[i]) || (backoff_fds[i] == fd)) {
			break;
		}
	}
	/* Make sure we can back off */
	assert(i <= FD_SETSIZE);
	assert(F->flags.open);

	/* Ok, back off */
	F->comm_backoff = 1;
	backoff_fds[i] = fd;
        kq_update_events(fd, EVFILT_READ, NULL);
}

void
commResumeFD(int fd)
{
	fde *F = &fd_table[fd];

	debug(5, 3) ("commResumeFD: %d, handler %p, data %p\n", fd, F->read_handler, F->read_data);

	/* If the FD has been modified then do nothing */
	if(!(F->read_handler) || !(F->comm_backoff)) {
		debug(5, 3) ("commResumeFD: fd=%d ignoring read_handler=%p, comm_backoff=%d\n",fd,F->read_handler,F->comm_backoff);
		F->comm_backoff=0;
		return;
	}
	/* Rightio - mark it as resuming */
	F->comm_backoff = 0;
        kq_update_events(fd, EVFILT_READ, F->read_handler);
}

void
commUpdateReadBits(int fd, PF *handler)
{
    /* Not imlpemented */
}

void
commUpdateWriteBits(int fd, PF *handler)
{
    /* Not imlpemented */
}