[apple/xnu.git] / bsd / miscfs / volfs / volfs_vnops.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1998-1999 Apple Computer, Inc. All Rights Reserved.
 *
 *	Modification History:
 *
 *	  2/10/2000     Clark Warner    Added copyfile	
 *	  5/24/1999	Don Brady	Fixed security hole in get_fsvnode.
 *	 11/18/1998 Don Brady		Special case 2 to mean the root of a file system.
 *	  9/28/1998	Umesh Vaishampayan	Use the default vnode ops. Cleanup 
 *									header includes.
 *	11/12/1998	Scott Roberts	validfsnode only checks to see if the volfs mount flag is set
 *	  8/5/1998	Don Brady	fix validfsnode logic to handle a "bad" VFS_GET
 *	  7/5/1998	Don Brady	In volfs_reclaim set vp->v_data to NULL after private data is free (VFS expects a NULL).
 *	  4/5/1998	Don Brady	Changed lockstatus calls to VOP_ISLOCKED (radar #2231108);
 *	 3/25/1998	Pat Dirks	Added include for sys/attr.h, which is no longer included indirectly.
 */

#include <mach/mach_types.h>

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/resourcevar.h>
#include <sys/kernel.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/stat.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/conf.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <sys/dirent.h>
#include <sys/namei.h>
#include <sys/attr.h>
#include <sys/kdebug.h>
#include <sys/queue.h>

#include <sys/vm.h>
#include <sys/errno.h>
#include <vfs/vfs_support.h>

#include "volfs.h"

/*
 * volfs acts as a bridge between the requirements of the MacOS API and the Unix API.
 * MacOS applications describe files by a <Volume ID><Directory ID><File Name> triple.
 * The Unix API describes files by pathname.  Volfs is a virtual file system that sits over
 * the HFS VFS interface and allows files to be described by a <Volume ID>/<Directory ID>/<File Name>
 * pathname.
 *
 * The root of the volfs filesystem consists of directories named the volume ID's of all the
 * currently mounted filesystems which support the VFS vget() routine.  Each of those directories
 * supports the lookup by file ID of all files and directories within the filesystem.  When a
 * file or directory is resolved its vnode from that filesystem rather than a volfs vnode is returned
 * allowing immediate access to the target file or directory.
 *
 * Readdir on the root of the volfs filesystem returns the list of available file systems.  Readdir
 * on a filesystem node, however, returns only . and .. since it is not practical to list all
 * of the file ID's in a timely fashion and furthermore VFS does not provide a mechanism for
 * enumerating all of the file id's.
 *
 * Volume ID's are taken from the low 32 bits of the f_fsid field, formatted as a base 10 ASCII
 * string with no leading zeros (volume ID 1 is represented as "1").
 *
 * File ID's are created in same manner, with their 32 bits formatted as a base 10 ASCII
 * string with no leading zeros.
 *
 * Volfs does create a security hole since it is possible to bypass directory permissions higher
 * in the namespace tree.  This security hole is about the same as the one created by NFS which uses
 * a similar mechanism.
 */

#define VOPFUNC int (*)(void *)

/* Global vfs data structures for volfs. */
int                 (**volfs_vnodeop_p) (void *);
struct vnodeopv_entry_desc volfs_vnodeop_entries[] = {
    {&vop_default_desc, (VOPFUNC)vn_default_error},
    {&vop_strategy_desc, (VOPFUNC)err_strategy},	/* strategy */
    {&vop_bwrite_desc, (VOPFUNC)err_bwrite},		/* bwrite */
    {&vop_lookup_desc, (VOPFUNC)volfs_lookup},		/* lookup */
    {&vop_create_desc, (VOPFUNC)err_create},		/* create */
    {&vop_whiteout_desc, (VOPFUNC)err_whiteout},	/* whiteout */
    {&vop_mknod_desc, (VOPFUNC)err_mknod},		/* mknod */
    {&vop_mkcomplex_desc, (VOPFUNC)err_mkcomplex},	/* mkcomplex */
    {&vop_open_desc, (VOPFUNC)nop_open},		/* open */
    {&vop_close_desc, (VOPFUNC)nop_close},		/* close */
    {&vop_access_desc, (VOPFUNC)volfs_access},		/* access */
    {&vop_getattr_desc, (VOPFUNC)volfs_getattr},	/* getattr */
    {&vop_setattr_desc, (VOPFUNC)err_setattr},		/* setattr */
    {&vop_getattrlist_desc, (VOPFUNC)err_getattrlist},	/* getattrlist */
    {&vop_setattrlist_desc, (VOPFUNC)err_setattrlist},	/* setattrlist */
    {&vop_read_desc, (VOPFUNC)err_read},		/* read */
    {&vop_write_desc, (VOPFUNC)err_write},		/* write */
    {&vop_lease_desc, (VOPFUNC)err_lease},		/* lease */
    {&vop_ioctl_desc, (VOPFUNC)err_ioctl},		/* ioctl */
    {&vop_select_desc, (VOPFUNC)volfs_select},		/* select */
    {&vop_exchange_desc, (VOPFUNC)err_exchange},	/* exchange */
    {&vop_revoke_desc, (VOPFUNC)nop_revoke},		/* revoke */
    {&vop_mmap_desc, (VOPFUNC)err_mmap},		/* mmap */
    {&vop_fsync_desc, (VOPFUNC)err_fsync},		/* fsync */
    {&vop_seek_desc, (VOPFUNC)nop_seek},		/* seek */
    {&vop_remove_desc, (VOPFUNC)err_remove},		/* remove */
    {&vop_link_desc, (VOPFUNC)err_link},		/* link */
    {&vop_rename_desc, (VOPFUNC)err_rename},		/* rename */
    {&vop_mkdir_desc, (VOPFUNC)err_mkdir},		/* mkdir */
    {&vop_rmdir_desc, (VOPFUNC)volfs_rmdir},		/* rmdir */
    {&vop_symlink_desc, (VOPFUNC)err_symlink},		/* symlink */
    {&vop_readdir_desc, (VOPFUNC)volfs_readdir},	/* readdir */
    {&vop_readdirattr_desc, (VOPFUNC)err_readdirattr},	/* readdirattr */
    {&vop_readlink_desc, (VOPFUNC)err_readlink},	/* readlink */
    {&vop_abortop_desc, (VOPFUNC)err_abortop},		/* abortop */
    {&vop_inactive_desc, (VOPFUNC)err_inactive},	/* inactive */
    {&vop_reclaim_desc, (VOPFUNC)volfs_reclaim},	/* reclaim */
    {&vop_lock_desc, (VOPFUNC)volfs_lock},		/* lock */
    {&vop_unlock_desc, (VOPFUNC)volfs_unlock},		/* unlock */
    {&vop_bmap_desc, (VOPFUNC)err_bmap},		/* bmap */
    {&vop_print_desc, (VOPFUNC)err_print},		/* print */
    {&vop_islocked_desc, (VOPFUNC)volfs_islocked},	/* islocked */
    {&vop_pathconf_desc, (VOPFUNC)volfs_pathconf},	/* pathconf */
    {&vop_advlock_desc, (VOPFUNC)err_advlock},		/* advlock */
    {&vop_blkatoff_desc, (VOPFUNC)err_blkatoff},	/* blkatoff */
    {&vop_valloc_desc, (VOPFUNC)err_valloc},		/* valloc */
    {&vop_reallocblks_desc, (VOPFUNC)err_reallocblks},	/* reallocblks */
    {&vop_vfree_desc, (VOPFUNC)err_vfree},		/* vfree */
    {&vop_truncate_desc, (VOPFUNC)err_truncate},	/* truncate */
    {&vop_allocate_desc, (VOPFUNC)err_allocate},	/* allocate */
    {&vop_update_desc, (VOPFUNC)err_update},		/* update */
	{&vop_pgrd_desc, (VOPFUNC)err_pgrd},		/* pgrd */
	{&vop_pgwr_desc, (VOPFUNC)err_pgwr},		/* pgwr */
	{&vop_pagein_desc, (VOPFUNC)err_pagein},	/* pagein */
	{&vop_pageout_desc, (VOPFUNC)err_pageout},	/* pageout */
	{&vop_devblocksize_desc, (VOPFUNC)err_devblocksize},	/* devblocksize */
	{&vop_searchfs_desc, (VOPFUNC)err_searchfs},	/* searchfs */
        {&vop_copyfile_desc, (VOPFUNC)err_copyfile },	/* Copyfile */
	{&vop_blktooff_desc, (VOPFUNC)err_blktooff},	/* blktooff */
	{&vop_offtoblk_desc, (VOPFUNC)err_offtoblk },	/* offtoblk */
 	{&vop_cmap_desc, (VOPFUNC)err_cmap },		/* cmap */
   {(struct vnodeop_desc *) NULL, (int (*) ()) NULL}
};

/*
 * Oh what a tangled web we weave.  This structure will be used by
 * bsd/vfs/vfs_conf.c to actually do the initialization of volfs_vnodeop_p
 */
struct vnodeopv_desc volfs_vnodeop_opv_desc =
{&volfs_vnodeop_p, volfs_vnodeop_entries};

static char gDot[] = ".";
static char gDotDot[] = "..";

struct finfo {
    fsobj_id_t parID;
};

struct finfoattrbuf {
    unsigned long length;
    struct finfo fi;
};

static int validfsnode(struct mount *fsnode);

struct volfs_PLCEntry
{
	LIST_ENTRY(volfs_PLCEntry) vplc_hash_link;	/* entry's hash chain */
	TAILQ_ENTRY(volfs_PLCEntry) vplc_lru_link;	/* entry's LRU chain link */
	int32_t			vplc_fsid;
	u_int			vplc_item_id;
	uid_t			vplc_uid;
    pid_t			vplc_pid;
};

#define VOLFSPLCHASH(fsid, inum) ((((unsigned long)fsid) + (unsigned long)(inum)) & volfs_PLCHashMask)

static struct slock volfs_PLChashtable_slock;
static TAILQ_HEAD(volfs_PLCLRUListHead, volfs_PLCEntry) volfs_PLCLRUList;
static TAILQ_HEAD(volfs_PLCFreeListHead, volfs_PLCEntry) volfs_PLCFreeList;
static LIST_HEAD(, volfs_PLCEntry) *volfs_PLCHashTable;
static u_long volfs_PLCHashMask;		/* size of hash table - 1 */
static u_long volfs_PLCEntryCount;

#if DBG_VOP_TEST_LOCKS
static void DbgVopTest (int max, int error, VopDbgStoreRec *VopDbgStore, char *funcname);
#endif /* DBG_VOP_TEST_LOCKS */


/*
 * volfs_PLChashinit
 */
__private_extern__ void
volfs_PLChashinit(void)
{
	int i;
	
	TAILQ_INIT(&volfs_PLCLRUList);
	TAILQ_INIT(&volfs_PLCFreeList);
	simple_lock_init(&volfs_PLChashtable_slock);
#if MAXPLCENTRIES
	volfs_PLCHashTable = hashinit(PLCHASHSIZE, M_TEMP, &volfs_PLCHashMask);

	for (i = 0; i < PLCHASHSIZE; ++i) {
		LIST_INIT(&volfs_PLCHashTable[i]);
	};
#endif
	volfs_PLCEntryCount = 0;
}


__private_extern__ void
volfs_PLC_reclaim_entries(int entrycount)
{
#if MAXPLCENTRIES
	int i;
	struct volfs_PLCEntry *reclaim_target;
	
	simple_lock(&volfs_PLChashtable_slock);

	for (i = entrycount; i > 0; --i) {
        if (TAILQ_EMPTY(&volfs_PLCLRUList)) break;
        
        /* Pick the next entry to be recycled and free it: */
        reclaim_target = TAILQ_FIRST(&volfs_PLCLRUList);
		TAILQ_REMOVE(&volfs_PLCLRUList, reclaim_target, vplc_lru_link);
		LIST_REMOVE(reclaim_target, vplc_hash_link);
        TAILQ_INSERT_TAIL(&volfs_PLCFreeList, reclaim_target, vplc_lru_link);
	};
	
	simple_unlock(&volfs_PLChashtable_slock);
#endif
}


#if MAXPLCENTRIES
/*
 * volfs_PLCLookup
 *
 * Look up a PLC entry in the hash
 */
static int
volfs_PLCLookup(int32_t fsid, u_int target_id, uid_t uid, pid_t pid)
{
	struct volfs_PLCEntry *hash_entry;
	int result = 0;
	
	simple_lock(&volfs_PLChashtable_slock);
	LIST_FOREACH(hash_entry, &volfs_PLCHashTable[VOLFSPLCHASH(fsid, target_id)], vplc_hash_link) {
		if ((hash_entry->vplc_item_id == target_id) &&
			(hash_entry->vplc_pid == pid) &&
			(hash_entry->vplc_uid == uid) &&
			(hash_entry->vplc_fsid == fsid)) {
				result = 1;
#if 0
				if (hash_entry != TAILQ_LAST(&volfs_PLCLRUList, volfs_PLCLRUListHead)) {
					TAILQ_REMOVE(&volfs_PLCLRUList, hash_entry, vplc_lru_link);
					TAILQ_INSERT_TAIL(&volfs_PLCLRUList, hash_entry, vplc_lru_link);
				};
#endif
				break;
		};
	};
	simple_unlock(&volfs_PLChashtable_slock);
	return result;
}


static void
volfs_PLCEnter(int32_t fsid, u_int target_id, uid_t uid, pid_t pid)
{
	struct volfs_PLCEntry *new_entry;
	
	simple_lock(&volfs_PLChashtable_slock);
    if (!TAILQ_EMPTY(&volfs_PLCFreeList)) {
        new_entry = TAILQ_FIRST(&volfs_PLCFreeList);
        TAILQ_REMOVE(&volfs_PLCFreeList, new_entry, vplc_lru_link);
    } else {
        /*
        * Allocate up to the predetermined maximum number of new entries:
        * [must be done now to avoid blocking in MALLOC() with volfs_PLChashtable_slock held locked]
        */
        if (volfs_PLCEntryCount < MAXPLCENTRIES) {
            simple_unlock(&volfs_PLChashtable_slock);
            new_entry = MALLOC(new_entry, struct volfs_PLCEntry *, sizeof(struct volfs_PLCEntry), M_TEMP, M_WAITOK);
            simple_lock(&volfs_PLChashtable_slock);
            ++volfs_PLCEntryCount;
        } else {
            new_entry = TAILQ_FIRST(&volfs_PLCLRUList);
			TAILQ_REMOVE(&volfs_PLCLRUList, new_entry, vplc_lru_link);
			LIST_REMOVE(new_entry, vplc_hash_link);
        };
    };
	
    new_entry->vplc_fsid = fsid;
	new_entry->vplc_item_id = target_id;
	new_entry->vplc_uid = uid;
    new_entry->vplc_pid = pid;
	
	/* Link the new entry on the hash list for the fsid/target_id as well as the tail of the LRU list: */
	LIST_INSERT_HEAD(&volfs_PLCHashTable[VOLFSPLCHASH(fsid, target_id)], new_entry, vplc_hash_link);
	TAILQ_INSERT_TAIL(&volfs_PLCLRUList, new_entry, vplc_lru_link);
	simple_unlock(&volfs_PLChashtable_slock);
}
#endif


/*
 * volfs_reclaim - Reclaim a vnode so that it can be used for other purposes.
 *
 * Locking policy: ignored
 */
int
volfs_reclaim(ap)
    struct vop_reclaim_args /* { struct vnode *a_vp; struct proc *a_p; } */ *ap;
{
    struct vnode *vp = ap->a_vp;
    void *data = vp->v_data;

    DBG_FUNC_NAME("volfs_reclaim");
    DBG_VOP_LOCKS_DECL(1);
    DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n"));

    DBG_VOP_LOCKS_INIT(0, vp, VOPDBG_UNLOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_ZERO);

	vp->v_data = NULL;
    FREE(data, M_VOLFSNODE);

    DBG_VOP_LOCKS_TEST(0);
    return (0);
}

/*
 * volfs_access - same access policy for all vnodes and all users (file/directory vnodes
 * 		for the actual file systems are handled by actual file system)
 *
 * Locking policy: a_vp locked on input and output
 */
int
volfs_access(ap)
    struct vop_access_args	/* { struct vnode *a_vp; int  a_mode; struct
        ucred *a_cred; struct proc *a_p; } */ *ap;
{
    int 	ret_err;
    DBG_FUNC_NAME("volfs_access");
    DBG_VOP_LOCKS_DECL(1);
    DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n"));

    DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);

    /*
     * We don't need to check credentials!  FS is read-only for everyone
     */
    if ((ap->a_mode & ~(VREAD | VEXEC)) == 0)
        ret_err = 0;
    else
        ret_err = EACCES;

    DBG_VOP_LOCKS_TEST(ret_err);
    return (ret_err);
}

