From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Date: Mon, 27 Jan 2020 19:00:42 +0000

Subject: [PATCH] virtiofsd: Add fuse_lowlevel.c

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

fuse_lowlevel is one of the largest files from the library

and does most of the work.  Add it separately to keep the diff

sizes small.

Again this is from upstream fuse-3.8.0

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>

(cherry picked from commit 2de121f01e37e2fe98a4362f4abf7c0848697f76)

---

 tools/virtiofsd/fuse_lowlevel.c | 3129 +++++++++++++++++++++++++++++++

 1 file changed, 3129 insertions(+)

 create mode 100644 tools/virtiofsd/fuse_lowlevel.c

diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c

new file mode 100644

index 0000000000..f2d7038e34

--- /dev/null

+++ b/tools/virtiofsd/fuse_lowlevel.c

@@ -0,0 +1,3129 @@

+/*

+  FUSE: Filesystem in Userspace

+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>

+

+  Implementation of (most of) the low-level FUSE API. The session loop

+  functions are implemented in separate files.

+

+  This program can be distributed under the terms of the GNU LGPLv2.

+  See the file COPYING.LIB

+*/

+

+#define _GNU_SOURCE

+

+#include "config.h"

+#include "fuse_i.h"

+#include "fuse_kernel.h"

+#include "fuse_opt.h"

+#include "fuse_misc.h"

+#include "mount_util.h"

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <stddef.h>

+#include <string.h>

+#include <unistd.h>

+#include <limits.h>

+#include <errno.h>

+#include <assert.h>

+#include <sys/file.h>

+

+#ifndef F_LINUX_SPECIFIC_BASE

+#define F_LINUX_SPECIFIC_BASE       1024

+#endif

+#ifndef F_SETPIPE_SZ

+#define F_SETPIPE_SZ	(F_LINUX_SPECIFIC_BASE + 7)

+#endif

+

+

+#define PARAM(inarg) (((char *)(inarg)) + sizeof(*(inarg)))

+#define OFFSET_MAX 0x7fffffffffffffffLL

+

+#define container_of(ptr, type, member) ({				\

+			const typeof( ((type *)0)->member ) *__mptr = (ptr); \

+			(type *)( (char *)__mptr - offsetof(type,member) );})

+

+struct fuse_pollhandle {

+	uint64_t kh;

+	struct fuse_session *se;

+};

+

+static size_t pagesize;

+

+static __attribute__((constructor)) void fuse_ll_init_pagesize(void)

+{

+	pagesize = getpagesize();

+}

+

+static void convert_stat(const struct stat *stbuf, struct fuse_attr *attr)

+{

+	attr->ino	= stbuf->st_ino;

+	attr->mode	= stbuf->st_mode;

+	attr->nlink	= stbuf->st_nlink;

+	attr->uid	= stbuf->st_uid;

+	attr->gid	= stbuf->st_gid;

+	attr->rdev	= stbuf->st_rdev;

+	attr->size	= stbuf->st_size;

+	attr->blksize	= stbuf->st_blksize;

+	attr->blocks	= stbuf->st_blocks;

+	attr->atime	= stbuf->st_atime;

+	attr->mtime	= stbuf->st_mtime;

+	attr->ctime	= stbuf->st_ctime;

+	attr->atimensec = ST_ATIM_NSEC(stbuf);

+	attr->mtimensec = ST_MTIM_NSEC(stbuf);

+	attr->ctimensec = ST_CTIM_NSEC(stbuf);

+}

+

+static void convert_attr(const struct fuse_setattr_in *attr, struct stat *stbuf)

+{

+	stbuf->st_mode	       = attr->mode;

+	stbuf->st_uid	       = attr->uid;

+	stbuf->st_gid	       = attr->gid;

+	stbuf->st_size	       = attr->size;

+	stbuf->st_atime	       = attr->atime;

+	stbuf->st_mtime	       = attr->mtime;

+	stbuf->st_ctime        = attr->ctime;

+	ST_ATIM_NSEC_SET(stbuf, attr->atimensec);

+	ST_MTIM_NSEC_SET(stbuf, attr->mtimensec);

+	ST_CTIM_NSEC_SET(stbuf, attr->ctimensec);

+}

