/*      $NetBSD: framebuf.c,v 1.37 2022/04/19 20:32:17 rillig Exp $     */

/*
 * Copyright (c) 2007  Antti Kantee.  All Rights Reserved.
 *
 * Development of this software was supported by the
 * Finnish Cultural Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * The event portion of this code is a twisty maze of pointers,
 * flags, yields and continues.  Sincere aplogies.
 */

#include <sys/cdefs.h>
#if !defined(lint)
__RCSID("$NetBSD: framebuf.c,v 1.37 2022/04/19 20:32:17 rillig Exp $");
#endif /* !lint */

#include <sys/types.h>
#include <sys/queue.h>

#include <assert.h>
#include <errno.h>
#include <poll.h>
#include <puffs.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "puffs_priv.h"

struct puffs_framebuf {
        struct puffs_cc *pcc;   /* pcc to continue with */
        /* OR */
        puffs_framev_cb fcb;    /* non-blocking callback */
        void *fcb_arg;          /* argument for previous */

        uint8_t *buf;           /* buffer base */
        size_t len;             /* total length */

        size_t offset;          /* cursor, telloff() */
        size_t maxoff;          /* maximum offset for data, tellsize() */

        volatile int rv;        /* errno value */

        int     istat;

        TAILQ_ENTRY(puffs_framebuf) pfb_entries;
};
#define ISTAT_NODESTROY 0x01    /* indestructible by framebuf_destroy() */
#define ISTAT_INTERNAL  0x02    /* never leaves library                 */
#define ISTAT_NOREPLY   0x04    /* nuke after sending                   */
#define ISTAT_DIRECT    0x08    /* receive directly, no moveinfo        */

#define ISTAT_ONQUEUE   ISTAT_NODESTROY /* alias */

#define PUFBUF_INCRALLOC 4096
#define PUFBUF_REMAIN(p) (p->len - p->offset)

/* for poll/kqueue */
struct puffs_fbevent {
        struct puffs_cc *pcc;
        int what;
        volatile int rv;

        LIST_ENTRY(puffs_fbevent) pfe_entries;
};

static struct puffs_fctrl_io *
getfiobyfd(struct puffs_usermount *pu, int fd)
{
        struct puffs_fctrl_io *fio;

        LIST_FOREACH(fio, &pu->pu_ios, fio_entries)
                if (fio->io_fd == fd)
                        return fio;
        return NULL;
}

struct puffs_framebuf *
puffs_framebuf_make(void)
{
        struct puffs_framebuf *pufbuf;

        pufbuf = malloc(sizeof(struct puffs_framebuf));
        if (pufbuf == NULL)
                return NULL;
        memset(pufbuf, 0, sizeof(struct puffs_framebuf));

        pufbuf->buf = malloc(PUFBUF_INCRALLOC);
        if (pufbuf->buf == NULL) {
                free(pufbuf);
                return NULL;
        }
        pufbuf->len = PUFBUF_INCRALLOC;

        puffs_framebuf_recycle(pufbuf);
        return pufbuf;
}

void
puffs_framebuf_destroy(struct puffs_framebuf *pufbuf)
{

        assert((pufbuf->istat & ISTAT_NODESTROY) == 0);

        free(pufbuf->buf);
        free(pufbuf);
}

void
puffs_framebuf_recycle(struct puffs_framebuf *pufbuf)
{

        assert((pufbuf->istat & ISTAT_NODESTROY) == 0);

        pufbuf->offset = 0;
        pufbuf->maxoff = 0;
        pufbuf->istat = 0;
}

static int
reservespace(struct puffs_framebuf *pufbuf, size_t off, size_t wantsize)
{
        size_t incr;
        void *nd;

        if (off <= pufbuf->len && pufbuf->len - off >= wantsize)
                return 0;

        for (incr = PUFBUF_INCRALLOC;
            pufbuf->len + incr < off + wantsize;
            incr += PUFBUF_INCRALLOC)
                continue;

        nd = realloc(pufbuf->buf, pufbuf->len + incr);
        if (nd == NULL)
                return -1;

        pufbuf->buf = nd;
        pufbuf->len += incr;

        return 0;
}