/*
 * volfs_getattr - fill in the attributes for this vnode
 *
 * Locking policy: don't change anything
 */
int
volfs_getattr(ap)
    struct vop_getattr_args	/* { struct vnode *a_vp; struct vattr *a_vap;
        struct ucred *a_cred; struct proc *a_p; } */ *ap;
{
    struct volfs_vndata *priv_data;
    struct vnode       *a_vp;
    struct vattr       *a_vap;
    int                 numMounts = 0;
    DBG_FUNC_NAME("volfs_getattr");
    DBG_VOP_LOCKS_DECL(1);
    DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n"));

    DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_POS);

    a_vp = ap->a_vp;
    a_vap = ap->a_vap;

    priv_data = a_vp->v_data;

    a_vap->va_type = VDIR;
    a_vap->va_mode = 0444;	/* Yup, hard - coded to read - only */
    a_vap->va_nlink = 2;
    a_vap->va_uid = 0;		/* Always owned by root */
    a_vap->va_gid = 0;		/* Always part of group 0 */
    a_vap->va_fsid = (int) a_vp->v_mount->mnt_stat.f_fsid.val[0];
    a_vap->va_fileid = priv_data->nodeID;

    /*
     * If it's the root vnode calculate its size based on the number of eligible
     * file systems
     */
    if (priv_data->vnode_type == VOLFS_ROOT)
      {
        register struct mount *mp, *nmp;

        simple_lock(&mountlist_slock);
        for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
            if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, ap->a_p)) {
                nmp = mp->mnt_list.cqe_next;
                continue;
            }

            if (mp != a_vp->v_mount && validfsnode(mp))
                numMounts++;

            simple_lock(&mountlist_slock);
            nmp = mp->mnt_list.cqe_next;
            vfs_unbusy(mp, ap->a_p);
        }
        simple_unlock(&mountlist_slock);

        DBG_VOP(("found %d file systems that volfs can support\n", numMounts));
        a_vap->va_size = (numMounts + 2) * VLFSDIRENTLEN;
      }
    else
      {
        a_vap->va_size = 2 * VLFSDIRENTLEN;
      }
    DBG_VOP(("va_size = %d, VLFSDIRENTLEN = %ld\n", (int) a_vap->va_size, VLFSDIRENTLEN));
    a_vap->va_blocksize = 512;

    a_vap->va_atime.tv_sec = boottime.tv_sec;
    a_vap->va_atime.tv_nsec = 0;

    a_vap->va_mtime.tv_sec = boottime.tv_sec;
    a_vap->va_mtime.tv_nsec = 0;

    a_vap->va_ctime.tv_sec = boottime.tv_sec;
    a_vap->va_ctime.tv_nsec = 0;

    a_vap->va_gen = 0;
    a_vap->va_flags = 0;
    a_vap->va_rdev = 0;
    a_vap->va_bytes = a_vap->va_size;
    a_vap->va_filerev = 0;
    a_vap->va_vaflags = 0;

    DBG_VOP_LOCKS_TEST(0);
    return (0);
}

