Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/lib/libperfuse/perfuse.c

707 lines
18 KiB
C
Raw Blame History

/* $NetBSD: perfuse.c,v 1.36 2015/02/15 20:21:29 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 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;
}
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 any FUSE packet
* will fit.
*/
opt = (uint32_t)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 any FUSE packet
* will fit.
*/
opt = (uint32_t)(4 * 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++;
}
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;
struct rlimit rl;
/*
* perfused can grow quite large, let assume there's enough ram ...
*/
rl.rlim_cur = RLIM_INFINITY;
rl.rlim_max = RLIM_INFINITY;
if (setrlimit(RLIMIT_DATA, &rl) < 0) {
DERR(EX_OSERR, "%s: setrlimit failed: %s", __func__,
strerror(errno));
}
if (setrlimit(RLIMIT_AS, &rl) < 0) {
DERR(EX_OSERR, "%s: setrlimit failed: %s", __func__,
strerror(errno));
}
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;
}
Reference in New Issue View Git Blame Copy Permalink