int
puffs_framebuf_dup(struct puffs_framebuf *pb, struct puffs_framebuf **pbp)
{
        struct puffs_framebuf *newpb;

        newpb = puffs_framebuf_make();
        if (newpb == NULL) {
                errno = ENOMEM;
                return -1;
        }
        memcpy(newpb, pb, sizeof(struct puffs_framebuf));

        newpb->buf = NULL;
        newpb->len = 0;
        if (reservespace(newpb, 0, pb->maxoff) == -1) {
                puffs_framebuf_destroy(newpb);
                return -1;
        }

        memcpy(newpb->buf, pb->buf, pb->maxoff);
        newpb->istat = 0;
        *pbp = newpb;

        return 0;
}

int
puffs_framebuf_reserve_space(struct puffs_framebuf *pufbuf, size_t wantsize)
{

        return reservespace(pufbuf, pufbuf->offset, wantsize);
}

int
puffs_framebuf_putdata(struct puffs_framebuf *pufbuf,
        const void *data, size_t dlen)
{

        if (PUFBUF_REMAIN(pufbuf) < dlen)
                if (puffs_framebuf_reserve_space(pufbuf, dlen) == -1)
                        return -1;

        memcpy(pufbuf->buf + pufbuf->offset, data, dlen);
        pufbuf->offset += dlen;

        if (pufbuf->offset > pufbuf->maxoff)
                pufbuf->maxoff = pufbuf->offset;

        return 0;
}

int
puffs_framebuf_putdata_atoff(struct puffs_framebuf *pufbuf, size_t offset,
        const void *data, size_t dlen)
{

        if (reservespace(pufbuf, offset, dlen) == -1)
                return -1;

        memcpy(pufbuf->buf + offset, data, dlen);

        if (offset + dlen > pufbuf->maxoff)
                pufbuf->maxoff = offset + dlen;

        return 0;
}

int
puffs_framebuf_getdata(struct puffs_framebuf *pufbuf, void *data, size_t dlen)
{

        if (pufbuf->maxoff < pufbuf->offset + dlen) {
                errno = ENOBUFS;
                return -1;
        }

        memcpy(data, pufbuf->buf + pufbuf->offset, dlen);
        pufbuf->offset += dlen;

        return 0;
}

int
puffs_framebuf_getdata_atoff(struct puffs_framebuf *pufbuf, size_t offset,
        void *data, size_t dlen)
{

        if (pufbuf->maxoff < offset + dlen) {
                errno = ENOBUFS;
                return -1;
        }

        memcpy(data, pufbuf->buf + offset, dlen);
        return 0;
}

size_t
puffs_framebuf_telloff(struct puffs_framebuf *pufbuf)
{

        return pufbuf->offset;
}

size_t
puffs_framebuf_tellsize(struct puffs_framebuf *pufbuf)
{

        return pufbuf->maxoff;
}

size_t
puffs_framebuf_remaining(struct puffs_framebuf *pufbuf)
{

        return puffs_framebuf_tellsize(pufbuf) - puffs_framebuf_telloff(pufbuf);
}

int
puffs_framebuf_seekset(struct puffs_framebuf *pufbuf, size_t newoff)
{

        if (reservespace(pufbuf, newoff, 0) == -1)
                return -1;

        pufbuf->offset = newoff;
        return 0;
}

int
puffs_framebuf_getwindow(struct puffs_framebuf *pufbuf, size_t winoff,
        void **data, size_t *dlen)
{
        size_t winlen;

#ifdef WINTESTING
        winlen = MIN(*dlen, 32);
#else
        winlen = *dlen;
#endif

        if (reservespace(pufbuf, winoff, winlen) == -1)
                return -1;

        *data = pufbuf->buf + winoff;
        if (pufbuf->maxoff < winoff + winlen)
                pufbuf->maxoff = winoff + winlen;

        return 0;
}

void *
puffs__framebuf_getdataptr(struct puffs_framebuf *pufbuf)
{

        return pufbuf->buf;
}