/*
 * volfs_select - just say OK.  Only possible op is readdir
 *
 * Locking policy: ignore
 */
int
volfs_select(ap)
    struct vop_select_args	/* { struct vnode *a_vp; int  a_which; int
				 * a_fflags; struct ucred *a_cred; void * a_wql; struct
        proc *a_p; } */ *ap;
{
    DBG_VOP(("volfs_select called\n"));

    return (1);
}

/*
 * vofls_rmdir - not possible to remove directories in volfs
 *
 * Locking policy: a_dvp & a_vp - locked on entry, unlocked on exit
 */
int
volfs_rmdir(ap)
    struct vop_rmdir_args	/* { struct vnode *a_dvp; struct vnode *a_vp;
        struct componentname *a_cnp; } */ *ap;
{
    DBG_VOP(("volfs_rmdir called\n"));
    if (ap->a_dvp == ap->a_vp) {
		(void) nop_rmdir(ap);
		return (EINVAL);
    } else
		return (err_rmdir(ap));
}

/*
 * volfs_readdir - Get directory entries
 *
 * Directory listings are only produced for the root volfs node.  Filesystems
 * just return . & ..
 * Filesystems contained within the volfs root are named by the decimal
 * equivalent of the f_fsid.val[0] from their mount structure (typically
 * the device id of the volume).  The maximum length for a name, then is
 * 10 characters.
 *
 * Locking policy: a_vp locked on entry and exit
 */
