/*-
 * 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"

static MALLOC_DEFINE(M_FUSE_NODE, "fuse_node", "FUSE node");

static struct objcache *fuse_node_objcache = NULL;
static struct objcache_malloc_args fuse_node_args = {
        sizeof(struct fuse_node), M_FUSE_NODE,
};

static int
fuse_node_cmp(struct fuse_node *p1, struct fuse_node *p2)
{
        if (p1->ino < p2->ino)
                return -1;
        if (p1->ino > p2->ino)
                return 1;
        return 0;
}

RB_PROTOTYPE2(fuse_node_tree, fuse_node, entry, fuse_node_cmp, uint64_t);
RB_GENERATE2(fuse_node_tree, fuse_node, node_entry, fuse_node_cmp,
                uint64_t, ino);

void
fuse_node_new(struct fuse_mount *fmp, uint64_t ino, enum vtype vtyp,
              struct fuse_node **fnpp)
{
        struct fuse_node *fnp;

        fnp = objcache_get(fuse_node_objcache, M_WAITOK);
        bzero(fnp, sizeof(*fnp));

        fnp->fmp = fmp;

        mtx_init(&fnp->node_lock, "fuse_node_lock");

        fnp->ino = ino;
        fnp->type = vtyp;
        fnp->size = 0;
        fnp->nlookup = 0;
        fnp->fh = 0;
        fnp->closed = false;

        if (RB_INSERT(fuse_node_tree, &fmp->node_head, fnp)) {
                panic("fuse_node_new: cannot insert %p\n", fnp);
        }

        *fnpp = fnp;
}

void
fuse_node_free(struct fuse_mount *fmp, struct fuse_node *fnp)
{
        fuse_dbg("free ino=%ju\n", fnp->ino);

        mtx_lock(&fmp->ino_lock);
        RB_REMOVE(fuse_node_tree, &fmp->node_head, fnp);
        mtx_unlock(&fmp->ino_lock);

        objcache_put(fuse_node_objcache, fnp);
}

/*
 * Allocate or find the fuse node for the specified inode number and assign
 * its vnode.
 */
int
fuse_alloc_node(struct fuse_mount *fmp, struct fuse_node *dfnp,
                uint64_t ino, enum vtype vtyp, struct vnode **vpp)
{
        struct fuse_node *fnp;
        int error;
        int allocated = 0;

        KKASSERT(dfnp->type == VDIR);
        if (vtyp == VBLK || vtyp == VCHR || vtyp == VFIFO)
                return EINVAL;

        mtx_lock(&fmp->ino_lock);
        fnp = RB_LOOKUP(fuse_node_tree, &fmp->node_head, ino);
        if (fnp == NULL) {
                fuse_node_new(fmp, ino, vtyp, &fnp);
                allocated = 1;
        }
        mtx_unlock(&fmp->ino_lock);

        error = fuse_node_vn(fnp, vpp);
        if (error) {
                if (allocated)
                        fuse_node_free(fmp, fnp);
        }
        return error;
}

/*
 * Returns exclusively locked vp
 */
int
fuse_node_vn(struct fuse_node *fnp, struct vnode **vpp)
{
        struct mount *mp = fnp->fmp->mp;
        struct vnode *vp;
        struct vnode *newvp;
        int error;

        newvp = NULL;
retry:
        error = 0;
        if (fnp->vp == NULL && newvp == NULL) {
                error = getnewvnode(VT_FUSE, mp, &newvp,
                                    VLKTIMEOUT, LK_CANRECURSE);
                if (error)
                        return error;
        }

        mtx_lock(&fnp->node_lock);

        /*
         * Check case where vp is already assigned
         */
        vp = fnp->vp;
        if (vp) {
                vhold(vp);
                mtx_unlock(&fnp->node_lock);
                error = vget(vp, LK_EXCLUSIVE | LK_RETRY);
                vdrop(vp);

                if (error)
                        goto retry;
                if (fnp->vp != vp) {
                        vput(vp);
                        goto retry;
                }

                *vpp = vp;

                if (newvp) {
                        newvp->v_type = VBAD;
                        vx_put(newvp);
                }

                return 0;
        }

        /*
         * Assign new vp, release the node lock
         */
        if (newvp == NULL) {
                mtx_unlock(&fnp->node_lock);
                goto retry;
        }

        fnp->vp = newvp;
        mtx_unlock(&fnp->node_lock);
        vp = newvp;

        /*
         * Finish setting up vp (vp is held exclusively + vx)
         */
        vp->v_type = fnp->type;
        vp->v_data = fnp;

        switch (vp->v_type) {
        case VREG:
                vinitvmio(vp, fnp->size, FUSE_BLKSIZE, -1);
                break;
        case VDIR:
                break;
        case VBLK:
        case VCHR:
                KKASSERT(0);
                vp->v_ops = &mp->mnt_vn_spec_ops;
                addaliasu(vp, umajor(0), uminor(0)); /* XXX CUSE */
                break;
        case VLNK:
                break;
        case VSOCK:
                break;
        case VFIFO:
                KKASSERT(0);
        case VDATABASE:
                break;
        default:
                KKASSERT(0);
        }

        vx_downgrade(vp);       /* VX to normal, is still exclusive */

        *vpp = vp;

        return error;
}

int
fuse_node_truncate(struct fuse_node *fnp, size_t oldsize, size_t newsize)
{
        struct vnode *vp = fnp->vp;
        int error;

        fuse_dbg("ino=%ju update size %ju -> %ju\n",
            fnp->ino, oldsize, newsize);

        fnp->attr.va_size = fnp->size = newsize;

        if (newsize < oldsize)
                error = nvtruncbuf(vp, newsize, FUSE_BLKSIZE, -1, 0);
        else
                error = nvextendbuf(vp, oldsize, newsize, FUSE_BLKSIZE,
                    FUSE_BLKSIZE, -1, -1, 0);
        return error;
}

void
fuse_node_init(void)
{
        fuse_node_objcache = objcache_create("fuse_node", 0, 0,
            NULL, NULL, NULL,
            objcache_malloc_alloc_zero, objcache_malloc_free, &fuse_node_args);
}

void
fuse_node_cleanup(void)
{
        objcache_destroy(fuse_node_objcache);
}