static void
errnotify(struct puffs_usermount *pu, struct puffs_framebuf *pufbuf, int error)
{

        pufbuf->rv = error;
        if (pufbuf->pcc) {
                puffs__goto(pufbuf->pcc);
        } else if (pufbuf->fcb) {
                pufbuf->istat &= ~ISTAT_NODESTROY;
                pufbuf->fcb(pu, pufbuf, pufbuf->fcb_arg, error);
        } else {
                pufbuf->istat &= ~ISTAT_NODESTROY;
                puffs_framebuf_destroy(pufbuf);
        }
}

#define GETFIO(fd)                                                      \
do {                                                                    \
        fio = getfiobyfd(pu, fd);                                       \
        if (fio == NULL) {                                              \
                errno = EINVAL;                                         \
                return -1;                                              \
        }                                                               \
        if (fio->stat & FIO_WRGONE) {                                   \
                errno = ESHUTDOWN;                                      \
                return -1;                                              \
        }                                                               \
} while (0)

int
puffs_framev_enqueue_cc(struct puffs_cc *pcc, int fd,
        struct puffs_framebuf *pufbuf, int flags)
{
        struct puffs_usermount *pu = pcc->pcc_pu;
        struct puffs_fctrl_io *fio;

        /*
         * Technically we shouldn't allow this if RDGONE, but it's
         * difficult to trap write close without allowing writes.
         * And besides, there's probably a disconnect sequence in
         * the protocol, so unexpectedly getting a closed fd is
         * most likely an error condition.
         */
        GETFIO(fd);

        pufbuf->pcc = pcc;
        pufbuf->fcb = NULL;
        pufbuf->fcb_arg = NULL;

        pufbuf->offset = 0;
        pufbuf->istat |= ISTAT_NODESTROY;

        if (flags & PUFFS_FBQUEUE_URGENT)
                TAILQ_INSERT_HEAD(&fio->snd_qing, pufbuf, pfb_entries);
        else
                TAILQ_INSERT_TAIL(&fio->snd_qing, pufbuf, pfb_entries);

        puffs_cc_yield(pcc);
        if (pufbuf->rv) {
                pufbuf->istat &= ~ISTAT_NODESTROY;
                errno = pufbuf->rv;
                return -1;
        }

        return 0;
}

int
puffs_framev_enqueue_cb(struct puffs_usermount *pu, int fd,
        struct puffs_framebuf *pufbuf, puffs_framev_cb fcb, void *arg,
        int flags)
{
        struct puffs_fctrl_io *fio;

        /* see enqueue_cc */
        GETFIO(fd);

        pufbuf->pcc = NULL;
        pufbuf->fcb = fcb;
        pufbuf->fcb_arg = arg;

        pufbuf->offset = 0;
        pufbuf->istat |= ISTAT_NODESTROY;

        if (flags & PUFFS_FBQUEUE_URGENT)
                TAILQ_INSERT_HEAD(&fio->snd_qing, pufbuf, pfb_entries);
        else
                TAILQ_INSERT_TAIL(&fio->snd_qing, pufbuf, pfb_entries);

        return 0;
}

int
puffs_framev_enqueue_justsend(struct puffs_usermount *pu, int fd,
        struct puffs_framebuf *pufbuf, int reply, int flags)
{
        struct puffs_fctrl_io *fio;

        assert((pufbuf->istat & ISTAT_INTERNAL) == 0);

        GETFIO(fd);

        pufbuf->pcc = NULL;
        pufbuf->fcb = NULL;
        pufbuf->fcb_arg = NULL;

        pufbuf->offset = 0;
        pufbuf->istat |= ISTAT_NODESTROY;
        if (!reply)
                pufbuf->istat |= ISTAT_NOREPLY;

        if (flags & PUFFS_FBQUEUE_URGENT)
                TAILQ_INSERT_HEAD(&fio->snd_qing, pufbuf, pfb_entries);
        else
                TAILQ_INSERT_TAIL(&fio->snd_qing, pufbuf, pfb_entries);

