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

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

Subject: [PATCH] virtiofsd: Add auxiliary .c's

MIME-Version: 1.0

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

Content-Transfer-Encoding: 8bit

Add most of the non-main .c files we need 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 ffcf8d9f8649c6e56b1193bbbc9c9f7388920043)

---

 tools/virtiofsd/buffer.c       | 321 ++++++++++++++++++++++++

 tools/virtiofsd/fuse_log.c     |  40 +++

 tools/virtiofsd/fuse_opt.c     | 423 +++++++++++++++++++++++++++++++

 tools/virtiofsd/fuse_signals.c |  91 +++++++

 tools/virtiofsd/helper.c       | 440 +++++++++++++++++++++++++++++++++

 5 files changed, 1315 insertions(+)

 create mode 100644 tools/virtiofsd/buffer.c

 create mode 100644 tools/virtiofsd/fuse_log.c

 create mode 100644 tools/virtiofsd/fuse_opt.c

 create mode 100644 tools/virtiofsd/fuse_signals.c

 create mode 100644 tools/virtiofsd/helper.c

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

new file mode 100644

index 0000000000..5ab9b87455

--- /dev/null

+++ b/tools/virtiofsd/buffer.c

@@ -0,0 +1,321 @@

+/*

+  FUSE: Filesystem in Userspace

+  Copyright (C) 2010  Miklos Szeredi <miklos@szeredi.hu>

+

+  Functions for dealing with `struct fuse_buf` and `struct

+  fuse_bufvec`.

+

+  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_lowlevel.h"

+#include <string.h>

+#include <unistd.h>

+#include <errno.h>

+#include <assert.h>

+

+size_t fuse_buf_size(const struct fuse_bufvec *bufv)

+{

+	size_t i;

+	size_t size = 0;

+

+	for (i = 0; i < bufv->count; i++) {

+		if (bufv->buf[i].size == SIZE_MAX)

+			size = SIZE_MAX;

+		else

+			size += bufv->buf[i].size;

+	}

+

+	return size;

+}

+

+static size_t min_size(size_t s1, size_t s2)

+{

+	return s1 < s2 ? s1 : s2;

+}

+

+static ssize_t fuse_buf_write(const struct fuse_buf *dst, size_t dst_off,

+			      const struct fuse_buf *src, size_t src_off,

+			      size_t len)

+{

+	ssize_t res = 0;

+	size_t copied = 0;

+

+	while (len) {

+		if (dst->flags & FUSE_BUF_FD_SEEK) {

+			res = pwrite(dst->fd, (char *)src->mem + src_off, len,

+				     dst->pos + dst_off);

+		} else {

+			res = write(dst->fd, (char *)src->mem + src_off, len);

+		}

+		if (res == -1) {

+			if (!copied)

+				return -errno;

+			break;

+		}

+		if (res == 0)

+			break;

+

+		copied += res;

+		if (!(dst->flags & FUSE_BUF_FD_RETRY))

+			break;

+

+		src_off += res;

+		dst_off += res;

+		len -= res;

+	}

+

+	return copied;

+}

+

+static ssize_t fuse_buf_read(const struct fuse_buf *dst, size_t dst_off,

+			     const struct fuse_buf *src, size_t src_off,

+			     size_t len)

+{

+	ssize_t res = 0;

+	size_t copied = 0;

+

+	while (len) {

+		if (src->flags & FUSE_BUF_FD_SEEK) {

+			res = pread(src->fd, (char *)dst->mem + dst_off, len,

+				     src->pos + src_off);

+		} else {

+			res = read(src->fd, (char *)dst->mem + dst_off, len);

+		}

+		if (res == -1) {

+			if (!copied)

+				return -errno;

+			break;

+		}

+		if (res == 0)

+			break;

+

+		copied += res;

+		if (!(src->flags & FUSE_BUF_FD_RETRY))

+			break;

+

+		dst_off += res;

+		src_off += res;

+		len -= res;

+	}

+

+	return copied;

+}

+

+static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,

+				 const struct fuse_buf *src, size_t src_off,

+				 size_t len)

+{

+	char buf[4096];

+	struct fuse_buf tmp = {

+		.size = sizeof(buf),

+		.flags = 0,

+	};

+	ssize_t res;

+	size_t copied = 0;

+

+	tmp.mem = buf;

+

+	while (len) {

+		size_t this_len = min_size(tmp.size, len);

+		size_t read_len;

+

+		res = fuse_buf_read(&tmp, 0, src, src_off, this_len);

+		if (res < 0) {

+			if (!copied)

+				return res;

+			break;

+		}

+		if (res == 0)

+			break;

+

+		read_len = res;

+		res = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);

+		if (res < 0) {

+			if (!copied)

+				return res;

+			break;

+		}

+		if (res == 0)

+			break;

+

+		copied += res;

+

+		if (res < this_len)

+			break;

+

+		dst_off += res;

+		src_off += res;

+		len -= res;

+	}

+

+	return copied;

+}

+

+#ifdef HAVE_SPLICE

+static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,

+			       const struct fuse_buf *src, size_t src_off,

+			       size_t len, enum fuse_buf_copy_flags flags)

+{

+	int splice_flags = 0;

+	off_t *srcpos = NULL;

+	off_t *dstpos = NULL;

+	off_t srcpos_val;

+	off_t dstpos_val;

+	ssize_t res;

+	size_t copied = 0;

+

+	if (flags & FUSE_BUF_SPLICE_MOVE)

+		splice_flags |= SPLICE_F_MOVE;

+	if (flags & FUSE_BUF_SPLICE_NONBLOCK)

+		splice_flags |= SPLICE_F_NONBLOCK;

+

+	if (src->flags & FUSE_BUF_FD_SEEK) {

+		srcpos_val = src->pos + src_off;

+		srcpos = &srcpos_val;

+	}

+	if (dst->flags & FUSE_BUF_FD_SEEK) {

+		dstpos_val = dst->pos + dst_off;

+		dstpos = &dstpos_val;

+	}

+

+	while (len) {

+		res = splice(src->fd, srcpos, dst->fd, dstpos, len,

+			     splice_flags);

+		if (res == -1) {

+			if (copied)

+				break;

+

+			if (errno != EINVAL || (flags & FUSE_BUF_FORCE_SPLICE))

+				return -errno;

+

+			/* Maybe splice is not supported for this combination */