+

+static	size_t iov_length(const struct iovec *iov, size_t count)

+{

+	size_t seg;

+	size_t ret = 0;

+

+	for (seg = 0; seg < count; seg++)

+		ret += iov[seg].iov_len;

+	return ret;

+}

+

+static void list_init_req(struct fuse_req *req)

+{

+	req->next = req;

+	req->prev = req;

+}

+

+static void list_del_req(struct fuse_req *req)

+{

+	struct fuse_req *prev = req->prev;

+	struct fuse_req *next = req->next;

+	prev->next = next;

+	next->prev = prev;

+}

+

+static void list_add_req(struct fuse_req *req, struct fuse_req *next)

+{

+	struct fuse_req *prev = next->prev;

+	req->next = next;

+	req->prev = prev;

+	prev->next = req;

+	next->prev = req;

+}

+

+static void destroy_req(fuse_req_t req)

+{

+	pthread_mutex_destroy(&req->lock);

+	free(req);

+}

+

+void fuse_free_req(fuse_req_t req)

+{

+	int ctr;

+	struct fuse_session *se = req->se;

+

+	pthread_mutex_lock(&se->lock);

+	req->u.ni.func = NULL;

+	req->u.ni.data = NULL;

+	list_del_req(req);

+	ctr = --req->ctr;

+	fuse_chan_put(req->ch);

+	req->ch = NULL;

+	pthread_mutex_unlock(&se->lock);

+	if (!ctr)

+		destroy_req(req);

+}

+

+static struct fuse_req *fuse_ll_alloc_req(struct fuse_session *se)

+{

+	struct fuse_req *req;

+

+	req = (struct fuse_req *) calloc(1, sizeof(struct fuse_req));

+	if (req == NULL) {

+		fuse_log(FUSE_LOG_ERR, "fuse: failed to allocate request\n");

+	} else {

+		req->se = se;

+		req->ctr = 1;

+		list_init_req(req);

+		fuse_mutex_init(&req->lock);

+	}

+

+	return req;

+}

+

+/* Send data. If *ch* is NULL, send via session master fd */

+static int fuse_send_msg(struct fuse_session *se, struct fuse_chan *ch,

+			 struct iovec *iov, int count)

+{

+	struct fuse_out_header *out = iov[0].iov_base;

+

+	out->len = iov_length(iov, count);

+	if (se->debug) {

+		if (out->unique == 0) {

+			fuse_log(FUSE_LOG_DEBUG, "NOTIFY: code=%d length=%u\n",

+				out->error, out->len);

+		} else if (out->error) {

+			fuse_log(FUSE_LOG_DEBUG,

+				"   unique: %llu, error: %i (%s), outsize: %i\n",

+				(unsigned long long) out->unique, out->error,

+				strerror(-out->error), out->len);

+		} else {

+			fuse_log(FUSE_LOG_DEBUG,

+				"   unique: %llu, success, outsize: %i\n",

+				(unsigned long long) out->unique, out->len);

+		}

+	}

+

+	ssize_t res = writev(ch ? ch->fd : se->fd,

+			     iov, count);

+	int err = errno;

+

+	if (res == -1) {

+		assert(se != NULL);

+

+		/* ENOENT means the operation was interrupted */

+		if (!fuse_session_exited(se) && err != ENOENT)

+			perror("fuse: writing device");

+		return -err;

+	}

+

+	return 0;

+}

+

+

+int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,

+			       int count)

+{

+	struct fuse_out_header out;

+

+	if (error <= -1000 || error > 0) {

+		fuse_log(FUSE_LOG_ERR, "fuse: bad error value: %i\n",	error);

+		error = -ERANGE;

+	}

+

+	out.unique = req->unique;

+	out.error = error;

+

+	iov[0].iov_base = &out;

+	iov[0].iov_len = sizeof(struct fuse_out_header);

+

+	return fuse_send_msg(req->se, req->ch, iov, count);

+}