        return 0;
}

/* ARGSUSED */
int
puffs_framev_enqueue_directreceive(struct puffs_cc *pcc, int fd,
        struct puffs_framebuf *pufbuf, int flags /* used in the future */)
{
        struct puffs_usermount *pu = pcc->pcc_pu;
        struct puffs_fctrl_io *fio;

        assert((pufbuf->istat & ISTAT_INTERNAL) == 0);

        fio = getfiobyfd(pu, fd);
        if (fio == NULL) {
                errno = EINVAL;
                return -1;
        }

        /* XXX: should have cur_in queue */
        assert(fio->cur_in == NULL);
        fio->cur_in = pufbuf;

        pufbuf->pcc = pcc;
        pufbuf->fcb = NULL;
        pufbuf->fcb_arg = NULL;

        pufbuf->offset = 0;
        pufbuf->istat |= ISTAT_NODESTROY | ISTAT_DIRECT;

        puffs_cc_yield(pcc);
        pufbuf->istat &= ~ISTAT_NODESTROY; /* XXX: not the right place */
        if (pufbuf->rv) {
                errno = pufbuf->rv;
                return -1;
        }

        return 0;
}

int
puffs_framev_enqueue_directsend(struct puffs_cc *pcc, int fd,
        struct puffs_framebuf *pufbuf, int flags)
{
        struct puffs_usermount *pu = pcc->pcc_pu;
        struct puffs_fctrl_io *fio;

        assert((pufbuf->istat & ISTAT_INTERNAL) == 0);

        if (flags & PUFFS_FBQUEUE_URGENT)
                abort(); /* EOPNOTSUPP for now */

        GETFIO(fd);

        pufbuf->pcc = pcc;
        pufbuf->fcb = NULL;
        pufbuf->fcb_arg = NULL;

        pufbuf->offset = 0;
        pufbuf->istat |= ISTAT_NODESTROY | ISTAT_DIRECT;

        TAILQ_INSERT_TAIL(&fio->snd_qing, pufbuf, pfb_entries);

        puffs_cc_yield(pcc);
        if (pufbuf->rv) {
                pufbuf->istat &= ~ISTAT_NODESTROY;
                errno = pufbuf->rv;
                return -1;
        }

        return 0;
}

int
puffs_framev_framebuf_ccpromote(struct puffs_framebuf *pufbuf,
        struct puffs_cc *pcc)
{

        if ((pufbuf->istat & ISTAT_ONQUEUE) == 0) {
                errno = EBUSY;
                return -1;
        }

        pufbuf->pcc = pcc;
        pufbuf->fcb = NULL;
        pufbuf->fcb_arg = NULL;
        pufbuf->istat &= ~ISTAT_NOREPLY;

        puffs_cc_yield(pcc);

        return 0;
}

int
puffs_framev_enqueue_waitevent(struct puffs_cc *pcc, int fd, int *what)
{
        struct puffs_usermount *pu = pcc->pcc_pu;
        struct puffs_fctrl_io *fio;
        struct puffs_fbevent feb;
        struct kevent kev;
        int rv, svwhat;

        svwhat = *what;

        if (*what == 0) {
                errno = EINVAL;
                return -1;
        }

        fio = getfiobyfd(pu, fd);
        if (fio == NULL) {
                errno = EINVAL;
                return -1;
        }

        feb.pcc = pcc;
        feb.what = *what & (PUFFS_FBIO_READ|PUFFS_FBIO_WRITE|PUFFS_FBIO_ERROR);

        if (*what & PUFFS_FBIO_READ)
                if ((fio->stat & FIO_ENABLE_R) == 0)
                        EV_SET(&kev, fd, EVFILT_READ, EV_ENABLE, 0, 0, fio);

        if (kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL) == -1)
                return -1;

        if (*what & PUFFS_FBIO_READ)
                fio->rwait++;
        if (*what & PUFFS_FBIO_WRITE)
                fio->wwait++;

        LIST_INSERT_HEAD(&fio->ev_qing, &feb, pfe_entries);
        puffs_cc_yield(pcc);

        assert(svwhat == *what);

        if (*what & PUFFS_FBIO_READ) {
                fio->rwait--;
                if (fio->rwait == 0 && (fio->stat & FIO_ENABLE_R) == 0) {
                        EV_SET(&kev, fd, EVFILT_READ, EV_DISABLE, 0, 0, fio);
                        rv = kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);
#if 0
                        if (rv != 0)
                                /* XXXXX oh dear */;
#endif
                }
        }
        if (*what & PUFFS_FBIO_WRITE)
                fio->wwait--;

        if (feb.rv == 0) {
                *what = feb.what;
                rv = 0;
        } else {
                *what = PUFFS_FBIO_ERROR;
                errno = feb.rv;
                rv = -1;
        }

        return rv;
}

