xref: /src/lib/libperfuse/perfuse.c

/*  $NetBSD: perfuse.c,v 1.38 2016/10/18 15:06:17 manu Exp $ */

/*-
 *  Copyright (c) 2010-2011 Emmanuel Dreyfus. 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <puffs.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/extattr.h>
#include <sys/hash.h>
#include <sys/un.h>
#include <machine/vmparam.h>

#define LIBPERFUSE
#include "perfuse.h"
#include "perfuse_if.h"
#include "perfuse_priv.h"

int perfuse_diagflags = 0; /* global used only in DPRINTF/DERR/DWARN */
extern char **environ;

static struct perfuse_state *init_state(void);
static int get_fd(const char *);
static uint32_t bufvar_from_env(const char *, const uint32_t);


static struct perfuse_state *
init_state(void)
{
	struct perfuse_state *ps;
	size_t len;
	char opts[1024];
	int i;

	if ((ps = malloc(sizeof(*ps))) == NULL)
		DERR(EX_OSERR, "%s:%d malloc failed", __func__, __LINE__);

	(void)memset(ps, 0, sizeof(*ps));
	ps->ps_max_write = UINT_MAX;
	ps->ps_max_readahead = UINT_MAX;
	TAILQ_INIT(&ps->ps_trace);

	ps->ps_nnidhash = PUFFS_PNODEBUCKETS;
	len = sizeof(*ps->ps_nidhash) * ps->ps_nnidhash;
	if ((ps->ps_nidhash = malloc(len)) == NULL)
		DERR(EX_OSERR, "%s:%d malloc failed", __func__, __LINE__);
	for (i = 0; i < ps->ps_nnidhash; i++)
		LIST_INIT(&ps->ps_nidhash[i]);

	/*
	 * Most of the time, access() is broken because the filesystem
	 * performs the check with root privileges. glusterfs will do that
	 * if the Linux-specific setfsuid() is missing, for instance.
	 */
	ps->ps_flags |= PS_NO_ACCESS;

	/*
	 * This is a temporary way to toggle access and creat usage.
	 * It would be nice if that could be provided as mount options,
	 * but that will not be obvious to do.
 	 */
	if (getenv_r("PERFUSE_OPTIONS", opts, sizeof(opts)) != -1) {
		char *optname;
		char *last;

		 for ((optname = strtok_r(opts, ",", &last));
		      optname != NULL;
		      (optname = strtok_r(NULL, ",", &last))) {
			if (strcmp(optname, "enable_access") == 0)
				ps->ps_flags &= ~PS_NO_ACCESS;

			if (strcmp(optname, "disable_access") == 0)
				ps->ps_flags |= PS_NO_ACCESS;

			if (strcmp(optname, "enable_creat") == 0)
				ps->ps_flags &= ~PS_NO_CREAT;

			if (strcmp(optname, "disable_creat") == 0)
				ps->ps_flags |= PS_NO_CREAT;
		}
	}


	return ps;
}


static int
get_fd(const char *data)
{
	char *string;
	const char fdopt[] = "fd=";
	char *lastp;
	char *opt;
	int fd = -1;

	if ((string = strdup(data)) == NULL)
		return -1;

	for (opt = strtok_r(string, ",", &lastp);
	     opt != NULL;
	     opt = strtok_r(NULL, ",", &lastp)) {
		if (strncmp(opt, fdopt, strlen(fdopt)) == 0) {
			fd =  atoi(opt + strlen(fdopt));
			break;
		}
	}

	/*
	 * No file descriptor found
	 */
	if (fd == -1)
		errno = EINVAL;

	free(string);
	return fd;

}

static uint32_t
bufvar_from_env(name, defval)
	const char *name;
	const uint32_t defval;
{
	char valstr[1024];
	uint32_t retval = defval;

	if (getenv_r(name, valstr, sizeof(valstr)) != -1) {
		long int val;
		char *ep;

		errno = 0;
		val = (int)strtol(valstr, &ep, 10);
		if (*valstr == '\0' || *ep != '\0')
			DWARNX("bad %s value \"%s\"", name, valstr);
		else if (errno != 0)
			DWARN("bad %s value \"%s\"", name, valstr);
		else if (val <= 0L ||
			 (unsigned long int)val > (unsigned long int)UINT32_MAX)
			DWARNX("%s value %ld out of "
			       "uint32_t bounds", name, val);
		else
			retval = val;
	}

	return retval;
}