+

+static int send_reply_iov(fuse_req_t req, int error, struct iovec *iov,

+			  int count)

+{

+	int res;

+

+	res = fuse_send_reply_iov_nofree(req, error, iov, count);

+	fuse_free_req(req);

+	return res;

+}

+

+static int send_reply(fuse_req_t req, int error, const void *arg,

+		      size_t argsize)

+{

+	struct iovec iov[2];

+	int count = 1;

+	if (argsize) {

+		iov[1].iov_base = (void *) arg;

+		iov[1].iov_len = argsize;

+		count++;

+	}

+	return send_reply_iov(req, error, iov, count);

+}

+

+int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count)

+{

+	int res;

+	struct iovec *padded_iov;

+

+	padded_iov = malloc((count + 1) * sizeof(struct iovec));

+	if (padded_iov == NULL)

+		return fuse_reply_err(req, ENOMEM);

+

+	memcpy(padded_iov + 1, iov, count * sizeof(struct iovec));

+	count++;

+

+	res = send_reply_iov(req, 0, padded_iov, count);

+	free(padded_iov);

+

+	return res;

+}

+

+

+/* `buf` is allowed to be empty so that the proper size may be

+   allocated by the caller */

+size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,

+			 const char *name, const struct stat *stbuf, off_t off)

+{

+	(void)req;

+	size_t namelen;

+	size_t entlen;

+	size_t entlen_padded;

+	struct fuse_dirent *dirent;

+

+	namelen = strlen(name);

+	entlen = FUSE_NAME_OFFSET + namelen;

+	entlen_padded = FUSE_DIRENT_ALIGN(entlen);

+

+	if ((buf == NULL) || (entlen_padded > bufsize))

+	  return entlen_padded;

+

+	dirent = (struct fuse_dirent*) buf;

+	dirent->ino = stbuf->st_ino;

+	dirent->off = off;

+	dirent->namelen = namelen;

+	dirent->type = (stbuf->st_mode & S_IFMT) >> 12;

+	memcpy(dirent->name, name, namelen);

+	memset(dirent->name + namelen, 0, entlen_padded - entlen);

+

+	return entlen_padded;

+}

+

+static void convert_statfs(const struct statvfs *stbuf,

+			   struct fuse_kstatfs *kstatfs)

+{

+	kstatfs->bsize	 = stbuf->f_bsize;

+	kstatfs->frsize	 = stbuf->f_frsize;

+	kstatfs->blocks	 = stbuf->f_blocks;

+	kstatfs->bfree	 = stbuf->f_bfree;

+	kstatfs->bavail	 = stbuf->f_bavail;

+	kstatfs->files	 = stbuf->f_files;

+	kstatfs->ffree	 = stbuf->f_ffree;

+	kstatfs->namelen = stbuf->f_namemax;

+}

+

+static int send_reply_ok(fuse_req_t req, const void *arg, size_t argsize)

+{

+	return send_reply(req, 0, arg, argsize);

+}

+

+int fuse_reply_err(fuse_req_t req, int err)

+{

+	return send_reply(req, -err, NULL, 0);

+}

+

+void fuse_reply_none(fuse_req_t req)

+{

+	fuse_free_req(req);

+}

+

+static unsigned long calc_timeout_sec(double t)

+{

+	if (t > (double) ULONG_MAX)

+		return ULONG_MAX;

+	else if (t < 0.0)

+		return 0;

+	else

+		return (unsigned long) t;

+}

+

+static unsigned int calc_timeout_nsec(double t)

+{

+	double f = t - (double) calc_timeout_sec(t);

+	if (f < 0.0)

+		return 0;

+	else if (f >= 0.999999999)

+		return 999999999;

+	else

+		return (unsigned int) (f * 1.0e9);

+}

+

+static void fill_entry(struct fuse_entry_out *arg,

+		       const struct fuse_entry_param *e)

