/*-
 * Copyright (c) 2019 Tomohiro Kusumi <tkusumi@netbsd.org>
 * Copyright (c) 2019 The DragonFly Project
 * All rights reserved.
 *
 * 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 AND CONTRIBUTORS ``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.
 */

#include "fuse.h"

#include <sys/signalvar.h>
#include <sys/kern_syscall.h>

static MALLOC_DEFINE(M_FUSE_BUF, "fuse_buf", "FUSE buf");
static MALLOC_DEFINE(M_FUSE_IPC, "fuse_ipc", "FUSE ipc");

static struct objcache *fuse_ipc_objcache = NULL;
static struct objcache_malloc_args fuse_ipc_args = {
        sizeof(struct fuse_ipc), M_FUSE_IPC,
};

#if 0
static int
fuse_block_sigs(sigset_t *oldset)
{
        if (curproc) {
                sigset_t newset;
                int error;

                SIGFILLSET(newset);
                SIGDELSET(newset, SIGKILL);

                error = kern_sigprocmask(SIG_BLOCK, &newset, oldset);
                KKASSERT(!error);
                return error;
        }

        return -1;
}

static int
fuse_restore_sigs(sigset_t *oldset)
{
        if (curproc) {
                int error = kern_sigprocmask(SIG_SETMASK, oldset, NULL);
                KKASSERT(!error);
                return error;
        }

        return -1;
}
#endif

void
fuse_buf_alloc(struct fuse_buf *fbp, size_t len)
{
        fbp->buf = kmalloc(len, M_FUSE_BUF, M_WAITOK | M_ZERO);
        KKASSERT(fbp->buf);
        fbp->len = len;
}

void
fuse_buf_free(struct fuse_buf *fbp)
{
        if (fbp->buf) {
                kfree(fbp->buf, M_FUSE_BUF);
                fbp->buf = NULL;
        }
        fbp->len = 0;
}

struct fuse_ipc*
fuse_ipc_get(struct fuse_mount *fmp, size_t len)
{
        struct fuse_ipc *fip;

        fip = objcache_get(fuse_ipc_objcache, M_WAITOK);
        bzero(fip, sizeof(*fip));
        refcount_init(&fip->refcnt, 1);
        fip->fmp = fmp;
        fip->unique = atomic_fetchadd_long(&fmp->unique, 1);
        fip->done = 0;

        fuse_buf_alloc(&fip->request, sizeof(struct fuse_in_header) + len);
        fip->reply.buf = NULL;

        return fip;
}

void
fuse_ipc_put(struct fuse_ipc *fip)
{
        if (refcount_release(&fip->refcnt)) {
                fuse_buf_free(&fip->request);
                fuse_buf_free(&fip->reply);
                objcache_put(fuse_ipc_objcache, fip);
        }
}

static void
fuse_ipc_remove(struct fuse_ipc *fip)
{
        struct fuse_mount *fmp = fip->fmp;
        struct fuse_ipc *p;

        mtx_lock(&fmp->ipc_lock);
        TAILQ_FOREACH(p, &fmp->request_head, request_entry) {
                if (fip == p) {
                        TAILQ_REMOVE(&fmp->request_head, p, request_entry);
                        if (atomic_swap_int(&fip->sent, 1) == -1)
                                wakeup(fip);
                        break;
                }
        }
        TAILQ_FOREACH(p, &fmp->reply_head, reply_entry) {
                if (fip == p) {
                        TAILQ_REMOVE(&fmp->reply_head, p, reply_entry);
                        break;
                }
        }
        mtx_unlock(&fmp->ipc_lock);
}

void*
fuse_ipc_fill(struct fuse_ipc *fip, int op, uint64_t ino, struct ucred *cred)
{
        if (!cred)
                cred = curthread->td_ucred;

        fuse_fill_in_header(fuse_in(fip), fuse_in_size(fip), op, fip->unique,
            ino, cred->cr_uid, cred->cr_rgid,
            curthread->td_proc ? curthread->td_proc->p_pid : 0);

        fuse_dbgipc(fip, 0, "");

        return fuse_in_data(fip);
}