+			return fuse_buf_fd_to_fd(dst, dst_off, src, src_off,

+						 len);

+		}

+		if (res == 0)

+			break;

+

+		copied += res;

+		if (!(src->flags & FUSE_BUF_FD_RETRY) &&

+		    !(dst->flags & FUSE_BUF_FD_RETRY)) {

+			break;

+		}

+

+		len -= res;

+	}

+

+	return copied;

+}

+#else

+static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,

+			       const struct fuse_buf *src, size_t src_off,

+			       size_t len, enum fuse_buf_copy_flags flags)

+{

+	(void) flags;

+

+	return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);

+}

+#endif

+

+

+static ssize_t fuse_buf_copy_one(const struct fuse_buf *dst, size_t dst_off,

+				 const struct fuse_buf *src, size_t src_off,

+				 size_t len, enum fuse_buf_copy_flags flags)

+{

+	int src_is_fd = src->flags & FUSE_BUF_IS_FD;

+	int dst_is_fd = dst->flags & FUSE_BUF_IS_FD;

+

+	if (!src_is_fd && !dst_is_fd) {

+		char *dstmem = (char *)dst->mem + dst_off;

+		char *srcmem = (char *)src->mem + src_off;

+

+		if (dstmem != srcmem) {

+			if (dstmem + len <= srcmem || srcmem + len <= dstmem)

+				memcpy(dstmem, srcmem, len);

+			else

+				memmove(dstmem, srcmem, len);

+		}

+

+		return len;

+	} else if (!src_is_fd) {

+		return fuse_buf_write(dst, dst_off, src, src_off, len);

+	} else if (!dst_is_fd) {

+		return fuse_buf_read(dst, dst_off, src, src_off, len);

+	} else if (flags & FUSE_BUF_NO_SPLICE) {

+		return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);

+	} else {

+		return fuse_buf_splice(dst, dst_off, src, src_off, len, flags);

+	}