void
puffs__framev_notify(struct puffs_fctrl_io *fio, int what)
{
        struct puffs_fbevent *fbevp;

 restart:
        LIST_FOREACH(fbevp, &fio->ev_qing, pfe_entries) {
                if (fbevp->what & what) {
                        fbevp->what = what;
                        fbevp->rv = 0;
                        LIST_REMOVE(fbevp, pfe_entries);
                        puffs_cc_continue(fbevp->pcc);
                        goto restart;
                }
        }
}

static struct puffs_framebuf *
findbuf(struct puffs_usermount *pu, struct puffs_framectrl *fctrl,
        struct puffs_fctrl_io *fio, struct puffs_framebuf *findme)
{
        struct puffs_framebuf *cand;
        int notresp = 0;

        TAILQ_FOREACH(cand, &fio->res_qing, pfb_entries)
                if (fctrl->cmpfb(pu, findme, cand, &notresp) == 0 || notresp)
                        break;

        assert(!(notresp && cand == NULL));
        if (notresp || cand == NULL)
                return NULL;

        TAILQ_REMOVE(&fio->res_qing, cand, pfb_entries);
        return cand;
}

void
puffs__framebuf_moveinfo(struct puffs_framebuf *from, struct puffs_framebuf *to)
{

        assert(from->istat & ISTAT_INTERNAL);

        /* migrate buffer */
        free(to->buf);
        to->buf = from->buf;

        /* migrate buffer info */
        to->len = from->len;
        to->offset = from->offset;
        to->maxoff = from->maxoff;

        from->buf = NULL;
        from->len = 0;
}

void
puffs__framev_input(struct puffs_usermount *pu, struct puffs_framectrl *fctrl,
        struct puffs_fctrl_io *fio)
{
        struct puffs_framebuf *pufbuf, *appbuf;
        int rv, complete;

        while ((fio->stat & FIO_DEAD) == 0 && (fio->stat & FIO_ENABLE_R)) {
                if ((pufbuf = fio->cur_in) == NULL) {
                        pufbuf = puffs_framebuf_make();
                        if (pufbuf == NULL)
                                return;
                        pufbuf->istat |= ISTAT_INTERNAL;
                        fio->cur_in = pufbuf;
                }

                complete = 0;
                rv = fctrl->rfb(pu, pufbuf, fio->io_fd, &complete);

                /* error */
                if (rv) {
                        puffs__framev_readclose(pu, fio, rv);
                        fio->cur_in = NULL;
                        return;
                }

                /* partial read, come back to fight another day */
                if (complete == 0)
                        break;

                /* else: full read, process */
                fio->cur_in = NULL;
                if ((pufbuf->istat & ISTAT_DIRECT) == 0) {
                        appbuf = findbuf(pu, fctrl, fio, pufbuf);

                        /*
                         * No request for this frame?  If fs implements
                         * gotfb, give frame to that.  Otherwise drop it.
                         */
                        if (appbuf == NULL) {
                                if (fctrl->gotfb) {
                                        pufbuf->istat &= ~ISTAT_INTERNAL;
                                        fctrl->gotfb(pu, pufbuf);
                                } else {
                                        puffs_framebuf_destroy(pufbuf);
                                }
                                continue;
                        }
                        
                        puffs__framebuf_moveinfo(pufbuf, appbuf);
                        puffs_framebuf_destroy(pufbuf);
                } else {
                        appbuf = pufbuf;
                }
                appbuf->istat &= ~ISTAT_NODESTROY;
        
                if (appbuf->pcc) {
                        puffs__cc_cont(appbuf->pcc);
                } else if (appbuf->fcb) {
                        appbuf->fcb(pu, appbuf, appbuf->fcb_arg, 0);
                } else {
                        puffs_framebuf_destroy(appbuf);
                }

                /* hopeless romantics, here we go again */
        }
}