+{

+	arg->nodeid = e->ino;

+	arg->generation = e->generation;

+	arg->entry_valid = calc_timeout_sec(e->entry_timeout);

+	arg->entry_valid_nsec = calc_timeout_nsec(e->entry_timeout);

+	arg->attr_valid = calc_timeout_sec(e->attr_timeout);

+	arg->attr_valid_nsec = calc_timeout_nsec(e->attr_timeout);

+	convert_stat(&e->attr, &arg->attr);

+}

+

+/* `buf` is allowed to be empty so that the proper size may be

+   allocated by the caller */

+size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize,

+			      const char *name,

+			      const struct fuse_entry_param *e, off_t off)

+{

+	(void)req;

+	size_t namelen;

+	size_t entlen;

+	size_t entlen_padded;

+

+	namelen = strlen(name);

+	entlen = FUSE_NAME_OFFSET_DIRENTPLUS + namelen;

+	entlen_padded = FUSE_DIRENT_ALIGN(entlen);

+	if ((buf == NULL) || (entlen_padded > bufsize))

+	  return entlen_padded;

+

+	struct fuse_direntplus *dp = (struct fuse_direntplus *) buf;

+	memset(&dp->entry_out, 0, sizeof(dp->entry_out));

+	fill_entry(&dp->entry_out, e);

+

+	struct fuse_dirent *dirent = &dp->dirent;

+	dirent->ino = e->attr.st_ino;

+	dirent->off = off;

+	dirent->namelen = namelen;

+	dirent->type = (e->attr.st_mode & S_IFMT) >> 12;

+	memcpy(dirent->name, name, namelen);

+	memset(dirent->name + namelen, 0, entlen_padded - entlen);

+

+	return entlen_padded;

+}

+

+static void fill_open(struct fuse_open_out *arg,

+		      const struct fuse_file_info *f)

+{

+	arg->fh = f->fh;

+	if (f->direct_io)

+		arg->open_flags |= FOPEN_DIRECT_IO;

+	if (f->keep_cache)

+		arg->open_flags |= FOPEN_KEEP_CACHE;

+	if (f->cache_readdir)

+		arg->open_flags |= FOPEN_CACHE_DIR;

+	if (f->nonseekable)

+		arg->open_flags |= FOPEN_NONSEEKABLE;

+}

+

+int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e)

+{

+	struct fuse_entry_out arg;

+	size_t size = req->se->conn.proto_minor < 9 ?

+		FUSE_COMPAT_ENTRY_OUT_SIZE : sizeof(arg);

+

+	/* before ABI 7.4 e->ino == 0 was invalid, only ENOENT meant

+	   negative entry */

+	if (!e->ino && req->se->conn.proto_minor < 4)

+		return fuse_reply_err(req, ENOENT);

+

+	memset(&arg, 0, sizeof(arg));

+	fill_entry(&arg, e);

+	return send_reply_ok(req, &arg, size);

+}

+

+int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,

+		      const struct fuse_file_info *f)

+{

+	char buf[sizeof(struct fuse_entry_out) + sizeof(struct fuse_open_out)];

+	size_t entrysize = req->se->conn.proto_minor < 9 ?

+		FUSE_COMPAT_ENTRY_OUT_SIZE : sizeof(struct fuse_entry_out);

+	struct fuse_entry_out *earg = (struct fuse_entry_out *) buf;

+	struct fuse_open_out *oarg = (struct fuse_open_out *) (buf + entrysize);

+

+	memset(buf, 0, sizeof(buf));

+	fill_entry(earg, e);

+	fill_open(oarg, f);

+	return send_reply_ok(req, buf,

+			     entrysize + sizeof(struct fuse_open_out));

+}

+

+int fuse_reply_attr(fuse_req_t req, const struct stat *attr,

+		    double attr_timeout)