+}

+

+static const struct fuse_buf *fuse_bufvec_current(struct fuse_bufvec *bufv)

+{

+	if (bufv->idx < bufv->count)

+		return &bufv->buf[bufv->idx];

+	else

+		return NULL;

+}

+

+static int fuse_bufvec_advance(struct fuse_bufvec *bufv, size_t len)

+{

+	const struct fuse_buf *buf = fuse_bufvec_current(bufv);

+

+	bufv->off += len;

+	assert(bufv->off <= buf->size);

+	if (bufv->off == buf->size) {

+		assert(bufv->idx < bufv->count);

+		bufv->idx++;

+		if (bufv->idx == bufv->count)

+			return 0;

+		bufv->off = 0;

+	}

+	return 1;

+}

+

+ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv,

+		      enum fuse_buf_copy_flags flags)

+{

+	size_t copied = 0;

+

+	if (dstv == srcv)

+		return fuse_buf_size(dstv);

+

+	for (;;) {

+		const struct fuse_buf *src = fuse_bufvec_current(srcv);

+		const struct fuse_buf *dst = fuse_bufvec_current(dstv);

+		size_t src_len;

+		size_t dst_len;

+		size_t len;

+		ssize_t res;

+

+		if (src == NULL || dst == NULL)

+			break;

+

+		src_len = src->size - srcv->off;

+		dst_len = dst->size - dstv->off;

+		len = min_size(src_len, dst_len);

+

+		res = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len, flags);

+		if (res < 0) {

+			if (!copied)

+				return res;

+			break;

+		}

+		copied += res;

+

+		if (!fuse_bufvec_advance(srcv, res) ||

+		    !fuse_bufvec_advance(dstv, res))

+			break;

+

+		if (res < len)

+			break;

+	}

+

+	return copied;

+}

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

new file mode 100644

index 0000000000..0d268ab014

--- /dev/null

+++ b/tools/virtiofsd/fuse_log.c

@@ -0,0 +1,40 @@

+/*

+  FUSE: Filesystem in Userspace

+  Copyright (C) 2019  Red Hat, Inc.

+

+  Logging API.

+

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

+  See the file COPYING.LIB

+*/

+

+#include "fuse_log.h"

+

+#include <stdarg.h>

+#include <stdio.h>

+

+static void default_log_func(

+		__attribute__(( unused )) enum fuse_log_level level,

+		const char *fmt, va_list ap)

+{

+	vfprintf(stderr, fmt, ap);

+}

+

+static fuse_log_func_t log_func = default_log_func;

+

+void fuse_set_log_func(fuse_log_func_t func)

+{

+	if (!func)

+		func = default_log_func;

+

+	log_func = func;

+}

+

+void fuse_log(enum fuse_log_level level, const char *fmt, ...)

+{

+	va_list ap;

+

+	va_start(ap, fmt);

+	log_func(level, fmt, ap);

+	va_end(ap);

+}

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

new file mode 100644

index 0000000000..93066b926e

--- /dev/null

+++ b/tools/virtiofsd/fuse_opt.c

@@ -0,0 +1,423 @@

+/*

+  FUSE: Filesystem in Userspace

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

+

+  Implementation of option parsing routines (dealing with `struct

+  fuse_args`).

+

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

+  See the file COPYING.LIB

+*/

+

+#include "config.h"

+#include "fuse_i.h"

+#include "fuse_opt.h"

+#include "fuse_misc.h"

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <assert.h>

+

+struct fuse_opt_context {

+	void *data;

+	const struct fuse_opt *opt;

+	fuse_opt_proc_t proc;

+	int argctr;

+	int argc;

+	char **argv;

+	struct fuse_args outargs;

+	char *opts;

+	int nonopt;

+};

+

+void fuse_opt_free_args(struct fuse_args *args)

+{

+	if (args) {

+		if (args->argv && args->allocated) {

+			int i;

+			for (i = 0; i < args->argc; i++)

+				free(args->argv[i]);

+			free(args->argv);

+		}

+		args->argc = 0;

+		args->argv = NULL;

+		args->allocated = 0;

+	}

+}