int
volfs_readdir(ap)
    struct vop_readdir_args	/* { struct vnode *a_vp; struct uio *a_uio;
				 * struct ucred *a_cred; int *a_eofflag; int
        *ncookies; u_long **a_cookies; } */ *ap;
{
    struct volfs_vndata *priv_data;
    register struct uio *uio = ap->a_uio;
    int                 error = 0;
    size_t              count, lost;
    int                 rec_offset;
    struct dirent       local_dir;
    int                 i;
    int					starting_resid;
    off_t               off;
    DBG_FUNC_NAME("volfs_readdir");
    DBG_VOP_LOCKS_DECL(1);

    DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS);
    DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n"));

    DBG_VOP(("\tuio_offset = %d, uio_resid = %d\n", (int) uio->uio_offset, uio->uio_resid));
	/* We assume it's all one big buffer... */
    if (uio->uio_iovcnt > 1)
    	DBG_VOP(("\tuio->uio_iovcnt = %d?\n", uio->uio_iovcnt));

	off = uio->uio_offset;
    priv_data = ap->a_vp->v_data;
    starting_resid = uio->uio_resid;
    count = uio->uio_resid;
 
    /* Make sure we don't return partial entries. */
    count -= (uio->uio_offset + count) & (VLFSDIRENTLEN - 1);
    if (count <= 0)
		{
        DBG_VOP(("volfs_readdir: Not enough buffer to read in entries\n"));
        DBG_VOP_LOCKS_TEST(EINVAL);
        return (EINVAL);
		}
    /*
     * Make sure we're starting on a directory boundary
     */
    if (off & (VLFSDIRENTLEN - 1))
        {
        DBG_VOP_LOCKS_TEST(EINVAL);
        return (EINVAL);
        }
    rec_offset = off / VLFSDIRENTLEN;
    lost = uio->uio_resid - count;
    uio->uio_resid = count;
    uio->uio_iov->iov_len = count;

    local_dir.d_reclen = VLFSDIRENTLEN;
    /*
     * We must synthesize . and ..
     */
    DBG_VOP(("\tstarting ... uio_offset = %d, uio_resid = %d\n",
            (int) uio->uio_offset, uio->uio_resid));
    if (rec_offset == 0)
      {
        DBG_VOP(("\tAdding .\n"));
        /*
         * Synthesize .
         */
        local_dir.d_fileno = priv_data->nodeID;
        local_dir.d_type = DT_DIR;
        local_dir.d_namlen = 1;
        local_dir.d_name[0] = '.';
        for (i = 1; i < MAXVLFSNAMLEN; i++)
            local_dir.d_name[i] = 0;
        error = uiomove((char *) &local_dir, VLFSDIRENTLEN, uio);
        DBG_VOP(("\t   after adding ., uio_offset = %d, uio_resid = %d\n",
                (int) uio->uio_offset, uio->uio_resid));
        rec_offset++;
      }
    if (rec_offset == 1)
      {
        DBG_VOP(("\tAdding ..\n"));
        /*
         * Synthesize ..
         * We only have two levels in the volfs hierarchy.  Root's
         * .. points to itself and the second level points to root,
         * hence we've hardcoded d_fileno for .. here
         */
        local_dir.d_fileno = ROOT_DIRID;
        local_dir.d_type = DT_DIR;
        local_dir.d_namlen = 2;
        local_dir.d_name[0] = '.';
        local_dir.d_name[1] = '.';
        for (i = 2; i < MAXVLFSNAMLEN; i++)
            local_dir.d_name[i] = 0;
        error = uiomove((char *) &local_dir, VLFSDIRENTLEN, uio);
        rec_offset++;
        DBG_VOP(("\t   after adding .., uio_offset = %d, uio_resid = %d\n",
                (int) uio->uio_offset, uio->uio_resid));
      }

    /*
     * OK, we've given them the . & .. entries.  If this is a
     * filesystem node then we've gone as far as we're going
     * to go
     */
    if (priv_data->vnode_type == VOLFS_FSNODE)
        {
        *ap->a_eofflag = 1;	/* we got all the way to the end */
        DBG_VOP_LOCKS_TEST(error);
        return (error);
        }

    if (rec_offset > 1) {
        register struct mount *mp, *nmp;
        int					validnodeindex;
        struct proc 		*p = uio->uio_procp;

        validnodeindex = 1;	/* we always have "." and ".." */

        simple_lock(&mountlist_slock);
        for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
            if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
                nmp = mp->mnt_list.cqe_next;
                continue;
            }

            if (mp != ap->a_vp->v_mount && validfsnode(mp))
                validnodeindex++;

            if (rec_offset == validnodeindex)
              {
                local_dir.d_fileno = mp->mnt_stat.f_fsid.val[0];
                local_dir.d_type = DT_DIR;
                local_dir.d_reclen = VLFSDIRENTLEN;
                DBG_VOP(("\tAdding dir entry %d for offset %d\n", mp->mnt_stat.f_fsid.val[0], rec_offset));
                local_dir.d_namlen = sprintf(&local_dir.d_name[0], "%d", mp->mnt_stat.f_fsid.val[0]);
                error = uiomove((char *) &local_dir, VLFSDIRENTLEN, uio);
                DBG_VOP(("\t   after adding entry '%s', uio_offset = %d, uio_resid = %d\n",
                         &local_dir.d_name[0], (int) uio->uio_offset, uio->uio_resid));
                rec_offset++;
              }

            simple_lock(&mountlist_slock);
            nmp = mp->mnt_list.cqe_next;
            vfs_unbusy(mp, p);
        }
        simple_unlock(&mountlist_slock);

        if (mp == (void *) &mountlist)
            *ap->a_eofflag = 1;	/* we got all the way to the end */
    }

    uio->uio_resid += lost;
    if (starting_resid == uio->uio_resid)
        uio->uio_offset = 0;

    DBG_VOP(("\tExiting, uio_offset = %d, uio_resid = %d, ap->a_eofflag = %d\n",
            (int) uio->uio_offset, uio->uio_resid, *ap->a_eofflag));

    DBG_VOP_LOCKS_TEST(error);
    return (error);
}


/*
 * validfsnode - test to see if a file system supports VGET
 *
 * This can cause context switching, so caller should be lock safe
 */
static int
validfsnode(struct mount *fsnode)
{

	/*
	 * Just check to see if the the mount flag is set, if it is we assume the
	 * file system supports all of volfs symantecs
	 */

    if ((! (fsnode->mnt_kern_flag & MNTK_UNMOUNT)) && (fsnode->mnt_flag & MNT_DOVOLFS))
		return 1;
	else 
		return 0;
}

/*
 * volfs_lock - Lock an inode.
 * If its already locked, set the WANT bit and sleep.
 *
 * Locking policy: handled by lockmgr
 */
int
volfs_lock(ap)
    struct vop_lock_args	/* { struct vnode *a_vp; int a_flags; struct
        proc *a_p; } */ *ap;
{	
    int                 retval;
    struct volfs_vndata *priv_data;
    DBG_FUNC_NAME("volfs_lock");
    DBG_VOP_LOCKS_DECL(1);
#if 0
	KERNEL_DEBUG((FSDBG_CODE(DBG_FSVN, 0)) | DBG_FUNC_START,
		     (unsigned int)ap->a_vp, (unsigned int)ap->a_flags, (unsigned int)ap->a_p, 0, 0);
#endif
    DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n"));

    DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_UNLOCKED, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_ZERO);
    
    priv_data = (struct volfs_vndata *) ap->a_vp->v_data;
    retval = lockmgr(&priv_data->lock, ap->a_flags, &ap->a_vp->v_interlock, ap->a_p);
    DBG_VOP_LOCKS_TEST(retval);
#if 0
	KERNEL_DEBUG((FSDBG_CODE(DBG_FSVN, 0)) | DBG_FUNC_END,
		     (unsigned int)ap->a_vp, (unsigned int)ap->a_flags, (unsigned int)ap->a_p, retval, 0);
#endif
    return (retval);
}

/*
 * volfs_unlock - Unlock an inode.
 *
 * Locking policy: handled by lockmgr
 */
int
volfs_unlock(ap)
    struct vop_unlock_args	/* { struct vnode *a_vp; int a_flags; struct
        proc *a_p; } */ *ap;
{
    int                 retval;
    struct volfs_vndata *priv_data;
    DBG_FUNC_NAME("volfs_unlock");
    DBG_VOP_LOCKS_DECL(1);
#if 0
	KERNEL_DEBUG((FSDBG_CODE(DBG_FSVN, 4)) | DBG_FUNC_START,
		     (unsigned int)ap->a_vp, (unsigned int)ap->a_flags, (unsigned int)ap->a_p, 0, 0);
#endif
    DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n"));

    DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_LOCKED, VOPDBG_ZERO);

    priv_data = (struct volfs_vndata *) ap->a_vp->v_data;
    retval = lockmgr(&priv_data->lock, ap->a_flags | LK_RELEASE,
		     &ap->a_vp->v_interlock, ap->a_p);

    DBG_VOP_LOCKS_TEST(retval);