int
perfuse_open(const char *path, int flags, mode_t mode)
{
	int sv[2];
	struct sockaddr_un sun;
	struct sockaddr *sa;
	char progname[] = _PATH_PERFUSED;
	char minus_i[] = "-i";
	char fdstr[16];
	char *const argv[] = { progname, minus_i, fdstr, NULL};
	uint32_t opt;
	uint32_t optlen;
	int sock_type = SOCK_SEQPACKET;

	if (strcmp(path, _PATH_FUSE) != 0)
		return open(path, flags, mode);

	/*
	 * Try SOCK_SEQPACKET then SOCK_DGRAM if unavailable
	 */
	if ((sv[0] = socket(PF_LOCAL, SOCK_SEQPACKET, 0)) == -1) {
		sock_type = SOCK_DGRAM;
                DWARNX("SEQPACKET local sockets unavailable, using less "
		       "reliable DGRAM sockets. Expect file operation hangs.");

		if ((sv[0] = socket(PF_LOCAL, SOCK_DGRAM, 0)) == -1) {
#ifdef PERFUSE_DEBUG
			DWARN("%s: %d socket failed", __func__, __LINE__);
#endif
			return -1;
		}
	}

	/*
	 * Set a buffer lentgh large enough so that enough FUSE packets
	 * will fit.
	 */
	opt = bufvar_from_env("PERFUSE_BUFSIZE", 16 * FUSE_BUFSIZE);
	optlen = sizeof(opt);
	if (setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &opt, optlen) != 0)
		DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt);

	if (setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &opt, optlen) != 0)
		DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt);

	sa = (struct sockaddr *)(void *)&sun;
	sun.sun_len = sizeof(sun);
	sun.sun_family = AF_LOCAL;
	(void)strcpy(sun.sun_path, path);

	if (connect(sv[0], sa, (socklen_t)sun.sun_len) == 0)
		return sv[0];

	/*
	 * Attempt to run perfused on our own
	 * if it does not run yet; In that case
	 * we will talk using a socketpair
	 * instead of /dev/fuse.
	 */
	if (socketpair(PF_LOCAL, sock_type, 0, sv) != 0) {
		DWARN("%s:%d: socketpair failed", __func__, __LINE__);
		return -1;
	}

	/*
	 * Set a buffer lentgh large enough so that enough FUSE packets
	 * will fit.
	 */
	opt = bufvar_from_env("PERFUSE_BUFSIZE", 16 * FUSE_BUFSIZE);
	optlen = sizeof(opt);
	if (setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &opt, optlen) != 0)
		DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt);

	if (setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &opt, optlen) != 0)
		DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt);

	if (setsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &opt, optlen) != 0)
		DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt);

	if (setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &opt, optlen) != 0)
		DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt);

	/*
	 * Request peer credentials. This musr be done before first
	 * frame is sent.
	 */
	opt = 1;
	optlen = sizeof(opt);
	if (setsockopt(sv[1], 0, LOCAL_CREDS, &opt, optlen) != 0)
		DWARN("%s: setsockopt LOCAL_CREDS failed", __func__);

	(void)sprintf(fdstr, "%d", sv[1]);

	switch(fork()) {
	case -1:
#ifdef PERFUSE_DEBUG
		DWARN("%s:%d: fork failed", __func__, __LINE__);
#endif
		return -1;
		/* NOTREACHED */
		break;
	case 0:
		(void)close(sv[0]);
		(void)execve(argv[0], argv, environ);
#ifdef PERFUSE_DEBUG
		DWARN("%s:%d: execve failed", __func__, __LINE__);
#endif
		return -1;
		/* NOTREACHED */
		break;
	default:
		break;
	}

	(void)close(sv[1]);
	return sv[0];
}

