/*
 * Copyright (c) 2010 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Alex Hornung <ahornung (at) gmail.com>
 *
 * 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.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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 <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/vnode.h>
#include <sys/lock.h>
#include <sys/disk.h>
#include <sys/mount.h>
#include <sys/namecache.h>
#include <sys/nlookup.h>
#include <sys/proc.h>
#include <sys/devfs.h>

struct mount    *synth_mp;
struct vnode    *synth_vp;
static int      synth_inited = 0;
static int      synth_synced = 0;

struct vnode *
getsynthvnode(const char *devname)
{
        struct vnode *vp;
        struct nchandle nch;
        struct nlookupdata nd;
        struct ucred *cred = proc0.p_ucred;
        int error;

        KKASSERT(synth_inited != 0);
        KKASSERT(synth_mp != NULL);
        KKASSERT(synth_mp->mnt_ncmountpt.mount != NULL);

        /* Sync devfs/disks twice to make sure all devices are around */
        if (synth_synced < 2) {
                sync_devs();
                ++synth_synced;
        }

        error = nlookup_init_root(&nd, devname, UIO_SYSSPACE, NLC_FOLLOW,
                                  cred, &synth_mp->mnt_ncmountpt,
                                  &synth_mp->mnt_ncmountpt);

        if (error) {
                panic("synth: nlookup_init_root failed with %d", error);
                /* NOTREACHED */
        }

        error = nlookup(&nd);
        if (error == 0) {
                if (nd.nl_nch.ncp->nc_vp == NULL) {
                        kprintf("synth: nc_vp == NULL\n");
                        return (NULL);
                }
                nch = nd.nl_nch;
                cache_zero(&nd.nl_nch);
        }

        nlookup_done(&nd);
        if (error) {
                if (error != ENOENT) { /* Don't bother warning about ENOENT */
                        kprintf("synth: nlookup of %s failed with %d\n",
                            devname, error);
                }
                return (NULL);
        }

        vp = nch.ncp->nc_vp;
        /* A VX locked & refd vnode must be returned. */
        error = vget(vp, LK_EXCLUSIVE);
        cache_unlock(&nch);

        if (error) {
                kprintf("synth: could not vget vnode\n");
                return (NULL);
        }

        return (vp);
}

static void
synthinit(void *arg __unused)
{
        int error;

        if ((error = vfs_rootmountalloc("devfs", "dummy", &synth_mp))) {
                panic("synth: vfs_rootmountalloc failed with %d", error);
                /* NOTREACHED */
        }
        if ((error = VFS_MOUNT(synth_mp, NULL, NULL, proc0.p_ucred))) {
                panic("synth: vfs_mount failed with %d", error);
                /* NOTREACHED */
        }
        if ((error = VFS_ROOT(synth_mp, &synth_vp))) {
                panic("synth: vfs_root failed with %d", error);
                /* NOTREACHED */
        }
        cache_allocroot(&synth_mp->mnt_ncmountpt, synth_mp, synth_vp);
        cache_unlock(&synth_mp->mnt_ncmountpt); /* leave ref intact */
        vput(synth_vp);

        synth_inited = 1;
}

SYSINIT(synthinit, SI_SUB_VFS, SI_ORDER_ANY, synthinit, NULL);