static int
fuse_ipc_wait(struct fuse_ipc *fip)
{
        int error, retry = 0;

        if (fuse_test_dead(fip->fmp)) {
                KKASSERT(!fuse_ipc_test_replied(fip));
                fuse_ipc_set_replied(fip);
                return ENOTCONN;
        }

        if (fuse_ipc_test_replied(fip))
                return 0;
again:
        tsleep_interlock(fip, 0);
        if (fuse_ipc_test_replied(fip))
                return 0;
        error = tsleep(fip, PINTERLOCKED, "ftxp", 5 * hz);
        if (!error)
                KKASSERT(fuse_ipc_test_replied(fip));

        if (error == EWOULDBLOCK) {
                if (!fuse_ipc_test_replied(fip)) {
                        if (!retry)
                                fuse_print("timeout/retry\n");
                        if (retry++ < 6)
                                goto again;
                        fuse_print("timeout\n");
                        fuse_ipc_remove(fip);
                        fuse_ipc_set_replied(fip);
                        return ETIMEDOUT;
                } else
                        fuse_dbg("EWOULDBLOCK lost race\n");
        } else if (error) {
                fuse_print("error=%d\n", error);
                fuse_ipc_remove(fip);
                fuse_ipc_set_replied(fip);
                return error;
        }

        if (fuse_test_dead(fip->fmp)) {
                KKASSERT(fuse_ipc_test_replied(fip));
                return ENOTCONN;
        }

        return 0;
}

static int
fuse_ipc_wait_sent(struct fuse_ipc *fip)
{
        int error, retry = 0;

        if (fuse_test_dead(fip->fmp)) {
                KKASSERT(!fuse_ipc_test_replied(fip));
                fuse_ipc_remove(fip);
                fuse_ipc_set_replied(fip);
                return ENOTCONN;
        }

        error = 0;

        for (;;) {
                tsleep_interlock(fip, 0);
                if (atomic_swap_int(&fip->sent, -1) == 1) {
                        error = 0;
                        break;
                }
                error = tsleep(fip, PINTERLOCKED, "ftxp", 5 * hz);
                if (error == EWOULDBLOCK) {
                        ++retry;
                        if (retry == 6) {
                                fuse_print("timeout\n");
                                error = ETIMEDOUT;
                                break;
                        }
                        fuse_print("timeout/retry\n");
                }
        }
        if (fuse_test_dead(fip->fmp))
                error = ENOTCONN;
        if (error) {
                fuse_ipc_remove(fip);
                fuse_ipc_set_replied(fip);
        }
        return error;
}

int
fuse_ipc_tx(struct fuse_ipc *fip)
{
        struct fuse_mount *fmp = fip->fmp;
        struct fuse_out_header *ohd;
        int error;

        if (fuse_test_dead(fmp)) {
                fuse_ipc_put(fip);
                return ENOTCONN;
        }

        mtx_lock(&fmp->ipc_lock);
        TAILQ_INSERT_TAIL(&fmp->reply_head, fip, reply_entry);
        TAILQ_INSERT_TAIL(&fmp->request_head, fip, request_entry);
        mtx_unlock(&fmp->ipc_lock);

        wakeup(fmp);
        KNOTE(&fmp->kq.ki_note, 0);

        error = fuse_ipc_wait(fip);
        KKASSERT(fuse_ipc_test_replied(fip));
        if (error) {
                fuse_dbgipc(fip, error, "ipc_wait");
                fuse_ipc_put(fip);
                return error;
        }

        ohd = fuse_out(fip);
        KKASSERT(ohd);
        error = ohd->error;
        if (error) {
                fuse_dbgipc(fip, error, "ipc_error");
                fuse_ipc_put(fip);
                if (error < 0)
                        error = -error;
                return error;
        }
        fuse_dbgipc(fip, 0, "done");

        return 0;
}

int
fuse_ipc_tx_noreply(struct fuse_ipc *fip)
{
        struct fuse_mount *fmp = fip->fmp;
        int error;

        if (fuse_test_dead(fmp)) {
                fuse_ipc_put(fip);
                return ENOTCONN;
        }

        mtx_lock(&fmp->ipc_lock);
        TAILQ_INSERT_TAIL(&fmp->request_head, fip, request_entry);
        mtx_unlock(&fmp->ipc_lock);

        wakeup(fmp);
        KNOTE(&fmp->kq.ki_note, 0);

        error = fuse_ipc_wait_sent(fip);
        if (error)
                fuse_ipc_put(fip);
        return error;
}

void
fuse_ipc_init(void)
{
        fuse_ipc_objcache = objcache_create("fuse_ipc", 0, 0,
            NULL, NULL, NULL,
            objcache_malloc_alloc_zero, objcache_malloc_free, &fuse_ipc_args);
}

void
fuse_ipc_cleanup(void)
{
        objcache_destroy(fuse_ipc_objcache);
}