+{

+	struct fuse_attr_out arg;

+	size_t size = req->se->conn.proto_minor < 9 ?

+		FUSE_COMPAT_ATTR_OUT_SIZE : sizeof(arg);

+

+	memset(&arg, 0, sizeof(arg));

+	arg.attr_valid = calc_timeout_sec(attr_timeout);

+	arg.attr_valid_nsec = calc_timeout_nsec(attr_timeout);

+	convert_stat(attr, &arg.attr);

+

+	return send_reply_ok(req, &arg, size);

+}

+

+int fuse_reply_readlink(fuse_req_t req, const char *linkname)

+{

+	return send_reply_ok(req, linkname, strlen(linkname));

+}

+

+int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *f)

+{

+	struct fuse_open_out arg;

+

+	memset(&arg, 0, sizeof(arg));

+	fill_open(&arg, f);

+	return send_reply_ok(req, &arg, sizeof(arg));

+}

+

+int fuse_reply_write(fuse_req_t req, size_t count)

+{

+	struct fuse_write_out arg;

+

+	memset(&arg, 0, sizeof(arg));

+	arg.size = count;

+

+	return send_reply_ok(req, &arg, sizeof(arg));

+}

+

+int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size)

+{

+	return send_reply_ok(req, buf, size);

+}

+

+static int fuse_send_data_iov_fallback(struct fuse_session *se,

+				       struct fuse_chan *ch,

+				       struct iovec *iov, int iov_count,

+				       struct fuse_bufvec *buf,

+				       size_t len)

+{

+	struct fuse_bufvec mem_buf = FUSE_BUFVEC_INIT(len);

+	void *mbuf;

+	int res;

+

+	/* Optimize common case */

+	if (buf->count == 1 && buf->idx == 0 && buf->off == 0 &&

+	    !(buf->buf[0].flags & FUSE_BUF_IS_FD)) {

+		/* FIXME: also avoid memory copy if there are multiple buffers

+		   but none of them contain an fd */

+

+		iov[iov_count].iov_base = buf->buf[0].mem;

+		iov[iov_count].iov_len = len;

+		iov_count++;

+		return fuse_send_msg(se, ch, iov, iov_count);

+	}

+

+	res = posix_memalign(&mbuf, pagesize, len);

+	if (res != 0)

+		return res;

+

+	mem_buf.buf[0].mem = mbuf;

+	res = fuse_buf_copy(&mem_buf, buf, 0);

+	if (res < 0) {

+		free(mbuf);

+		return -res;

+	}

+	len = res;

+

+	iov[iov_count].iov_base = mbuf;

+	iov[iov_count].iov_len = len;

+	iov_count++;

+	res = fuse_send_msg(se, ch, iov, iov_count);

+	free(mbuf);

+

+	return res;

+}

+

+struct fuse_ll_pipe {

+	size_t size;

+	int can_grow;

+	int pipe[2];

+};

+

+static void fuse_ll_pipe_free(struct fuse_ll_pipe *llp)

+{

+	close(llp->pipe[0]);

+	close(llp->pipe[1]);

+	free(llp);

+}

+

+#ifdef HAVE_SPLICE

+#if !defined(HAVE_PIPE2) || !defined(O_CLOEXEC)

+static int fuse_pipe(int fds[2])

+{

+	int rv = pipe(fds);

+

+	if (rv == -1)

+		return rv;

+

+	if (fcntl(fds[0], F_SETFL, O_NONBLOCK) == -1 ||

+	    fcntl(fds[1], F_SETFL, O_NONBLOCK) == -1 ||

+	    fcntl(fds[0], F_SETFD, FD_CLOEXEC) == -1 ||

+	    fcntl(fds[1], F_SETFD, FD_CLOEXEC) == -1) {

+		close(fds[0]);

+		close(fds[1]);

+		rv = -1;

+	}

+	return rv;

+}

+#else

+static int fuse_pipe(int fds[2])

+{

+	return pipe2(fds, O_CLOEXEC | O_NONBLOCK);

+}

+#endif

+

+static struct fuse_ll_pipe *fuse_ll_get_pipe(struct fuse_session *se)