int
perfuse_mount(const char *source, const char *target,
	const char *filesystemtype, long mountflags, const void *data)
{
	int s;
	size_t len;
	struct perfuse_mount_out *pmo;
	struct sockaddr_storage ss;
	struct sockaddr_un *sun;
	struct sockaddr *sa;
	socklen_t sa_len;
	size_t sock_len;
	char *frame;
	char *cp;

#ifdef PERFUSE_DEBUG
	if (perfuse_diagflags & PDF_MISC)
		DPRINTF("%s(\"%s\", \"%s\", \"%s\", 0x%lx, \"%s\")\n",
			__func__, source, target, filesystemtype,
			mountflags, (const char *)data);
#endif

	if ((s = get_fd(data)) == -1)
		return -1;

	/*
	 * If we are connected to /dev/fuse, we need a second
	 * socket to get replies from perfused.
	 * XXX This socket is not removed at exit time yet
	 */
	sock_len = 0;
	sa = (struct sockaddr *)(void *)&ss;
	sun = (struct sockaddr_un *)(void *)&ss;
	sa_len = sizeof(ss);
	if ((getpeername(s, sa, &sa_len) == 0) &&
	    (sa->sa_family = AF_LOCAL) &&
	    (strcmp(sun->sun_path, _PATH_FUSE) == 0)) {

		sun->sun_len = sizeof(*sun);
		sun->sun_family = AF_LOCAL;
		(void)sprintf(sun->sun_path, "%s/%s-%d",
			      _PATH_TMP, getprogname(), getpid());

		if (bind(s, sa, (socklen_t)sa->sa_len) != 0)
			DERR(EX_OSERR, "%s:%d bind to \"%s\" failed",
			     __func__, __LINE__, sun->sun_path);

		sock_len = strlen(sun->sun_path) + 1;
	}

	len = sizeof(*pmo);
	len += source ? (uint32_t)strlen(source) + 1 : 0;
	len += target ? (uint32_t)strlen(target) + 1 : 0;
	len += filesystemtype ? (uint32_t)strlen(filesystemtype) + 1 : 0;
	len += data ? (uint32_t)strlen(data) + 1 : 0;
	len += sock_len;

	if ((frame = malloc(len)) == NULL) {
#ifdef PERFUSE_DEBUG
		if (perfuse_diagflags & PDF_MISC)
			DWARN("%s:%d malloc failed", __func__, __LINE__);
#endif
		return -1;
	}

	pmo = (struct perfuse_mount_out *)(void *)frame;
	pmo->pmo_len = (uint32_t)len;
	pmo->pmo_error = 0;
	pmo->pmo_unique = (uint64_t)-1;
	(void)strcpy(pmo->pmo_magic, PERFUSE_MOUNT_MAGIC);

	pmo->pmo_source_len = source ? (uint32_t)strlen(source) + 1 : 0;
	pmo->pmo_target_len = target ? (uint32_t)strlen(target) + 1: 0;
	pmo->pmo_filesystemtype_len =
	    filesystemtype ? (uint32_t)strlen(filesystemtype) + 1 : 0;
	pmo->pmo_mountflags = (uint32_t)mountflags;
	pmo->pmo_data_len = data ? (uint32_t)strlen(data) + 1 : 0;
	pmo->pmo_sock_len = (uint32_t)sock_len;

	cp = (char *)(void *)(pmo + 1);

	if (source) {
		(void)strcpy(cp, source);
		cp += pmo->pmo_source_len;
	}

	if (target) {
		(void)strcpy(cp, target);
		cp += pmo->pmo_target_len;
	}

	if (filesystemtype) {
		(void)strcpy(cp, filesystemtype);
		cp += pmo->pmo_filesystemtype_len;
	}

	if (data) {
		(void)strcpy(cp, data);
		cp += pmo->pmo_data_len;
	}

	if (sock_len != 0) {
		(void)strcpy(cp, sun->sun_path);
		cp += pmo->pmo_sock_len;
	}

	if (send(s, frame, len, MSG_NOSIGNAL) != (ssize_t)len) {
#ifdef PERFUSE_DEBUG
		DWARN("%s:%d sendto failed", __func__, __LINE__);
#endif
		return -1;
	}

	return 0;
}


uint64_t
perfuse_next_unique(struct puffs_usermount *pu)
{
	struct perfuse_state *ps;

	ps = puffs_getspecific(pu);

	return ps->ps_unique++;
}