#if 0
	KERNEL_DEBUG((FSDBG_CODE(DBG_FSVN, 4)) | DBG_FUNC_END,
		     (unsigned int)ap->a_vp, (unsigned int)ap->a_flags, (unsigned int)ap->a_p, retval, 0);
#endif
    return (retval);
}

/*
 * volfs_islocked - Check for a locked inode.
 *
 * Locking policy: ignore
 */
int
volfs_islocked(ap)
    struct vop_islocked_args /* { struct vnode *a_vp; } */ *ap;
{
    int                 retval;
    struct volfs_vndata *priv_data;

    DBG_FUNC_NAME("volfs_islocked");
    DBG_VOP_LOCKS_DECL(1);
    //DBG_VOP_PRINT_FUNCNAME();DBG_VOP(("\n"));

    DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_ZERO);
    priv_data = (struct volfs_vndata *) ap->a_vp->v_data;
    retval = lockstatus(&priv_data->lock);

    DBG_VOP_LOCKS_TEST(retval);
    return (retval);
}

/*
 * volfs_pathconf - Return POSIX pathconf information applicable to ufs filesystems.
 *
 * Locking policy: a_vp locked on input and output
 */
int
volfs_pathconf(ap)
    struct vop_pathconf_args	/* { struct vnode *a_vp; int a_name; int
        *a_retval; } */ *ap;
{
    DBG_VOP(("volfs_pathconf called\n"));

    switch (ap->a_name)
      {
        case _PC_LINK_MAX:
            *ap->a_retval = LINK_MAX;
            return (0);
        case _PC_NAME_MAX:
            *ap->a_retval = NAME_MAX;
            return (0);
        case _PC_PATH_MAX:
            *ap->a_retval = PATH_MAX;
            return (0);
        case _PC_PIPE_BUF:
            *ap->a_retval = PIPE_BUF;
            return (0);
        case _PC_CHOWN_RESTRICTED:
            *ap->a_retval = 1;
            return (0);
        case _PC_NO_TRUNC:
            *ap->a_retval = 1;
            return (0);
        default:
            return (EINVAL);
      }
    /* NOTREACHED */
}


/*
 * Call VOP_GETATTRLIST on a given vnode
 */
static int
vp_getattrlist(struct vnode *vp, struct attrlist alist, void *attrbufptr, size_t bufsize, unsigned long options, struct proc *p) {
	struct iovec iov;
	struct uio bufuio;
	
	iov.iov_base = (char *)attrbufptr;
	iov.iov_len = bufsize;
	
	bufuio.uio_iov = &iov;
	bufuio.uio_iovcnt = 1;
	bufuio.uio_offset = 0;
	bufuio.uio_resid = iov.iov_len;
	bufuio.uio_segflg = UIO_SYSSPACE;
	bufuio.uio_rw = UIO_READ;
	bufuio.uio_procp = p;
	
    return VOP_GETATTRLIST(vp, &alist, &bufuio, p->p_ucred, p);
}

/* 
 * get_parentvp() - internal routine that tries to lookup the parent of vpp.
 * On success, *vpp is the parent vp and is returned locked and the original child 
 * is left unlocked. On failure, the original child will be locked upon return.
 */
static int
get_parentvp(struct vnode **vpp, struct mount *mp, struct proc *p)
{
	int result;
	struct attrlist alist;
	struct finfoattrbuf finfobuf;
	struct vnode *child_vp = *vpp;

	alist.bitmapcount = 5;
	alist.reserved = 0;
	alist.commonattr = ATTR_CMN_PAROBJID;
	alist.volattr = 0;
	alist.dirattr = 0;
	alist.fileattr = 0;
	alist.forkattr = 0;
	result = vp_getattrlist(child_vp, alist, &finfobuf, sizeof(finfobuf), 0, p);
	if (result)
		return result;
	
	/* Release the child vnode before trying to acquire its parent
	   to avoid vnode deadlock problems with parsing code
	   coming top-down through the directory hierarchy: */
	VOP_UNLOCK(child_vp, 0, p);
	
	/* Shift attention to the parent directory vnode: */
	result = VFS_VGET(mp, &finfobuf.fi.parID.fid_objno, vpp);
	if (result) { 
		/* Make sure child_vp is still locked on exit: */
		vn_lock(child_vp, LK_EXCLUSIVE | LK_RETRY, p);
	}
	
	return result;
}	


/*
 * Look up the parent directory of a given vnode.
 */
static int
lookup_parent(u_int id, struct vnode *child_vp, struct vnode **parent_vp, struct proc *p)
{
	struct nameidata nd;
	struct componentname *cnp = &nd.ni_cnd;
    struct filedesc *fdp = p->p_fd;
	int error;

	*parent_vp = NULL;
	
    /*
     * Special case lookups for root's parent directory,
     * recognized by its special id of "1":
     */
    if (id != 1) {
        VREF(child_vp);
        nd.ni_startdir = child_vp;
        NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, (caddr_t)&gDotDot, p);
    } else {
        struct vnode *root_vp;
        
        error = VFS_ROOT(child_vp->v_mount, &root_vp);
        if (error) return error;
        VOP_UNLOCK(root_vp, 0, p);			/* Hold on to the reference */
        nd.ni_startdir = root_vp;
        NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, (caddr_t)&gDot, p);
    };
	nd.ni_cnd.cn_cred = nd.ni_cnd.cn_proc->p_ucred;
    
    /* Since we can't hit any symlinks, use the source path string directly: */
    cnp->cn_pnbuf = nd.ni_dirp;
    nd.ni_pathlen = strlen(cnp->cn_pnbuf);
	cnp->cn_pnlen = nd.ni_pathlen + 1;
    cnp->cn_flags |= (HASBUF | SAVENAME);

	nd.ni_loopcnt = 0;

	if ((nd.ni_rootdir = fdp->fd_rdir) == NULL) nd.ni_rootdir = rootvnode;
	cnp->cn_nameptr = cnp->cn_pnbuf;
    if (error = lookup(&nd)) {
        cnp->cn_pnbuf = NULL;
        return (error);
    }
    /*
     * Check for symbolic link
     */
    if (cnp->cn_flags & ISSYMLINK) return ENOENT;
    if (nd.ni_vp == child_vp) return ELOOP;

    *parent_vp = nd.ni_vp;
    return 0;
}


/*
 * 	verify_fullpathaccess(ret_vnode);
 */