+{

+	struct fuse_ll_pipe *llp = pthread_getspecific(se->pipe_key);

+	if (llp == NULL) {

+		int res;

+

+		llp = malloc(sizeof(struct fuse_ll_pipe));

+		if (llp == NULL)

+			return NULL;

+

+		res = fuse_pipe(llp->pipe);

+		if (res == -1) {

+			free(llp);

+			return NULL;

+		}

+

+		/*

+		 *the default size is 16 pages on linux

+		 */

+		llp->size = pagesize * 16;

+		llp->can_grow = 1;

+

+		pthread_setspecific(se->pipe_key, llp);

+	}

+

+	return llp;

+}

+#endif

+

+static void fuse_ll_clear_pipe(struct fuse_session *se)

+{

+	struct fuse_ll_pipe *llp = pthread_getspecific(se->pipe_key);

+	if (llp) {

+		pthread_setspecific(se->pipe_key, NULL);

+		fuse_ll_pipe_free(llp);

+	}

+}

+

+#if defined(HAVE_SPLICE) && defined(HAVE_VMSPLICE)

+static int read_back(int fd, char *buf, size_t len)

+{

+	int res;

+

+	res = read(fd, buf, len);

+	if (res == -1) {

+		fuse_log(FUSE_LOG_ERR, "fuse: internal error: failed to read back from pipe: %s\n", strerror(errno));

+		return -EIO;

+	}

+	if (res != len) {

+		fuse_log(FUSE_LOG_ERR, "fuse: internal error: short read back from pipe: %i from %zi\n", res, len);

+		return -EIO;

+	}

+	return 0;

+}

+

+static int grow_pipe_to_max(int pipefd)

+{

+	int max;

+	int res;

+	int maxfd;

+	char buf[32];

+

+	maxfd = open("/proc/sys/fs/pipe-max-size", O_RDONLY);

+	if (maxfd < 0)

+		return -errno;

+

+	res = read(maxfd, buf, sizeof(buf) - 1);

+	if (res < 0) {

+		int saved_errno;

+

+		saved_errno = errno;

+		close(maxfd);

+		return -saved_errno;

+	}

+	close(maxfd);

+	buf[res] = '\0';

+

+	max = atoi(buf);

+	res = fcntl(pipefd, F_SETPIPE_SZ, max);

+	if (res < 0)

+		return -errno;

+	return max;

+}

+

+static int fuse_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,

+			       struct iovec *iov, int iov_count,

+			       struct fuse_bufvec *buf, unsigned int flags)

+{

+	int res;

+	size_t len = fuse_buf_size(buf);

+	struct fuse_out_header *out = iov[0].iov_base;

+	struct fuse_ll_pipe *llp;

+	int splice_flags;

+	size_t pipesize;

+	size_t total_fd_size;

+	size_t idx;

+	size_t headerlen;

+	struct fuse_bufvec pipe_buf = FUSE_BUFVEC_INIT(len);

+

+	if (se->broken_splice_nonblock)

+		goto fallback;

+

+	if (flags & FUSE_BUF_NO_SPLICE)

+		goto fallback;

+

+	total_fd_size = 0;

+	for (idx = buf->idx; idx < buf->count; idx++) {

+		if (buf->buf[idx].flags & FUSE_BUF_IS_FD) {

+			total_fd_size = buf->buf[idx].size;

+			if (idx == buf->idx)

+				total_fd_size -= buf->off;

+		}

+	}

+	if (total_fd_size < 2 * pagesize)

+		goto fallback;

+

+	if (se->conn.proto_minor < 14 ||

+	    !(se->conn.want & FUSE_CAP_SPLICE_WRITE))

+		goto fallback;

+

+	llp = fuse_ll_get_pipe(se);

+	if (llp == NULL)

+		goto fallback;

+

+

+	headerlen = iov_length(iov, iov_count);

+

+	out->len = headerlen + len;

+

+	/*

+	 * Heuristic for the required pipe size, does not work if the

+	 * source contains less than page size fragments

+	 */

+	pipesize = pagesize * (iov_count + buf->count + 1) + out->len;

+