int
puffs__framev_output(struct puffs_usermount *pu, struct puffs_framectrl *fctrl,
        struct puffs_fctrl_io *fio)
{
        struct puffs_framebuf *pufbuf;
        int rv, complete, done;

        if (fio->stat & FIO_DEAD)
                return 0;

        for (pufbuf = TAILQ_FIRST(&fio->snd_qing), done = 0;
            pufbuf && (fio->stat & FIO_DEAD) == 0 && fio->stat & FIO_ENABLE_W;
            pufbuf = TAILQ_FIRST(&fio->snd_qing)) {
                complete = 0;
                rv = fctrl->wfb(pu, pufbuf, fio->io_fd, &complete);

                if (rv) {
                        puffs__framev_writeclose(pu, fio, rv);
                        done = 1;
                        break;
                }

                /* partial write */
                if (complete == 0)
                        return done;

                /* else, complete write */
                TAILQ_REMOVE(&fio->snd_qing, pufbuf, pfb_entries);

                /* can't wait for result if we can't read */
                if (fio->stat & FIO_RDGONE) {
                        errnotify(pu, pufbuf, ENXIO);
                        done = 1;
                } else if ((pufbuf->istat & ISTAT_DIRECT)) {
                        pufbuf->istat &= ~ISTAT_NODESTROY;
                        done = 1;
                        puffs__cc_cont(pufbuf->pcc);
                } else if ((pufbuf->istat & ISTAT_NOREPLY) == 0) {
                        TAILQ_INSERT_TAIL(&fio->res_qing, pufbuf,
                            pfb_entries);
                } else {
                        pufbuf->istat &= ~ISTAT_NODESTROY;
                        puffs_framebuf_destroy(pufbuf);
                }

                /* omstart! */
        }

        return done;
}

int
puffs__framev_addfd_ctrl(struct puffs_usermount *pu, int fd, int what,
        struct puffs_framectrl *pfctrl)
{
        struct puffs_fctrl_io *fio;
        struct kevent kev[2];
        size_t nevs;
        int rv, readenable;

        nevs = pu->pu_nevs+2;
        if (reallocarr(&pu->pu_evs, nevs, sizeof(struct kevent)) != 0) {
                errno = ENOMEM;
                return -1;
        }

        fio = malloc(sizeof(struct puffs_fctrl_io));
        if (fio == NULL)
                return -1;
        memset(fio, 0, sizeof(struct puffs_fctrl_io));
        fio->io_fd = fd;
        fio->cur_in = NULL;
        fio->fctrl = pfctrl;
        TAILQ_INIT(&fio->snd_qing);
        TAILQ_INIT(&fio->res_qing);
        LIST_INIT(&fio->ev_qing);

        readenable = 0;
        if ((what & PUFFS_FBIO_READ) == 0)
                readenable = EV_DISABLE;

        if (pu->pu_state & PU_INLOOP) {
                struct stat st;
                size_t nf = 0;

                if (fstat(fd, &st) == -1)
                        goto out;
                EV_SET(&kev[nf], fd, EVFILT_READ, EV_ADD|readenable, 0, 0, fio);
                nf++;
                if (S_ISSOCK(st.st_mode)) {
                        EV_SET(&kev[nf], fd, EVFILT_WRITE,
                            EV_ADD|EV_DISABLE, 0, 0, fio);
                        nf++;
                }
                rv = kevent(pu->pu_kq, kev, nf, NULL, 0, NULL);
                if (rv == -1)
                        goto out;
        }
        if (what & PUFFS_FBIO_READ)
                fio->stat |= FIO_ENABLE_R;
        if (what & PUFFS_FBIO_WRITE)
                fio->stat |= FIO_ENABLE_W;