static int
verify_fullpathaccess(u_int id, struct vnode *targetvp, struct proc *p) {
	struct vnode *vp, *parent_vp;
	struct mount *mp = targetvp->v_mount;
	struct attrlist alist;
	struct finfoattrbuf finfobuf;
	int result;
	struct filedesc *fdp = p->p_fd;	/* pointer to file descriptor state */
	u_int target_id;
	u_long vp_id;
	
#if 0
	KERNEL_DEBUG((FSDBG_CODE(DBG_FSVN, 12)) | DBG_FUNC_START,
		     (unsigned int)targetvp, (unsigned int)mp, (unsigned int)p, 0, 0);
#endif

	vp = targetvp;
	vp_id = vp->v_id;
	if (vp->v_type != VDIR) {
	  
		/* The target is a file: get the parent directory. */
		result = get_parentvp(&vp, mp, p);
		if (result) goto err_exit;
	        	
		/* At this point, targetvp is unlocked (but still referenced), and
		   vp is the parent directory vnode, held locked */
	};

	
#if MAXPLCENTRIES
	if (volfs_PLCLookup(mp->mnt_stat.f_fsid.val[0], id, p->p_ucred->cr_uid, p->p_pid)) goto lookup_success;
#endif
	/* Keep going up until either the process's root or the process's working directory is hit,
	   either one of which are potential valid starting points for a full pathname: */
    target_id = id;
	while (vp != NULL && (!((vp->v_flag & VROOT) ||	/* Hit "/" */
			 (vp == fdp->fd_cdir) ||	/* Hit process's working directory */
	         (vp == fdp->fd_rdir)))) {	/* Hit process chroot()-ed root */
	     
	     /* At this point, vp is some directory node and it's always locked */
	    /* Unlock the starting directory for namei(), retaining a reference... */
		VOP_UNLOCK(vp, 0, p);

		if (result = lookup_parent(target_id, vp, &parent_vp, p)) {
			/* 
			 * If the lookup fails with EACCES and the targetvp is a directory,
			 * we should try again using get_parentvp(). Without this check, 
			 * directories that you can navigate to but not traverse will 
			 * disappear when clicked in the Finder.
			 */
			if (result == EACCES && vp == targetvp && vp->v_type == VDIR && (vp->v_flag & VROOT) == 0) {
				vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
				parent_vp = vp;
				if (get_parentvp(&parent_vp, mp, p)) {
					/* on error, vp is still locked... unlock for lookup_err_exit path */
					VOP_UNLOCK(vp, 0, p);
				} else {
					/* on success, vp is returned unlocked, parent_vp is returned locked */
					result = 0;
				}
			};
			if (result) goto lookup_err_exit;
		};
		
		if (vp != targetvp) {
			vrele(vp);					/* Completely done with that vp now... */
		};
		
		vp = parent_vp;
        target_id = 0;					/* It's unknown at this point */
		
		if (((result = VOP_ACCESS(vp, VEXEC, p->p_ucred, p)) != 0) &&
			((result = VOP_ACCESS(vp, VREAD, p->p_ucred, p)) != 0)) {
			VOP_UNLOCK(vp, 0, p);
			goto lookup_err_exit;
		};
	};

#if MAXPLCENTRIES
	volfs_PLCEnter(mp->mnt_stat.f_fsid.val[0], id, p->p_ucred->cr_uid, p->p_pid);
#endif

lookup_success:
    /* Success: the caller has complete access to the initial vnode: */
	result = 0;
	
	if (vp && vp != targetvp) VOP_UNLOCK(vp, 0, p);

lookup_err_exit:
	if (vp && vp != targetvp) {
		vrele(vp);
		vn_lock(targetvp, LK_EXCLUSIVE | LK_RETRY, p);
		if (vp_id != targetvp->v_id || targetvp->v_type == VBAD) {
			result = EAGAIN;  /* vnode was recycled */
		}
	};
		
err_exit:
#if 0
	KERNEL_DEBUG((FSDBG_CODE(DBG_FSVN, 12)) | DBG_FUNC_END,
		     (unsigned int)targetvp, (unsigned int)mp, (unsigned int)p, result, 0);
#endif
	return result;
};


/*
 * get_fsvnode - internal routine to create a vnode for a file system.  Called with mount pointer,
 *   id of filesystem to lookup and pointer to vnode pointer to fill in
 */
static int
get_fsvnode(our_mount, id, ret_vnode)
    struct mount       *our_mount;
    int id;
    struct vnode      **ret_vnode;
{
    register struct mount *mp;
    struct mount       *cur_mount;
    struct vnode       *cur_vnode;
    struct volfs_vndata *cur_privdata;
	int					retval;

    //DBG_VOP(("volfs: get_fsvnode called\n"));

    /*
     * OK, first look up the matching mount on the list of mounted file systems
     */
    cur_mount = NULL;
    simple_lock(&mountlist_slock);
    for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = mp->mnt_list.cqe_next)
      {
        if (validfsnode(mp) && mp->mnt_stat.f_fsid.val[0] == id)
          {
            cur_mount = mp;
            break;
          }
      }
    simple_unlock(&mountlist_slock);

    if (cur_mount == NULL) {
        /*
         * No mounted file system by the specified ID currently exists in the system.
         *
         * XXX We could deal with a vnode that is still hanging about for an FS that
         * does not exists or has been unmounted now, or count on the update below
         * to happen later...
         */
        *ret_vnode = NULL;
        return ENOENT;
    };

    /*
     * Now search the list attached to the mount structure to
     * see if this vnode is already floating around
     */
search_vnodelist:
    cur_vnode = our_mount->mnt_vnodelist.lh_first;
    while (cur_vnode != NULL)
      {
        cur_privdata = (struct volfs_vndata *) cur_vnode->v_data;
        if (cur_privdata->nodeID == id)
            {
            if (cur_privdata->fs_mount != cur_mount) {
                DBG_VOP(("volfs get_fsvnode: Updating fs_mount for vnode 0x%08lX (id = %d) from 0x%08lX to 0x%08lX...\n",
                         (unsigned long)cur_vnode,
                         cur_privdata->nodeID,
                         (unsigned long)cur_privdata->fs_mount,
                         (unsigned long)cur_mount));
                cur_privdata->fs_mount = cur_mount;
            };
            break;
            }
        cur_vnode = cur_vnode->v_mntvnodes.le_next;
      }

    //DBG_VOP(("\tfinal cur_mount: 0x%x\n",cur_mount));
    if (cur_vnode) {
        /* If vget returns an error, cur_vnode will not be what we think it is, try again */
        if (vget(cur_vnode, LK_EXCLUSIVE, current_proc()) != 0) {
            goto search_vnodelist;
        };
        }
    else
      {
        MALLOC(cur_privdata, struct volfs_vndata *,
               sizeof(struct volfs_vndata), M_VOLFSNODE, M_WAITOK);
        retval = getnewvnode(VT_VOLFS, our_mount, volfs_vnodeop_p, &cur_vnode);
        if (retval != 0) {
            FREE(cur_privdata, M_VOLFSNODE);
            return retval;
        };
			
        cur_privdata->vnode_type = VOLFS_FSNODE;
        cur_privdata->nodeID = id;

        cur_privdata->fs_mount = cur_mount;
        lockinit(&cur_privdata->lock, PINOD, "volfsnode", 0, 0);
        lockmgr(&cur_privdata->lock, LK_EXCLUSIVE, (struct slock *)0, current_proc());
        cur_vnode->v_data = cur_privdata;
        cur_vnode->v_type = VDIR;
        DBG_VOP(("get_fsvnode returned with new node of "));
        DBG_VOP_PRINT_VNODE_INFO(cur_vnode);DBG_VOP(("\n"));
      }

    *ret_vnode = cur_vnode;

    return (0);
}


/*
 * get_filevnode - returns the vnode for the given id within a filesystem.  The parent vnode
 * 	   is a filesystem, id is the 32-bit id of the file/directory and ret_vnode is a pointer
 *		to a vnode pointer
 */
static int
get_filevnode(parent_fs, id, ret_vnode, p)
    struct mount      	*parent_fs;
    u_int 				id;
    struct vnode     	**ret_vnode;
    struct proc 		*p;
{
    int                 retval;

again:
	/*
	 * Special case 2 to mean the root of a file system
	 */
	if (id == 2)
		retval = VFS_ROOT(parent_fs, ret_vnode);
	else
    	retval = VFS_VGET(parent_fs, &id, ret_vnode);
	if (retval) goto error;

    retval = verify_fullpathaccess(id, *ret_vnode, p);
	if (retval) {
		/* An error was encountered verifying that the caller has,
		   in fact, got access all the way from "/" or their working
		   directory to the specified item...
		 */
		vput(*ret_vnode);
		*ret_vnode = NULL;
		/* vnode was recycled during access verification. */
		if (retval == EAGAIN) {
			goto again;
		}
	};

error:
    return (retval);
}