+

+static int alloc_failed(void)

+{

+	fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");

+	return -1;

+}

+

+int fuse_opt_add_arg(struct fuse_args *args, const char *arg)

+{

+	char **newargv;

+	char *newarg;

+

+	assert(!args->argv || args->allocated);

+

+	newarg = strdup(arg);

+	if (!newarg)

+		return alloc_failed();

+

+	newargv = realloc(args->argv, (args->argc + 2) * sizeof(char *));

+	if (!newargv) {

+		free(newarg);

+		return alloc_failed();

+	}

+

+	args->argv = newargv;

+	args->allocated = 1;

+	args->argv[args->argc++] = newarg;

+	args->argv[args->argc] = NULL;

+	return 0;

+}

+

+static int fuse_opt_insert_arg_common(struct fuse_args *args, int pos,

+				      const char *arg)

+{

+	assert(pos <= args->argc);

+	if (fuse_opt_add_arg(args, arg) == -1)

+		return -1;

+

+	if (pos != args->argc - 1) {

+		char *newarg = args->argv[args->argc - 1];

+		memmove(&args->argv[pos + 1], &args->argv[pos],

+			sizeof(char *) * (args->argc - pos - 1));

+		args->argv[pos] = newarg;

+	}

+	return 0;

+}

+

+int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg)

+{

+	return fuse_opt_insert_arg_common(args, pos, arg);

+}

+

+static int next_arg(struct fuse_opt_context *ctx, const char *opt)

+{

+	if (ctx->argctr + 1 >= ctx->argc) {

+		fuse_log(FUSE_LOG_ERR, "fuse: missing argument after `%s'\n", opt);

+		return -1;

+	}

+	ctx->argctr++;

+	return 0;

+}

+

+static int add_arg(struct fuse_opt_context *ctx, const char *arg)

+{

+	return fuse_opt_add_arg(&ctx->outargs, arg);

+}

+

+static int add_opt_common(char **opts, const char *opt, int esc)

+{

+	unsigned oldlen = *opts ? strlen(*opts) : 0;

+	char *d = realloc(*opts, oldlen + 1 + strlen(opt) * 2 + 1);

+

+	if (!d)

+		return alloc_failed();

+

+	*opts = d;

+	if (oldlen) {

+		d += oldlen;

+		*d++ = ',';

+	}

+

+	for (; *opt; opt++) {

+		if (esc && (*opt == ',' || *opt == '\\'))

+			*d++ = '\\';

+		*d++ = *opt;

+	}

+	*d = '\0';

+

+	return 0;

+}

+

+int fuse_opt_add_opt(char **opts, const char *opt)

+{

+	return add_opt_common(opts, opt, 0);

+}

+

+int fuse_opt_add_opt_escaped(char **opts, const char *opt)

+{

+	return add_opt_common(opts, opt, 1);

+}

+

+static int add_opt(struct fuse_opt_context *ctx, const char *opt)

+{

+	return add_opt_common(&ctx->opts, opt, 1);

+}

+

+static int call_proc(struct fuse_opt_context *ctx, const char *arg, int key,

+		     int iso)

+{

+	if (key == FUSE_OPT_KEY_DISCARD)

+		return 0;

+

+	if (key != FUSE_OPT_KEY_KEEP && ctx->proc) {

+		int res = ctx->proc(ctx->data, arg, key, &ctx->outargs);

+		if (res == -1 || !res)

+			return res;

+	}

+	if (iso)

+		return add_opt(ctx, arg);

+	else

+		return add_arg(ctx, arg);

+}

+

+static int match_template(const char *t, const char *arg, unsigned *sepp)

+{

+	int arglen = strlen(arg);

+	const char *sep = strchr(t, '=');

+	sep = sep ? sep : strchr(t, ' ');

+	if (sep && (!sep[1] || sep[1] == '%')) {

+		int tlen = sep - t;

+		if (sep[0] == '=')

+			tlen ++;

+		if (arglen >= tlen && strncmp(arg, t, tlen) == 0) {

+			*sepp = sep - t;

+			return 1;

+		}

+	}

+	if (strcmp(t, arg) == 0) {

+		*sepp = 0;

+		return 1;

+	}

+	return 0;

+}