        LIST_INSERT_HEAD(&pu->pu_ios, fio, fio_entries);
        pu->pu_nevs = nevs;

        return 0;
out:
        free(fio);
        return -1;
}

int
puffs_framev_addfd(struct puffs_usermount *pu, int fd, int what)
{

        return puffs__framev_addfd_ctrl(pu, fd, what,
            &pu->pu_framectrl[PU_FRAMECTRL_USER]);
}

/*
 * XXX: the following en/disable should be coalesced and executed
 * only during the actual kevent call.  So feel free to fix if
 * threatened by mindblowing boredom.
 */

int
puffs_framev_enablefd(struct puffs_usermount *pu, int fd, int what)
{
        struct kevent kev;
        struct puffs_fctrl_io *fio;
        int rv = 0;

        assert((what & (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE)) != 0);

        fio = getfiobyfd(pu, fd);
        if (fio == NULL) {
                errno = ENXIO;
                return -1;
        }

        /* write is enabled in the event loop if there is output */
        if (what & PUFFS_FBIO_READ && fio->rwait == 0) {
                EV_SET(&kev, fd, EVFILT_READ, EV_ENABLE, 0, 0, fio);
                rv = kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);
        }

        if (rv == 0) {
                if (what & PUFFS_FBIO_READ)
                        fio->stat |= FIO_ENABLE_R;
                if (what & PUFFS_FBIO_WRITE)
                        fio->stat |= FIO_ENABLE_W;
        }

        return rv;
}

int
puffs_framev_disablefd(struct puffs_usermount *pu, int fd, int what)
{
        struct kevent kev[2];
        struct puffs_fctrl_io *fio;
        size_t i;
        int rv;

        assert((what & (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE)) != 0);

        fio = getfiobyfd(pu, fd);
        if (fio == NULL) {
                errno = ENXIO;
                return -1;
        }

        i = 0;
        if (what & PUFFS_FBIO_READ && fio->rwait == 0) {
                EV_SET(&kev[0], fd, EVFILT_READ, EV_DISABLE, 0, 0, fio);
                i++;
        }
        if (what & PUFFS_FBIO_WRITE && fio->stat & FIO_WR && fio->wwait == 0) {
                EV_SET(&kev[1], fd, EVFILT_WRITE, EV_DISABLE, 0, 0, fio);
                i++;
        }
        if (i)
                rv = kevent(pu->pu_kq, kev, i, NULL, 0, NULL);
        else
                rv = 0;

        if (rv == 0) {
                if (what & PUFFS_FBIO_READ)
                        fio->stat &= ~FIO_ENABLE_R;
                if (what & PUFFS_FBIO_WRITE)
                        fio->stat &= ~FIO_ENABLE_W;
        }

        return rv;
}

void
puffs__framev_readclose(struct puffs_usermount *pu,
        struct puffs_fctrl_io *fio, int error)
{
        struct puffs_framebuf *pufbuf;
        struct kevent kev;
        int notflag;

        if (fio->stat & FIO_RDGONE || fio->stat & FIO_DEAD)
                return;
        fio->stat |= FIO_RDGONE;

        if (fio->cur_in) {
                if ((fio->cur_in->istat & ISTAT_DIRECT) == 0) {
                        puffs_framebuf_destroy(fio->cur_in);
                        fio->cur_in = NULL;
                } else {
                        errnotify(pu, fio->cur_in, error);
                }
        }

        while ((pufbuf = TAILQ_FIRST(&fio->res_qing)) != NULL) {
                TAILQ_REMOVE(&fio->res_qing, pufbuf, pfb_entries);
                errnotify(pu, pufbuf, error);
        }

        EV_SET(&kev, fio->io_fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
        (void) kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);