static void
updatelimit(const char *func, int lim, const char *name)
{
	struct rlimit rl;

	/* Try infinity but that will fail unless we are root */
	rl.rlim_cur = RLIM_INFINITY;
	rl.rlim_max = RLIM_INFINITY;
	if (setrlimit(lim, &rl) != -1)
		return;

	/* Get and set to the maximum allowed */
	if (getrlimit(lim, &rl) == -1)
		DERR(EX_OSERR, "%s: getrlimit %s failed", func, name);

	rl.rlim_cur = rl.rlim_max;
	if (setrlimit(lim, &rl) == -1)
		DERR(EX_OSERR, "%s: setrlimit %s to %ju failed", func,
		    name, (uintmax_t)rl.rlim_cur);
}

struct puffs_usermount *
perfuse_init(struct perfuse_callbacks *pc, struct perfuse_mount_info *pmi)
{
	struct perfuse_state *ps;
	struct puffs_usermount *pu;
	struct puffs_ops *pops;
	const char *source = _PATH_PUFFS;
	char *fstype;
	unsigned int puffs_flags;
	struct puffs_node *pn_root;
	struct puffs_pathobj *po_root;

	/*
	 * perfused can grow quite large, let assume there's enough ram ...
	 */
	updatelimit(__func__, RLIMIT_DATA, "RLIMIT_DATA");
	updatelimit(__func__, RLIMIT_AS, "RLIMIT_AS");

	ps = init_state();
	ps->ps_owner_uid = pmi->pmi_uid;

	if (pmi->pmi_source) {
		if ((ps->ps_source = strdup(pmi->pmi_source)) == NULL)
			DERR(EX_OSERR, "%s: strdup failed", __func__);

		source = ps->ps_source;
	}

	if (pmi->pmi_filesystemtype) {
		size_t len;

		ps->ps_filesystemtype = strdup(pmi->pmi_filesystemtype);
		if (ps->ps_filesystemtype == NULL)
			DERR(EX_OSERR, "%s: strdup failed", __func__);

		len = sizeof("perfuse|") + strlen(ps->ps_filesystemtype) + 1;
		if ((fstype = malloc(len)) == NULL)
			DERR(EX_OSERR, "%s: malloc failed", __func__);

		(void)sprintf(fstype, "perfuse|%s", ps->ps_filesystemtype);
	} else {
		if ((fstype = strdup("perfuse")) == NULL)
			DERR(EX_OSERR, "%s: strdup failed", __func__);
	}

	if ((ps->ps_target = strdup(pmi->pmi_target)) == NULL)
		DERR(EX_OSERR, "%s: strdup failed", __func__);

	ps->ps_mountflags = pmi->pmi_mountflags;

	/*
	 * Some options are forbidden for non root users
	 */
	if (ps->ps_owner_uid != 0)
	    ps->ps_mountflags |= MNT_NOSUID|MNT_NODEV;

	PUFFSOP_INIT(pops);
	PUFFSOP_SET(pops, perfuse, fs, unmount);
	PUFFSOP_SET(pops, perfuse, fs, statvfs);
	PUFFSOP_SET(pops, perfuse, fs, sync);
	PUFFSOP_SET(pops, perfuse, node, lookup);
	PUFFSOP_SET(pops, perfuse, node, create);
	PUFFSOP_SET(pops, perfuse, node, mknod);
	PUFFSOP_SET(pops, perfuse, node, open);
	PUFFSOP_SET(pops, perfuse, node, close);
	PUFFSOP_SET(pops, perfuse, node, access);
	PUFFSOP_SET(pops, perfuse, node, getattr);
	PUFFSOP_SET(pops, perfuse, node, setattr);
	PUFFSOP_SET(pops, perfuse, node, poll);
	PUFFSOP_SET(pops, perfuse, node, fsync);
	PUFFSOP_SET(pops, perfuse, node, remove);
	PUFFSOP_SET(pops, perfuse, node, link);
	PUFFSOP_SET(pops, perfuse, node, rename);
	PUFFSOP_SET(pops, perfuse, node, mkdir);
	PUFFSOP_SET(pops, perfuse, node, rmdir);
	PUFFSOP_SET(pops, perfuse, node, symlink);
	PUFFSOP_SET(pops, perfuse, node, readdir);
	PUFFSOP_SET(pops, perfuse, node, readlink);
	PUFFSOP_SET(pops, perfuse, node, reclaim);
	PUFFSOP_SET(pops, perfuse, node, inactive);
	PUFFSOP_SET(pops, perfuse, node, print);
	PUFFSOP_SET(pops, perfuse, node, pathconf);
	PUFFSOP_SET(pops, perfuse, node, advlock);
	PUFFSOP_SET(pops, perfuse, node, read);
	PUFFSOP_SET(pops, perfuse, node, write);
#ifdef PUFFS_EXTNAMELEN
	PUFFSOP_SET(pops, perfuse, node, getextattr);
	PUFFSOP_SET(pops, perfuse, node, setextattr);
	PUFFSOP_SET(pops, perfuse, node, listextattr);
	PUFFSOP_SET(pops, perfuse, node, deleteextattr);
#endif /* PUFFS_EXTNAMELEN */
#ifdef PUFFS_KFLAG_CACHE_FS_TTL
	PUFFSOP_SET(pops, perfuse, node, getattr_ttl);
	PUFFSOP_SET(pops, perfuse, node, setattr_ttl);
#endif /* PUFFS_KFLAG_CACHE_FS_TTL */
#ifdef PUFFS_SETATTR_FAF
	PUFFSOP_SET(pops, perfuse, node, write2);
#endif /* PUFFS_SETATTR_FAF */
#ifdef PUFFS_OPEN_IO_DIRECT
	PUFFSOP_SET(pops, perfuse, node, open2);
#endif /* PUFFS_OPEN_IO_DIRECT */
#ifdef PUFFS_HAVE_FALLOCATE
	PUFFSOP_SET(pops, perfuse, node, fallocate);
#endif /* PUFFS_HAVE_FALLOCATE */

	/*
	 * PUFFS_KFLAG_NOCACHE_NAME is required so that we can see changes
	 * done by other machines in networked filesystems. In later
	 * NetBSD releases we use the alternative PUFFS_KFLAG_CACHE_FS_TTL,
	 * which implement name cache with a filesystem-provided TTL.
	 */
#ifdef PUFFS_KFLAG_CACHE_FS_TTL
	puffs_flags = PUFFS_KFLAG_CACHE_FS_TTL;
#else
	puffs_flags = PUFFS_KFLAG_NOCACHE_NAME;
#endif

	/*
	 * Do not lookuo ..
	 * That means we keep all parent vnode active
	 */
#ifdef PUFFS_KFLAG_CACHE_DOTDOT
	puffs_flags |= PUFFS_KFLAG_CACHE_DOTDOT;
#endif

	/*
	 * It would be nice to avoid useless inactive, and only
	 * get them on file open for writing (PUFFS does
	 * CLOSE/WRITE/INACTIVE, therefore actual close must be
	 * done at INACTIVE time). Unfortunatley, puffs_setback
	 * crashes when called on OPEN, therefore leave it for
	 * another day.
	 */
#ifdef notyet
	puffs_flags |= PUFFS_FLAG_IAONDEMAND;
#endif

	/*
	 * FUSE filesystem do not expect [amc]time and size
	 * updates to be sent by the kernel, they do the
	 * updates on their own after other operations.
	 */
#ifdef PUFFS_KFLAG_NOFLUSH_META
	puffs_flags |= PUFFS_KFLAG_NOFLUSH_META;
#endif

	if (perfuse_diagflags & PDF_PUFFS)
		puffs_flags |= PUFFS_FLAG_OPDUMP;

	if ((pu = puffs_init(pops, source, fstype, ps, puffs_flags)) == NULL)
		DERR(EX_OSERR, "%s: puffs_init failed", __func__);

	puffs_setncookiehash(pu, PUFFS_PNODEBUCKETS);

	ps->ps_pu = pu;

	/*
	 * Setup filesystem root
	 */
	pn_root = perfuse_new_pn(pu, "", NULL);
	PERFUSE_NODE_DATA(pn_root)->pnd_nodeid = FUSE_ROOT_ID;
	PERFUSE_NODE_DATA(pn_root)->pnd_parent_nodeid = FUSE_ROOT_ID;
	perfuse_node_cache(ps, pn_root);
	puffs_setroot(pu, pn_root);
	ps->ps_fsid = pn_root->pn_va.va_fsid;

	po_root = puffs_getrootpathobj(pu);
	if ((po_root->po_path = strdup("/")) == NULL)
		DERRX(EX_OSERR, "perfuse_mount_start() failed");

	po_root->po_len = 1;
	puffs_path_buildhash(pu, po_root);

	puffs_vattr_null(&pn_root->pn_va);
	pn_root->pn_va.va_type = VDIR;
	pn_root->pn_va.va_mode = 0755;
	pn_root->pn_va.va_fileid = FUSE_ROOT_ID;

	ps->ps_root = pn_root;

	/*
	 *  Callbacks
	 */
	ps->ps_new_msg = pc->pc_new_msg;
	ps->ps_xchg_msg = pc->pc_xchg_msg;
	ps->ps_destroy_msg = pc->pc_destroy_msg;
	ps->ps_get_inhdr = pc->pc_get_inhdr;
	ps->ps_get_inpayload = pc->pc_get_inpayload;
	ps->ps_get_outhdr = pc->pc_get_outhdr;
	ps->ps_get_outpayload = pc->pc_get_outpayload;
	ps->ps_umount = pc->pc_umount;

	pc->pc_fsreq = *perfuse_fsreq;

	return pu;
}

