1 files changed, 586 insertions, 0 deletions

diff --git a/contrib/netbsd-tests/fs/puffs/h_dtfs/dtfs_vnops.c b/contrib/netbsd-tests/fs/puffs/h_dtfs/dtfs_vnops.c
new file mode 100644
index 0000000..875109c
--- /dev/null
+++ b/contrib/netbsd-tests/fs/puffs/h_dtfs/dtfs_vnops.c
@@ -0,0 +1,586 @@
+/*	$NetBSD: dtfs_vnops.c,v 1.10 2013/10/19 17:45:00 christos Exp $	*/
+
+/*
+ * Copyright (c) 2006  Antti Kantee.  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 ``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 <sys/types.h>
+#include <sys/poll.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <puffs.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <util.h>
+
+#include "dtfs.h"
+
+int
+dtfs_node_lookup(struct puffs_usermount *pu, void *opc,
+	struct puffs_newinfo *pni, const struct puffs_cn *pcn)
+{
+	struct puffs_node *pn_dir = opc;
+	struct dtfs_file *df = DTFS_CTOF(opc);
+	struct dtfs_dirent *dfd;
+	extern int straightflush;
+	int rv;
+
+	/* parent dir? */
+	if (PCNISDOTDOT(pcn)) {
+		if (df->df_dotdot == NULL)
+			return ENOENT;
+
+		assert(df->df_dotdot->pn_va.va_type == VDIR);
+		puffs_newinfo_setcookie(pni, df->df_dotdot);
+		puffs_newinfo_setvtype(pni, df->df_dotdot->pn_va.va_type);
+
+		return 0;
+	}
+
+	dfd = dtfs_dirgetbyname(df, pcn->pcn_name, pcn->pcn_namelen);
+	if (dfd) {
+		if ((pcn->pcn_flags & NAMEI_ISLASTCN) &&
+		    (pcn->pcn_nameiop == NAMEI_DELETE)) {
+			rv = puffs_access(VDIR, pn_dir->pn_va.va_mode,
+			    pn_dir->pn_va.va_uid, pn_dir->pn_va.va_gid,
+			    PUFFS_VWRITE, pcn->pcn_cred);
+			if (rv)
+				return rv;
+		}
+		puffs_newinfo_setcookie(pni, dfd->dfd_node);
+		puffs_newinfo_setvtype(pni, dfd->dfd_node->pn_va.va_type);
+		puffs_newinfo_setsize(pni, dfd->dfd_node->pn_va.va_size);
+		puffs_newinfo_setrdev(pni, dfd->dfd_node->pn_va.va_rdev);
+
+		if (straightflush)
+			puffs_flush_pagecache_node(pu, dfd->dfd_node);
+
+		return 0;
+	}
+
+	if ((pcn->pcn_flags & NAMEI_ISLASTCN)
+	    && (pcn->pcn_nameiop == NAMEI_CREATE ||
+	        pcn->pcn_nameiop == NAMEI_RENAME)) {
+		rv = puffs_access(VDIR, pn_dir->pn_va.va_mode,
+		    pn_dir->pn_va.va_uid, pn_dir->pn_va.va_gid,
+		    PUFFS_VWRITE, pcn->pcn_cred);
+		if (rv)
+			return rv;
+	}
+
+	return ENOENT;
+}
+
+int
+dtfs_node_access(struct puffs_usermount *pu, void *opc, int acc_mode,
+	const struct puffs_cred *pcr)
+{
+	struct puffs_node *pn = opc;
+
+	return puffs_access(pn->pn_va.va_type, pn->pn_va.va_mode,
+	    pn->pn_va.va_uid, pn->pn_va.va_gid, acc_mode, pcr);
+}
+
+int
+dtfs_node_setattr(struct puffs_usermount *pu, void *opc,
+	const struct vattr *va, const struct puffs_cred *pcr)
+{
+	struct puffs_node *pn = opc;
+	int rv;
+
+	/* check permissions */
+	if (va->va_flags != PUFFS_VNOVAL)
+		return EOPNOTSUPP;
+
+	if (va->va_uid != PUFFS_VNOVAL || va->va_gid != PUFFS_VNOVAL) {
+		rv = puffs_access_chown(pn->pn_va.va_uid, pn->pn_va.va_gid,
+		    va->va_uid, va->va_gid, pcr);
+		if (rv)
+			return rv;
+	}
+
+	if (va->va_mode != PUFFS_VNOVAL) {
+		rv = puffs_access_chmod(pn->pn_va.va_uid, pn->pn_va.va_gid,
+		    pn->pn_va.va_type, va->va_mode, pcr);
+		if (rv)
+			return rv;
+	}
+
+	if ((va->va_atime.tv_sec != PUFFS_VNOVAL
+	      && va->va_atime.tv_nsec != PUFFS_VNOVAL)
+	    || (va->va_mtime.tv_sec != PUFFS_VNOVAL
+	      && va->va_mtime.tv_nsec != PUFFS_VNOVAL)) {
+		rv = puffs_access_times(pn->pn_va.va_uid, pn->pn_va.va_gid,
+		    pn->pn_va.va_mode, va->va_vaflags & VA_UTIMES_NULL, pcr);
+		if (rv)
+			return rv;
+	}
+
+	if (va->va_size != PUFFS_VNOVAL) {
+		switch (pn->pn_va.va_type) {
+		case VREG:
+			dtfs_setsize(pn, va->va_size);
+			pn->pn_va.va_bytes = va->va_size;
+			break;
+		case VBLK:
+		case VCHR:
+		case VFIFO:
+			break;
+		case VDIR:
+			return EISDIR;
+		default:
+			return EOPNOTSUPP;
+		}
+	}
+
+	puffs_setvattr(&pn->pn_va, va);
+
+	return 0;
+}
+
+/* create a new node in the parent directory specified by opc */
+int
+dtfs_node_create(struct puffs_usermount *pu, void *opc,
+	struct puffs_newinfo *pni, const struct puffs_cn *pcn,
+	const struct vattr *va)
+{
+	struct puffs_node *pn_parent = opc;
+	struct puffs_node *pn_new;
+
+	if (!(va->va_type == VREG || va->va_type == VSOCK))
+		return ENODEV;
+
+	pn_new = dtfs_genfile(pn_parent, pcn, va->va_type);
+	puffs_setvattr(&pn_new->pn_va, va);
+
+	puffs_newinfo_setcookie(pni, pn_new);
+
+	return 0;
+}
+
+int
+dtfs_node_remove(struct puffs_usermount *pu, void *opc, void *targ,
+	const struct puffs_cn *pcn)
+{
+	struct puffs_node *pn_parent = opc;
+	struct puffs_node *pn = targ;
+
+	if (pn->pn_va.va_type == VDIR)
+		return EPERM;
+
+	dtfs_nukenode(targ, pn_parent, pcn->pcn_name, pcn->pcn_namelen);
+
+	if (pn->pn_va.va_nlink == 0)
+		puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N2);
+
+	return 0;
+}
+
+int
+dtfs_node_mkdir(struct puffs_usermount *pu, void *opc,
+	struct puffs_newinfo *pni, const struct puffs_cn *pcn,
+	const struct vattr *va)
+{
+	struct puffs_node *pn_parent = opc;
+	struct puffs_node *pn_new;
+
+	pn_new = dtfs_genfile(pn_parent, pcn, VDIR);
+	puffs_setvattr(&pn_new->pn_va, va);
+
+	puffs_newinfo_setcookie(pni, pn_new);
+
+	return 0;
+}
+
+int
+dtfs_node_rmdir(struct puffs_usermount *pu, void *opc, void *targ,
+	const struct puffs_cn *pcn)
+{
+	struct puffs_node *pn_parent = opc;
+	struct dtfs_file *df = DTFS_CTOF(targ);
+
+	if (!LIST_EMPTY(&df->df_dirents))
+		return ENOTEMPTY;
+
+	dtfs_nukenode(targ, pn_parent, pcn->pcn_name, pcn->pcn_namelen);
+	puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N2);
+
+	return 0;
+}
+
+int
+dtfs_node_readdir(struct puffs_usermount *pu, void *opc,
+	struct dirent *dent, off_t *readoff, size_t *reslen,
+	const struct puffs_cred *pcr,
+	int *eofflag, off_t *cookies, size_t *ncookies)
+{
+	struct puffs_node *pn = opc;
+	struct puffs_node *pn_nth;
+	struct dtfs_dirent *dfd_nth;
+
+	if (pn->pn_va.va_type != VDIR)
+		return ENOTDIR;
+	
+	dtfs_updatetimes(pn, 1, 0, 0);
+
+	*ncookies = 0;
+ again:
+	if (*readoff == DENT_DOT || *readoff == DENT_DOTDOT) {
+		puffs_gendotdent(&dent, pn->pn_va.va_fileid, *readoff, reslen);
+		(*readoff)++;
+		PUFFS_STORE_DCOOKIE(cookies, ncookies, *readoff);
+		goto again;
+	}
+
+	for (;;) {
+		dfd_nth = dtfs_dirgetnth(pn->pn_data, DENT_ADJ(*readoff));
+		if (!dfd_nth) {
+			*eofflag = 1;
+			break;
+		}
+		pn_nth = dfd_nth->dfd_node;
+
+		if (!puffs_nextdent(&dent, dfd_nth->dfd_name,
+		    pn_nth->pn_va.va_fileid,
+		    puffs_vtype2dt(pn_nth->pn_va.va_type),
+		    reslen))
+			break;
+
+		(*readoff)++;
+		PUFFS_STORE_DCOOKIE(cookies, ncookies, *readoff);
+	}
+
+	return 0;
+}
+
+int
+dtfs_node_poll(struct puffs_usermount *pu, void *opc, int *events)
+{
+	struct dtfs_mount *dtm = puffs_getspecific(pu);
+	struct dtfs_poll dp;
+	struct itimerval it;
+
+	memset(&it, 0, sizeof(struct itimerval));
+	it.it_value.tv_sec = 4;
+	if (setitimer(ITIMER_REAL, &it, NULL) == -1)
+		return errno;
+
+	dp.dp_pcc = puffs_cc_getcc(pu);
+	LIST_INSERT_HEAD(&dtm->dtm_pollent, &dp, dp_entries);
+	puffs_cc_yield(dp.dp_pcc);
+
+	*events = *events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
+	return 0;
+}
+
+int
+dtfs_node_mmap(struct puffs_usermount *pu, void *opc, vm_prot_t prot,
+	const struct puffs_cred *pcr)
+{
+	struct dtfs_mount *dtm = puffs_getspecific(pu);
+
+	if ((dtm->dtm_allowprot & prot) != prot)
+		return EACCES;
+
+	return 0;
+}
+
+int
+dtfs_node_rename(struct puffs_usermount *pu, void *opc, void *src,
+	const struct puffs_cn *pcn_src, void *targ_dir, void *targ,
+	const struct puffs_cn *pcn_targ)
+{
+	struct dtfs_dirent *dfd_src;
+	struct dtfs_file *df_targ;
+	struct puffs_node *pn_sdir = opc;
+	struct puffs_node *pn_sfile = src;
+	struct puffs_node *pn_tdir = targ_dir;
+	struct puffs_node *pn_tfile = targ;
+
+	/* check that we don't do the old amigados trick */
+	if (pn_sfile->pn_va.va_type == VDIR) {
+		if (dtfs_isunder(pn_tdir, pn_sfile))
+			return EINVAL;
+
+		if ((pcn_src->pcn_namelen == 1 && pcn_src->pcn_name[0]=='.') ||
+		    opc == src ||
+		    PCNISDOTDOT(pcn_src) ||
+		    PCNISDOTDOT(pcn_targ)) {
+			return EINVAL;
+		}
+	}
+
+	dfd_src = dtfs_dirgetbyname(DTFS_PTOF(pn_sdir),
+	    pcn_src->pcn_name, pcn_src->pcn_namelen);
+
+	/* does it still exist, or did someone race us here? */
+	if (dfd_src == NULL) {
+		return ENOENT;
+	}
+
+	/* if there's a target file, nuke it for atomic replacement */
+	if (pn_tfile) {
+		if (pn_tfile->pn_va.va_type == VDIR) {
+			df_targ = DTFS_CTOF(pn_tfile);
+			if (!LIST_EMPTY(&df_targ->df_dirents))
+				return ENOTEMPTY;
+		}
+		dtfs_nukenode(pn_tfile, pn_tdir,
+		    pcn_targ->pcn_name, pcn_targ->pcn_namelen);
+	}
+
+	/* out with the old */
+	dtfs_removedent(pn_sdir, dfd_src);
+	/* and in with the new */
+	dtfs_adddent(pn_tdir, dfd_src);
+
+	/* update name */
+	free(dfd_src->dfd_name);
+	dfd_src->dfd_name = estrndup(pcn_targ->pcn_name,pcn_targ->pcn_namelen);
+	dfd_src->dfd_namelen = strlen(dfd_src->dfd_name);
+
+	dtfs_updatetimes(src, 0, 1, 0);
+
+	return 0;
+}
+
+int
+dtfs_node_link(struct puffs_usermount *pu, void *opc, void *targ,
+	const struct puffs_cn *pcn)
+{
+	struct puffs_node *pn_dir = opc;
+	struct dtfs_dirent *dfd;
+
+	dfd = emalloc(sizeof(struct dtfs_dirent));
+	dfd->dfd_node = targ;
+	dfd->dfd_name = estrndup(pcn->pcn_name, pcn->pcn_namelen);
+	dfd->dfd_namelen = strlen(dfd->dfd_name);
+	dtfs_adddent(pn_dir, dfd);
+
+	dtfs_updatetimes(targ, 0, 1, 0);
+
+	return 0;
+}
+
+int
+dtfs_node_symlink(struct puffs_usermount *pu, void *opc,
+	struct puffs_newinfo *pni, const struct puffs_cn *pcn_src,
+	const struct vattr *va, const char *link_target)
+{
+	struct puffs_node *pn_parent = opc;
+	struct puffs_node *pn_new;
+	struct dtfs_file *df_new;
+
+	if (va->va_type != VLNK)
+		return ENODEV;
+
+	pn_new = dtfs_genfile(pn_parent, pcn_src, VLNK);
+	puffs_setvattr(&pn_new->pn_va, va);
+	df_new = DTFS_PTOF(pn_new);
+	df_new->df_linktarget = estrdup(link_target);
+	pn_new->pn_va.va_size = strlen(df_new->df_linktarget);
+
+	puffs_newinfo_setcookie(pni, pn_new);
+
+	return 0;
+}
+
+int
+dtfs_node_readlink(struct puffs_usermount *pu, void *opc,
+	const struct puffs_cred *cred, char *linkname, size_t *linklen)
+{
+	struct dtfs_file *df = DTFS_CTOF(opc);
+	struct puffs_node *pn = opc;
+
+	assert(pn->pn_va.va_type == VLNK);
+	strlcpy(linkname, df->df_linktarget, *linklen);
+	*linklen = strlen(linkname);
+
+	return 0;
+}
+
+int
+dtfs_node_mknod(struct puffs_usermount *pu, void *opc,
+	struct puffs_newinfo *pni, const struct puffs_cn *pcn,
+	const struct vattr *va)
+{
+	struct puffs_node *pn_parent = opc;
+	struct puffs_node *pn_new;
+
+	if (!(va->va_type == VBLK || va->va_type == VCHR
+	    || va->va_type == VFIFO))
+		return EINVAL;
+
+	pn_new = dtfs_genfile(pn_parent, pcn, va->va_type);
+	puffs_setvattr(&pn_new->pn_va, va);
+
+	puffs_newinfo_setcookie(pni, pn_new);
+
+	return 0;
+}
+
+#define BLOCKOFF(a,b) ((a) & ((b)-1))
+#define BLOCKLEFT(a,b) ((b) - BLOCKOFF(a,b))
+
+/*
+ * Read operation, used both for VOP_READ and VOP_GETPAGES
+ */
+int
+dtfs_node_read(struct puffs_usermount *pu, void *opc, uint8_t *buf,
+	off_t offset, size_t *resid, const struct puffs_cred *pcr, int ioflag)
+{
+	struct puffs_node *pn = opc;
+	struct dtfs_file *df = DTFS_CTOF(opc);
+	quad_t xfer, origxfer;
+	uint8_t *src, *dest;
+	size_t copylen;
+
+	if (pn->pn_va.va_type != VREG)
+		return EISDIR;
+
+	xfer = MIN(*resid, df->df_datalen - offset);
+	if (xfer < 0)
+		return EINVAL;
+
+	dest = buf;
+	origxfer = xfer;
+	while (xfer > 0) {
+		copylen = MIN(xfer, BLOCKLEFT(offset, DTFS_BLOCKSIZE));
+		src = df->df_blocks[BLOCKNUM(offset, DTFS_BLOCKSHIFT)]
+		    + BLOCKOFF(offset, DTFS_BLOCKSIZE);
+		memcpy(dest, src, copylen);
+		offset += copylen;
+		dest += copylen;
+		xfer -= copylen;
+	}
+	*resid -= origxfer;
+
+	dtfs_updatetimes(pn, 1, 0, 0);
+
+	return 0;
+}
+
+/*
+ * write operation on the wing
+ */
+int
+dtfs_node_write(struct puffs_usermount *pu, void *opc, uint8_t *buf,
+	off_t offset, size_t *resid, const struct puffs_cred *pcr, int ioflag)
+{
+	struct puffs_node *pn = opc;
+	struct dtfs_file *df = DTFS_CTOF(opc);
+	uint8_t *src, *dest;
+	size_t copylen;
+
+	if (pn->pn_va.va_type != VREG)
+		return EISDIR;
+
+	if (ioflag & PUFFS_IO_APPEND)
+		offset = pn->pn_va.va_size;
+
+	if (*resid + offset > pn->pn_va.va_size)
+		dtfs_setsize(pn, *resid + offset);
+
+	src = buf;
+	while (*resid > 0) {
+		int i;
+		copylen = MIN(*resid, BLOCKLEFT(offset, DTFS_BLOCKSIZE));
+		i = BLOCKNUM(offset, DTFS_BLOCKSHIFT);
+		dest = df->df_blocks[i]
+		    + BLOCKOFF(offset, DTFS_BLOCKSIZE);
+		memcpy(dest, src, copylen);
+		offset += copylen;
+		dest += copylen;
+		*resid -= copylen;
+	}
+
+	dtfs_updatetimes(pn, 0, 1, 1);
+
+	return 0;
+}
+
+int
+dtfs_node_pathconf(struct puffs_usermount *pu, puffs_cookie_t opc,
+	int name, register_t *retval)
+{
+
+	switch (name) {
+	case _PC_LINK_MAX:
+		*retval = LINK_MAX;
+		return 0;
+	case _PC_NAME_MAX:
+		*retval = NAME_MAX;
+		return 0;
+	case _PC_PATH_MAX:
+		*retval = PATH_MAX;
+		return 0;
+	case _PC_PIPE_BUF:
+		*retval = PIPE_BUF;
+		return 0;
+	case _PC_CHOWN_RESTRICTED:
+		*retval = 1;
+		return 0;
+	case _PC_NO_TRUNC:
+		*retval = 1;
+		return 0;
+	case _PC_SYNC_IO:
+		*retval = 1;
+		return 0;
+	case _PC_FILESIZEBITS:
+		*retval = 43; /* this one goes to 11 */
+		return 0;
+	case _PC_SYMLINK_MAX:
+		*retval = MAXPATHLEN;
+		return 0;
+	case _PC_2_SYMLINKS:
+		*retval = 1;
+		return 0;
+	default:
+		return EINVAL;
+	}
+}
+
+int
+dtfs_node_inactive(struct puffs_usermount *pu, puffs_cookie_t opc)
+{
+	struct puffs_node *pn = opc;
+
+	if (pn->pn_va.va_nlink == 0)
+		puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N1);
+	return 0;
+}
+
+int
+dtfs_node_reclaim(struct puffs_usermount *pu, void *opc)
+{
+	struct puffs_node *pn = opc;
+
+	if (pn->pn_va.va_nlink == 0)
+		dtfs_freenode(pn);
+
+	return 0;
+}