        notflag = PUFFS_FBIO_READ;
        if (fio->stat & FIO_WRGONE)
                notflag |= PUFFS_FBIO_WRITE;

        if (fio->fctrl->fdnotfn)
                fio->fctrl->fdnotfn(pu, fio->io_fd, notflag);
}

void
puffs__framev_writeclose(struct puffs_usermount *pu,
        struct puffs_fctrl_io *fio, int error)
{
        struct puffs_framebuf *pufbuf;
        struct kevent kev;
        int notflag;

        if (fio->stat & FIO_WRGONE || fio->stat & FIO_DEAD)
                return;
        fio->stat |= FIO_WRGONE;

        while ((pufbuf = TAILQ_FIRST(&fio->snd_qing)) != NULL) {
                TAILQ_REMOVE(&fio->snd_qing, pufbuf, pfb_entries);
                errnotify(pu, pufbuf, error);
        }

        EV_SET(&kev, fio->io_fd, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
        (void) kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);

        notflag = PUFFS_FBIO_WRITE;
        if (fio->stat & FIO_RDGONE)
                notflag |= PUFFS_FBIO_READ;

        if (fio->fctrl->fdnotfn)
                fio->fctrl->fdnotfn(pu, fio->io_fd, notflag);
}

static int
removefio(struct puffs_usermount *pu, struct puffs_fctrl_io *fio, int error)
{
        struct puffs_fbevent *fbevp;

        LIST_REMOVE(fio, fio_entries);
        if (pu->pu_state & PU_INLOOP) {
                puffs__framev_readclose(pu, fio, error);
                puffs__framev_writeclose(pu, fio, error);
        }

        while ((fbevp = LIST_FIRST(&fio->ev_qing)) != NULL) {
                fbevp->rv = error;
                LIST_REMOVE(fbevp, pfe_entries);
                puffs__goto(fbevp->pcc);
        }

        /* don't bother with realloc */
        pu->pu_nevs -= 2;

        /* don't free us yet, might have some references in event arrays */
        fio->stat |= FIO_DEAD;
        LIST_INSERT_HEAD(&pu->pu_ios_rmlist, fio, fio_entries);

        return 0;

}

int
puffs_framev_removefd(struct puffs_usermount *pu, int fd, int error)
{
        struct puffs_fctrl_io *fio;

        fio = getfiobyfd(pu, fd);
        if (fio == NULL) {
                errno = ENXIO;
                return -1;
        }

        return removefio(pu, fio, error ? error : ECONNRESET);
}

void
puffs_framev_removeonclose(struct puffs_usermount *pu, int fd, int what)
{

        if (what == (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE))
                (void) puffs_framev_removefd(pu, fd, ECONNRESET);
}

void
puffs_framev_unmountonclose(struct puffs_usermount *pu, int fd, int what)
{

        /* XXX & X: unmount is non-sensible */
        puffs_framev_removeonclose(pu, fd, what);
        if (what == (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE))
                PU_SETSTATE(pu, PUFFS_STATE_UNMOUNTED);
}

void
puffs_framev_init(struct puffs_usermount *pu,
        puffs_framev_readframe_fn rfb, puffs_framev_writeframe_fn wfb,
        puffs_framev_cmpframe_fn cmpfb, puffs_framev_gotframe_fn gotfb,
        puffs_framev_fdnotify_fn fdnotfn)
{
        struct puffs_framectrl *pfctrl;

        pfctrl = &pu->pu_framectrl[PU_FRAMECTRL_USER];
        pfctrl->rfb = rfb;
        pfctrl->wfb = wfb;
        pfctrl->cmpfb = cmpfb;
        pfctrl->gotfb = gotfb;
        pfctrl->fdnotfn = fdnotfn;
}

void
puffs__framev_exit(struct puffs_usermount *pu)
{
        struct puffs_fctrl_io *fio;

        while ((fio = LIST_FIRST(&pu->pu_ios)) != NULL)
                removefio(pu, fio, ENXIO);
        free(pu->pu_evs);

        /* closing pu->pu_kq takes care of puffsfd */
}