int
volfs_lookup(ap)
    struct vop_lookup_args	/* { struct vnode *a_dvp; struct vnode
        **a_vpp; struct componentname *a_cnp; } */ *ap;
{
    struct volfs_vndata *priv_data;
    char				*cnp;
    long				namelen;
    struct mount		*parent_fs;
    int					unlocked_parent = 0, isdot_or_dotdot = 0;
    int                 ret_err = ENOENT;
    DBG_FUNC_NAME("volfs_lookup");
    DBG_VOP_LOCKS_DECL(2);

#if 0
	KERNEL_DEBUG((FSDBG_CODE(DBG_FSVN, 8)) | DBG_FUNC_START,
		     (unsigned int)ap->a_dvp, (unsigned int)ap->a_cnp, (unsigned int)p, 0, 0);
#endif

    DBG_VOP(("volfs_lookup called, name = %s, namelen = %ld\n", ap->a_cnp->cn_nameptr, ap->a_cnp->cn_namelen));

    DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS);
    DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS);
    DBG_VOP_PRINT_FUNCNAME();DBG_VOP(("\n"));
    DBG_VOP(("\t"));DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP(("\n"));
	if (ap->a_cnp->cn_flags & LOCKPARENT)
		DBG_VOP(("\tLOCKPARENT is set\n"));
	if (ap->a_cnp->cn_flags & ISLASTCN)
		{
		DBG_VOP(("\tISLASTCN is set\n"));
		if (ap->a_cnp->cn_nameiop == DELETE || ap->a_cnp->cn_nameiop == RENAME)		/* XXX PPD Shouldn't we check for CREATE, too? */
			{
			ret_err = EROFS;
			goto Err_Exit;
			}
		}
	priv_data = ap->a_dvp->v_data;
	cnp = ap->a_cnp->cn_nameptr;
	namelen = ap->a_cnp->cn_namelen;
	
#if VOLFS_DEBUG
    switch (priv_data->vnode_type) {
        case VOLFS_ROOT:
            DBG_VOP(("\tparent directory (vnode 0x%08lX) vnode_type is VOLFS_ROOT.\n", (unsigned long)ap->a_dvp));
            break;

        case VOLFS_FSNODE:
            DBG_VOP(("\tparent directory (vnode 0x%08lX) vnode_type is VOLFS_FSNODE, nodeID = %d, fs_mount = 0x%08lX.\n",
                     (unsigned long)ap->a_dvp,
                     priv_data->nodeID,
                     (unsigned long)priv_data->fs_mount));

        default:
            DBG_VOP(("\tparent directory (vnode 0x%08lX) has unknown vnode_type (%d), nodeID = %d.\n",
                     (unsigned long)ap->a_dvp,
                     priv_data->vnode_type,
                     priv_data->nodeID));
    };
#endif	/* VOLFS_DEBUG */

	/* first check for "." and ".." */
	if (cnp[0] == '.')
	{
		if (namelen == 1)
		{
			/* "." requested */
			isdot_or_dotdot = 1;
		    *ap->a_vpp = ap->a_dvp;
		    VREF(*ap->a_vpp);
            DBG_VOP_LOCKS_TEST(0);
            ret_err = 0;
		}
		else if (cnp[1] == '.' && namelen == 2)	
		{
			/* ".." requested */
			isdot_or_dotdot = 1;
			ret_err = volfs_root(ap->a_dvp->v_mount, ap->a_vpp);
		}
	}

	/* then look for special file system root symbol ('@') */
	else if (cnp[0] == '@')
	{
		if ((namelen == 1) && (priv_data->vnode_type != VOLFS_ROOT)) {
			parent_fs = priv_data->fs_mount;
			if (!(ap->a_cnp->cn_flags & LOCKPARENT) || !(ap->a_cnp->cn_flags & ISLASTCN)) {
				VOP_UNLOCK(ap->a_dvp, 0, ap->a_cnp->cn_proc);
				unlocked_parent = 1;
			};
			ret_err = VFS_ROOT(parent_fs, ap->a_vpp);
        } else {
            DBG_VOP(("volfs_lookup: pathname = '@' but namelen = %ld and parent vnode_type = %d.\n", namelen, priv_data->vnode_type));
            *ap->a_vpp = NULL;
            ret_err = ENOENT;
        };
	}

	/* finally, just look for numeric ids... */
	else if (namelen <= 10 && cnp[0] > '0' && cnp[0] <= '9') /* 10 digits max lead digit must be 1 - 9 */
	{
		char	*check_ptr;
		u_long	id;

		id = strtoul(cnp, &check_ptr, 10);

    	/*
		 * strtol will leave us at the first non-numeric character.
		 * we've checked to make sure the component name does
		 * begin with a numeric so check_ptr must wind up on
		 * the terminating null or there was other junk following the
		 * number
		 */
		if ((check_ptr - cnp) == namelen)
		{
		    if (priv_data->vnode_type == VOLFS_ROOT)
				ret_err = get_fsvnode(ap->a_dvp->v_mount, id, ap->a_vpp);
		    else {
		    	parent_fs = priv_data->fs_mount;
                        if (!(ap->a_cnp->cn_flags & LOCKPARENT) || !(ap->a_cnp->cn_flags & ISLASTCN)) {
                                VOP_UNLOCK(ap->a_dvp, 0, ap->a_cnp->cn_proc);
                                unlocked_parent = 1;
                        };
                        ret_err = get_filevnode(parent_fs, id, ap->a_vpp, ap->a_cnp->cn_proc);
			}
		}
	}

	if (!isdot_or_dotdot && *ap->a_vpp && VPARENT(*ap->a_vpp) == NULL && ap->a_dvp != *ap->a_vpp) {
		if (VPARENT(ap->a_dvp) == *ap->a_vpp) {
			panic("volfs: ap->a_dvp 0x%x has parent == a_vpp 0x%x\n",
				  ap->a_dvp, *ap->a_vpp);
		}
		vget(ap->a_dvp, 0, ap->a_cnp->cn_proc);
		VPARENT(*ap->a_vpp) = ap->a_dvp;
	}

	if (!unlocked_parent && (!(ap->a_cnp->cn_flags & LOCKPARENT) || !(ap->a_cnp->cn_flags & ISLASTCN))) {
		VOP_UNLOCK(ap->a_dvp, 0, ap->a_cnp->cn_proc);
	};

	/* XXX PPD Should we do something special in case LOCKLEAF isn't set? */

Err_Exit:

	DBG_VOP_UPDATE_VP(1, *ap->a_vpp);
	DBG_VOP_LOCKS_TEST(ret_err);
    
#if 0
	KERNEL_DEBUG((FSDBG_CODE(DBG_FSVN, 8)) | DBG_FUNC_START,
		     (unsigned int)ap->a_dvp, (unsigned int)ap->a_cnp, (unsigned int)p, ret_err, 0);
#endif
    return (ret_err);
}

#if DBG_VOP_TEST_LOCKS

#if 0
static void DbgLookupTest(	char *funcname, struct componentname  *cnp, struct vnode *dvp, struct vnode *vp)
{
    int 		flags = cnp->cn_flags;
    int 		nameiop = cnp->cn_nameiop;

    DBG_VOP (("%s: Action:", funcname));
    switch (nameiop)
        {
        case LOOKUP:
            PRINTIT ("LOOKUP");
            break;
        case CREATE:
            PRINTIT ("CREATE");
            break;
        case DELETE:
            PRINTIT ("DELETE");
            break;
        case RENAME:
            PRINTIT ("RENAME");
            break;
        default:
            PRINTIT ("!!!UNKNOWN!!!!");
            break;
            }
    PRINTIT(" flags: 0x%x ",flags );
    if (flags & LOCKPARENT)
        PRINTIT (" Lock Parent");
    if (flags & ISLASTCN)
        PRINTIT (" Last Action");
    PRINTIT("\n");

    if (dvp)
        {
        PRINTIT ("%s: Parent vnode exited ", funcname);
    if (VOP_ISLOCKED(dvp))
            PRINTIT("LOCKED\n");
        else
            PRINTIT("UNLOCKED\n");
        }
    if (vp && vp==dvp)
        {
        PRINTIT ("%s: Found and Parent are the same\n", funcname);
        }
    else if (vp)
        {
        PRINTIT ("%s: Found vnode exited ", funcname);
    if (VOP_ISLOCKED(vp))
            PRINTIT("LOCKED\n");
        else
            PRINTIT("UNLOCKED\n");
        }
    else
        PRINTIT ("%s: Found vnode exited NULL\n", funcname);


}
#endif