+

+static const struct fuse_opt *find_opt(const struct fuse_opt *opt,

+				       const char *arg, unsigned *sepp)

+{

+	for (; opt && opt->templ; opt++)

+		if (match_template(opt->templ, arg, sepp))

+			return opt;

+	return NULL;

+}

+

+int fuse_opt_match(const struct fuse_opt *opts, const char *opt)

+{

+	unsigned dummy;

+	return find_opt(opts, opt, &dummy) ? 1 : 0;

+}

+

+static int process_opt_param(void *var, const char *format, const char *param,

+			     const char *arg)

+{

+	assert(format[0] == '%');

+	if (format[1] == 's') {

+		char **s = var;

+		char *copy = strdup(param);

+		if (!copy)

+			return alloc_failed();

+

+		free(*s);

+		*s = copy;

+	} else {

+		if (sscanf(param, format, var) != 1) {

+			fuse_log(FUSE_LOG_ERR, "fuse: invalid parameter in option `%s'\n", arg);

+			return -1;

+		}

+	}

+	return 0;

+}

+

+static int process_opt(struct fuse_opt_context *ctx,

+		       const struct fuse_opt *opt, unsigned sep,

+		       const char *arg, int iso)

+{

+	if (opt->offset == -1U) {

+		if (call_proc(ctx, arg, opt->value, iso) == -1)

+			return -1;

+	} else {

+		void *var = (char *)ctx->data + opt->offset;

+		if (sep && opt->templ[sep + 1]) {

+			const char *param = arg + sep;

+			if (opt->templ[sep] == '=')

+				param ++;

+			if (process_opt_param(var, opt->templ + sep + 1,

+					      param, arg) == -1)

+				return -1;

+		} else

+			*(int *)var = opt->value;

+	}

+	return 0;

+}

+

+static int process_opt_sep_arg(struct fuse_opt_context *ctx,

+			       const struct fuse_opt *opt, unsigned sep,

+			       const char *arg, int iso)

+{

+	int res;

+	char *newarg;

+	char *param;

+

+	if (next_arg(ctx, arg) == -1)

+		return -1;

+

+	param = ctx->argv[ctx->argctr];

+	newarg = malloc(sep + strlen(param) + 1);

+	if (!newarg)

+		return alloc_failed();

+

+	memcpy(newarg, arg, sep);

+	strcpy(newarg + sep, param);

+	res = process_opt(ctx, opt, sep, newarg, iso);

+	free(newarg);

+

+	return res;

+}

+

+static int process_gopt(struct fuse_opt_context *ctx, const char *arg, int iso)

+{

+	unsigned sep;

+	const struct fuse_opt *opt = find_opt(ctx->opt, arg, &sep;;

+	if (opt) {

+		for (; opt; opt = find_opt(opt + 1, arg, &sep)) {

+			int res;

+			if (sep && opt->templ[sep] == ' ' && !arg[sep])

+				res = process_opt_sep_arg(ctx, opt, sep, arg,

+							  iso);

+			else

+				res = process_opt(ctx, opt, sep, arg, iso);

+			if (res == -1)

+				return -1;

+		}

+		return 0;

+	} else

+		return call_proc(ctx, arg, FUSE_OPT_KEY_OPT, iso);

+}

+

+static int process_real_option_group(struct fuse_opt_context *ctx, char *opts)

+{

+	char *s = opts;

+	char *d = s;

+	int end = 0;

+

+	while (!end) {

+		if (*s == '\0')

+			end = 1;

+		if (*s == ',' || end) {

+			int res;

+

+			*d = '\0';

+			res = process_gopt(ctx, opts, 1);

+			if (res == -1)

+				return -1;

+			d = opts;

+		} else {

+			if (s[0] == '\\' && s[1] != '\0') {

+				s++;

+				if (s[0] >= '0' && s[0] <= '3' &&

+				    s[1] >= '0' && s[1] <= '7' &&