void
perfuse_setspecific(struct puffs_usermount *pu, void *priv)
{
	struct perfuse_state *ps;

	ps = puffs_getspecific(pu);
	ps->ps_private = priv;

	return;
}

void *
perfuse_getspecific(struct puffs_usermount *pu)
{
	struct perfuse_state *ps;

	ps = puffs_getspecific(pu);

	return ps->ps_private;
}

int
perfuse_inloop(struct puffs_usermount *pu)
{
	struct perfuse_state *ps;

	ps = puffs_getspecific(pu);

	return ps->ps_flags & PS_INLOOP;
}

int
perfuse_mainloop(struct puffs_usermount *pu)
{
	struct perfuse_state *ps;

	ps = puffs_getspecific(pu);

	ps->ps_flags |= PS_INLOOP;
	if (puffs_mainloop(ps->ps_pu) != 0) {
		DERR(EX_OSERR, "%s: failed", __func__);
		return -1;
	}

	/*
	 * Normal exit after unmount
	 */
	return 0;
}

/* ARGSUSED0 */
uint64_t
perfuse_get_nodeid(struct puffs_usermount *pu, puffs_cookie_t opc)
{
	return PERFUSE_NODE_DATA(opc)->pnd_nodeid;
}

int
perfuse_unmount(struct puffs_usermount *pu)
{
	struct perfuse_state *ps;

	ps = puffs_getspecific(pu);

	return unmount(ps->ps_target, MNT_FORCE);
}

void
perfuse_fsreq(struct puffs_usermount *pu, perfuse_msg_t *pm)
{
	struct perfuse_state *ps;
	struct fuse_out_header *foh;

	ps = puffs_getspecific(pu);
	foh = GET_OUTHDR(ps, pm);

	/*
	 * There are some operations we may use in a  Fire and Forget wey,
	 * because the kernel does not await a reply, but FUSE still
	 * sends a reply. This happens for fsyc, setattr (for metadata
	 * associated with a fsync) and write (for VOP_PUTPAGES). Ignore
	 * if it was fine, warn or abort otherwise.
	 */
	switch (foh->error) {
	case 0:
		break;
	case -ENOENT:
		/* File disapeared during a FAF operation */
		break;
	case -ENOTCONN: /* FALLTHROUGH */
	case -EAGAIN: /* FALLTHROUGH */
	case -EMSGSIZE:
		DWARN("operation unique = %"PRId64" failed", foh->unique);
		break;
	default:
		DWARNX("Unexpected frame: unique = %"PRId64", error = %d",
		        foh->unique, foh->error);
		/* NOTREACHED */
		break;
	}

	ps->ps_destroy_msg(pm);

	return;
}