static void DbgVopTest( int maxSlots,
                 int retval,
                 VopDbgStoreRec *VopDbgStore,
                 char *funcname)
{
    int index;

    for (index = 0; index < maxSlots; index++)
      {
        if (VopDbgStore[index].id != index) {
            PRINTIT("%s: DBG_VOP_LOCK: invalid id field (%d) in target entry (#%d).\n", funcname, VopDbgStore[index].id, index);
		return;
        };

        if ((VopDbgStore[index].vp != NULL) &&
            ((VopDbgStore[index].vp->v_data==NULL)))
            continue;

        switch (VopDbgStore[index].inState)
          {
            case VOPDBG_IGNORE:
            case VOPDBG_SAME:
                /* Do Nothing !!! */
                break;
            case VOPDBG_LOCKED:
            case VOPDBG_UNLOCKED:
            case VOPDBG_LOCKNOTNIL:
              {
                  if (VopDbgStore[index].vp == NULL && (VopDbgStore[index].inState != VOPDBG_LOCKNOTNIL)) {
                      PRINTIT ("%s: InState check: Null vnode ptr in entry #%d\n", funcname, index);
                  } else if (VopDbgStore[index].vp != NULL) {
                      switch (VopDbgStore[index].inState)
                        {
                          case VOPDBG_LOCKED:
                          case VOPDBG_LOCKNOTNIL:
                              if (VopDbgStore[index].inValue == 0)
                                {
                                  PRINTIT ("%s: %d Entry: not LOCKED:", funcname, index); DBG_VOP(("\n"));
                                }
                              break;
                          case VOPDBG_UNLOCKED:
                              if (VopDbgStore[index].inValue != 0)
                                {
                                  PRINTIT ("%s: %d Entry: not UNLOCKED:", funcname, index); DBG_VOP(("\n"));
                                }
                              break;
                        }
                  }
                  break;
              }
            default:
                PRINTIT ("%s: DBG_VOP_LOCK on entry: bad lock test value: %d\n", funcname, VopDbgStore[index].errState);
          }


        if (retval != 0)
          {
            switch (VopDbgStore[index].errState)
              {
                case VOPDBG_IGNORE:
                    /* Do Nothing !!! */
                    break;
                case VOPDBG_LOCKED:
                case VOPDBG_UNLOCKED:
                case VOPDBG_SAME:
                  {
                      if (VopDbgStore[index].vp == NULL) {
                          PRINTIT ("%s: ErrState check: Null vnode ptr in entry #%d\n", funcname, index);
                      } else {
                          VopDbgStore[index].outValue = VOP_ISLOCKED(VopDbgStore[index].vp);
                          switch (VopDbgStore[index].errState)
                            {
                              case VOPDBG_LOCKED:
                                  if (VopDbgStore[index].outValue == 0)
                                    {
                                      PRINTIT ("%s: %d Error: not LOCKED:", funcname, index); DBG_VOP(("\n"));
                                    }
                                  break;
                              case VOPDBG_UNLOCKED:
                                  if (VopDbgStore[index].outValue != 0)
                                    {
                                      PRINTIT ("%s: %d Error: not UNLOCKED:", funcname, index); DBG_VOP(("\n"));
                                    }
                                  break;
                              case VOPDBG_SAME:
                                  if (VopDbgStore[index].outValue != VopDbgStore[index].inValue)
                                      PRINTIT ("%s: Error: In/Out locks are DIFFERENT: 0x%x, inis %d and out is %d\n", funcname, (u_int)VopDbgStore[index].vp, VopDbgStore[index].inValue, VopDbgStore[index].outValue);
                                  break;
                            }
                      }
                      break;
                  }
                case VOPDBG_LOCKNOTNIL:
                    if (VopDbgStore[index].vp != NULL) {
                    VopDbgStore[index].outValue = VOP_ISLOCKED(VopDbgStore[index].vp);
                        if (VopDbgStore[index].outValue == 0)
                            PRINTIT ("%s: Error: %d Not LOCKED: 0x%x\n", funcname, index, (u_int)VopDbgStore[index].vp);
                    }
                    break;
                default:
                    PRINTIT ("%s: Error: bad lock test value: %d\n", funcname, VopDbgStore[index].errState);
              }
          }
        else
          {
            switch (VopDbgStore[index].outState)
              {
                case VOPDBG_IGNORE:
                    /* Do Nothing !!! */
                    break;
                case VOPDBG_LOCKED:
                case VOPDBG_UNLOCKED:
                case VOPDBG_SAME:
                    if (VopDbgStore[index].vp == NULL) {
                        PRINTIT ("%s: OutState: Null vnode ptr in entry #%d\n", funcname, index);
                    };
                    if (VopDbgStore[index].vp != NULL)
                      {
                    VopDbgStore[index].outValue = VOP_ISLOCKED(VopDbgStore[index].vp);
                        switch (VopDbgStore[index].outState)
                          {
                            case VOPDBG_LOCKED:
                                if (VopDbgStore[index].outValue == 0)
                                  {
                                    PRINTIT ("%s: %d Out: not LOCKED:", funcname, index); DBG_VOP(("\n"));
                                  }
                                break;
                            case VOPDBG_UNLOCKED:
                                if (VopDbgStore[index].outValue != 0)
                                  {
                                    PRINTIT ("%s: %d Out: not UNLOCKED:", funcname, index); DBG_VOP(("\n"));
                                  }
                                break;
                            case VOPDBG_SAME:
                                if (VopDbgStore[index].outValue != VopDbgStore[index].inValue)
                                    PRINTIT ("%s: Out: In/Out locks are DIFFERENT: 0x%x, inis %d and out is %d\n", funcname, (u_int)VopDbgStore[index].vp, VopDbgStore[index].inValue, VopDbgStore[index].outValue);
                                break;
                          }
                      }
                    break;
                case VOPDBG_LOCKNOTNIL:
                    if (VopDbgStore[index].vp != NULL) {
                    if (&((struct volfs_vndata *)(VopDbgStore[index].vp->v_data))->lock == NULL)
                            PRINTIT ("%s: DBG_VOP_LOCK on out: Null lock on vnode 0x%x\n", funcname, (u_int)VopDbgStore[index].vp);
                        else {
                        VopDbgStore[index].outValue = VOP_ISLOCKED(VopDbgStore[index].vp);
                            if (VopDbgStore[index].outValue == 0)
                              {
                                PRINTIT ("%s: DBG_VOP_LOCK on out: Should be LOCKED:", funcname); DBG_VOP(("\n"));
                              }
                        }
                    }
                    break;
                default:
                    PRINTIT ("%s: DBG_VOP_LOCK on out: bad lock test value: %d\n", funcname, VopDbgStore[index].outState);
              }
          }

        VopDbgStore[index].id = -1;		/* Invalidate the entry to allow panic-free re-use */
      }	
}

#endif /* DBG_VOP_TEST_LOCKS */