* [PULL 001/108] virtiofsd: Pull in upstream headers
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 002/108] virtiofsd: Pull in kernel's fuse.h Dr. David Alan Gilbert (git)
` (108 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Pull in headers fromlibfuse's upstream fuse-3.8.0
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse.h | 1275 +++++++++++++++
tools/virtiofsd/fuse_common.h | 823 ++++++++++
tools/virtiofsd/fuse_i.h | 139 ++
tools/virtiofsd/fuse_log.h | 82 +
tools/virtiofsd/fuse_lowlevel.h | 2089 +++++++++++++++++++++++++
tools/virtiofsd/fuse_misc.h | 59 +
tools/virtiofsd/fuse_opt.h | 271 ++++
tools/virtiofsd/passthrough_helpers.h | 76 +
8 files changed, 4814 insertions(+)
create mode 100644 tools/virtiofsd/fuse.h
create mode 100644 tools/virtiofsd/fuse_common.h
create mode 100644 tools/virtiofsd/fuse_i.h
create mode 100644 tools/virtiofsd/fuse_log.h
create mode 100644 tools/virtiofsd/fuse_lowlevel.h
create mode 100644 tools/virtiofsd/fuse_misc.h
create mode 100644 tools/virtiofsd/fuse_opt.h
create mode 100644 tools/virtiofsd/passthrough_helpers.h
diff --git a/tools/virtiofsd/fuse.h b/tools/virtiofsd/fuse.h
new file mode 100644
index 0000000000..883f6e59fb
--- /dev/null
+++ b/tools/virtiofsd/fuse.h
@@ -0,0 +1,1275 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU LGPLv2.
+ See the file COPYING.LIB.
+*/
+
+#ifndef FUSE_H_
+#define FUSE_H_
+
+/** @file
+ *
+ * This file defines the library interface of FUSE
+ *
+ * IMPORTANT: you should define FUSE_USE_VERSION before including this header.
+ */
+
+#include "fuse_common.h"
+
+#include <fcntl.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sys/uio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ----------------------------------------------------------- *
+ * Basic FUSE API *
+ * ----------------------------------------------------------- */
+
+/** Handle for a FUSE filesystem */
+struct fuse;
+
+/**
+ * Readdir flags, passed to ->readdir()
+ */
+enum fuse_readdir_flags {
+ /**
+ * "Plus" mode.
+ *
+ * The kernel wants to prefill the inode cache during readdir. The
+ * filesystem may honour this by filling in the attributes and setting
+ * FUSE_FILL_DIR_FLAGS for the filler function. The filesystem may also
+ * just ignore this flag completely.
+ */
+ FUSE_READDIR_PLUS = (1 << 0),
+};
+
+enum fuse_fill_dir_flags {
+ /**
+ * "Plus" mode: all file attributes are valid
+ *
+ * The attributes are used by the kernel to prefill the inode cache
+ * during a readdir.
+ *
+ * It is okay to set FUSE_FILL_DIR_PLUS if FUSE_READDIR_PLUS is not set
+ * and vice versa.
+ */
+ FUSE_FILL_DIR_PLUS = (1 << 1),
+};
+
+/** Function to add an entry in a readdir() operation
+ *
+ * The *off* parameter can be any non-zero value that enables the
+ * filesystem to identify the current point in the directory
+ * stream. It does not need to be the actual physical position. A
+ * value of zero is reserved to indicate that seeking in directories
+ * is not supported.
+ *
+ * @param buf the buffer passed to the readdir() operation
+ * @param name the file name of the directory entry
+ * @param stat file attributes, can be NULL
+ * @param off offset of the next entry or zero
+ * @param flags fill flags
+ * @return 1 if buffer is full, zero otherwise
+ */
+typedef int (*fuse_fill_dir_t) (void *buf, const char *name,
+ const struct stat *stbuf, off_t off,
+ enum fuse_fill_dir_flags flags);
+/**
+ * Configuration of the high-level API
+ *
+ * This structure is initialized from the arguments passed to
+ * fuse_new(), and then passed to the file system's init() handler
+ * which should ensure that the configuration is compatible with the
+ * file system implementation.
+ */
+struct fuse_config {
+ /**
+ * If `set_gid` is non-zero, the st_gid attribute of each file
+ * is overwritten with the value of `gid`.
+ */
+ int set_gid;
+ unsigned int gid;
+
+ /**
+ * If `set_uid` is non-zero, the st_uid attribute of each file
+ * is overwritten with the value of `uid`.
+ */
+ int set_uid;
+ unsigned int uid;
+
+ /**
+ * If `set_mode` is non-zero, the any permissions bits set in
+ * `umask` are unset in the st_mode attribute of each file.
+ */
+ int set_mode;
+ unsigned int umask;
+
+ /**
+ * The timeout in seconds for which name lookups will be
+ * cached.
+ */
+ double entry_timeout;
+
+ /**
+ * The timeout in seconds for which a negative lookup will be
+ * cached. This means, that if file did not exist (lookup
+ * retuned ENOENT), the lookup will only be redone after the
+ * timeout, and the file/directory will be assumed to not
+ * exist until then. A value of zero means that negative
+ * lookups are not cached.
+ */
+ double negative_timeout;
+
+ /**
+ * The timeout in seconds for which file/directory attributes
+ * (as returned by e.g. the `getattr` handler) are cached.
+ */
+ double attr_timeout;
+
+ /**
+ * Allow requests to be interrupted
+ */
+ int intr;
+
+ /**
+ * Specify which signal number to send to the filesystem when
+ * a request is interrupted. The default is hardcoded to
+ * USR1.
+ */
+ int intr_signal;
+
+ /**
+ * Normally, FUSE assigns inodes to paths only for as long as
+ * the kernel is aware of them. With this option inodes are
+ * instead remembered for at least this many seconds. This
+ * will require more memory, but may be necessary when using
+ * applications that make use of inode numbers.
+ *
+ * A number of -1 means that inodes will be remembered for the
+ * entire life-time of the file-system process.
+ */
+ int remember;
+
+ /**
+ * The default behavior is that if an open file is deleted,
+ * the file is renamed to a hidden file (.fuse_hiddenXXX), and
+ * only removed when the file is finally released. This
+ * relieves the filesystem implementation of having to deal
+ * with this problem. This option disables the hiding
+ * behavior, and files are removed immediately in an unlink
+ * operation (or in a rename operation which overwrites an
+ * existing file).
+ *
+ * It is recommended that you not use the hard_remove
+ * option. When hard_remove is set, the following libc
+ * functions fail on unlinked files (returning errno of
+ * ENOENT): read(2), write(2), fsync(2), close(2), f*xattr(2),
+ * ftruncate(2), fstat(2), fchmod(2), fchown(2)
+ */
+ int hard_remove;
+
+ /**
+ * Honor the st_ino field in the functions getattr() and
+ * fill_dir(). This value is used to fill in the st_ino field
+ * in the stat(2), lstat(2), fstat(2) functions and the d_ino
+ * field in the readdir(2) function. The filesystem does not
+ * have to guarantee uniqueness, however some applications
+ * rely on this value being unique for the whole filesystem.
+ *
+ * Note that this does *not* affect the inode that libfuse
+ * and the kernel use internally (also called the "nodeid").
+ */
+ int use_ino;
+
+ /**
+ * If use_ino option is not given, still try to fill in the
+ * d_ino field in readdir(2). If the name was previously
+ * looked up, and is still in the cache, the inode number
+ * found there will be used. Otherwise it will be set to -1.
+ * If use_ino option is given, this option is ignored.
+ */
+ int readdir_ino;
+
+ /**
+ * This option disables the use of page cache (file content cache)
+ * in the kernel for this filesystem. This has several affects:
+ *
+ * 1. Each read(2) or write(2) system call will initiate one
+ * or more read or write operations, data will not be
+ * cached in the kernel.
+ *
+ * 2. The return value of the read() and write() system calls
+ * will correspond to the return values of the read and
+ * write operations. This is useful for example if the
+ * file size is not known in advance (before reading it).
+ *
+ * Internally, enabling this option causes fuse to set the
+ * `direct_io` field of `struct fuse_file_info` - overwriting
+ * any value that was put there by the file system.
+ */
+ int direct_io;
+
+ /**
+ * This option disables flushing the cache of the file
+ * contents on every open(2). This should only be enabled on
+ * filesystems where the file data is never changed
+ * externally (not through the mounted FUSE filesystem). Thus
+ * it is not suitable for network filesystems and other
+ * intermediate filesystems.
+ *
+ * NOTE: if this option is not specified (and neither
+ * direct_io) data is still cached after the open(2), so a
+ * read(2) system call will not always initiate a read
+ * operation.
+ *
+ * Internally, enabling this option causes fuse to set the
+ * `keep_cache` field of `struct fuse_file_info` - overwriting
+ * any value that was put there by the file system.
+ */
+ int kernel_cache;
+
+ /**
+ * This option is an alternative to `kernel_cache`. Instead of
+ * unconditionally keeping cached data, the cached data is
+ * invalidated on open(2) if if the modification time or the
+ * size of the file has changed since it was last opened.
+ */
+ int auto_cache;
+
+ /**
+ * The timeout in seconds for which file attributes are cached
+ * for the purpose of checking if auto_cache should flush the
+ * file data on open.
+ */
+ int ac_attr_timeout_set;
+ double ac_attr_timeout;
+
+ /**
+ * If this option is given the file-system handlers for the
+ * following operations will not receive path information:
+ * read, write, flush, release, fsync, readdir, releasedir,
+ * fsyncdir, lock, ioctl and poll.
+ *
+ * For the truncate, getattr, chmod, chown and utimens
+ * operations the path will be provided only if the struct
+ * fuse_file_info argument is NULL.
+ */
+ int nullpath_ok;
+
+ /**
+ * The remaining options are used by libfuse internally and
+ * should not be touched.
+ */
+ int show_help;
+ char *modules;
+ int debug;
+};
+
+
+/**
+ * The file system operations:
+ *
+ * Most of these should work very similarly to the well known UNIX
+ * file system operations. A major exception is that instead of
+ * returning an error in 'errno', the operation should return the
+ * negated error value (-errno) directly.
+ *
+ * All methods are optional, but some are essential for a useful
+ * filesystem (e.g. getattr). Open, flush, release, fsync, opendir,
+ * releasedir, fsyncdir, access, create, truncate, lock, init and
+ * destroy are special purpose methods, without which a full featured
+ * filesystem can still be implemented.
+ *
+ * In general, all methods are expected to perform any necessary
+ * permission checking. However, a filesystem may delegate this task
+ * to the kernel by passing the `default_permissions` mount option to
+ * `fuse_new()`. In this case, methods will only be called if
+ * the kernel's permission check has succeeded.
+ *
+ * Almost all operations take a path which can be of any length.
+ */
+struct fuse_operations {
+ /** Get file attributes.
+ *
+ * Similar to stat(). The 'st_dev' and 'st_blksize' fields are
+ * ignored. The 'st_ino' field is ignored except if the 'use_ino'
+ * mount option is given. In that case it is passed to userspace,
+ * but libfuse and the kernel will still assign a different
+ * inode for internal use (called the "nodeid").
+ *
+ * `fi` will always be NULL if the file is not currently open, but
+ * may also be NULL if the file is open.
+ */
+ int (*getattr) (const char *, struct stat *, struct fuse_file_info *fi);
+
+ /** Read the target of a symbolic link
+ *
+ * The buffer should be filled with a null terminated string. The
+ * buffer size argument includes the space for the terminating
+ * null character. If the linkname is too long to fit in the
+ * buffer, it should be truncated. The return value should be 0
+ * for success.
+ */
+ int (*readlink) (const char *, char *, size_t);
+
+ /** Create a file node
+ *
+ * This is called for creation of all non-directory, non-symlink
+ * nodes. If the filesystem defines a create() method, then for
+ * regular files that will be called instead.
+ */
+ int (*mknod) (const char *, mode_t, dev_t);
+
+ /** Create a directory
+ *
+ * Note that the mode argument may not have the type specification
+ * bits set, i.e. S_ISDIR(mode) can be false. To obtain the
+ * correct directory type bits use mode|S_IFDIR
+ * */
+ int (*mkdir) (const char *, mode_t);
+
+ /** Remove a file */
+ int (*unlink) (const char *);
+
+ /** Remove a directory */
+ int (*rmdir) (const char *);
+
+ /** Create a symbolic link */
+ int (*symlink) (const char *, const char *);
+
+ /** Rename a file
+ *
+ * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If
+ * RENAME_NOREPLACE is specified, the filesystem must not
+ * overwrite *newname* if it exists and return an error
+ * instead. If `RENAME_EXCHANGE` is specified, the filesystem
+ * must atomically exchange the two files, i.e. both must
+ * exist and neither may be deleted.
+ */
+ int (*rename) (const char *, const char *, unsigned int flags);
+
+ /** Create a hard link to a file */
+ int (*link) (const char *, const char *);
+
+ /** Change the permission bits of a file
+ *
+ * `fi` will always be NULL if the file is not currenlty open, but
+ * may also be NULL if the file is open.
+ */
+ int (*chmod) (const char *, mode_t, struct fuse_file_info *fi);
+
+ /** Change the owner and group of a file
+ *
+ * `fi` will always be NULL if the file is not currenlty open, but
+ * may also be NULL if the file is open.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ */
+ int (*chown) (const char *, uid_t, gid_t, struct fuse_file_info *fi);
+
+ /** Change the size of a file
+ *
+ * `fi` will always be NULL if the file is not currenlty open, but
+ * may also be NULL if the file is open.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ */
+ int (*truncate) (const char *, off_t, struct fuse_file_info *fi);
+
+ /** Open a file
+ *
+ * Open flags are available in fi->flags. The following rules
+ * apply.
+ *
+ * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be
+ * filtered out / handled by the kernel.
+ *
+ * - Access modes (O_RDONLY, O_WRONLY, O_RDWR, O_EXEC, O_SEARCH)
+ * should be used by the filesystem to check if the operation is
+ * permitted. If the ``-o default_permissions`` mount option is
+ * given, this check is already done by the kernel before calling
+ * open() and may thus be omitted by the filesystem.
+ *
+ * - When writeback caching is enabled, the kernel may send
+ * read requests even for files opened with O_WRONLY. The
+ * filesystem should be prepared to handle this.
+ *
+ * - When writeback caching is disabled, the filesystem is
+ * expected to properly handle the O_APPEND flag and ensure
+ * that each write is appending to the end of the file.
+ *
+ * - When writeback caching is enabled, the kernel will
+ * handle O_APPEND. However, unless all changes to the file
+ * come through the kernel this will not work reliably. The
+ * filesystem should thus either ignore the O_APPEND flag
+ * (and let the kernel handle it), or return an error
+ * (indicating that reliably O_APPEND is not available).
+ *
+ * Filesystem may store an arbitrary file handle (pointer,
+ * index, etc) in fi->fh, and use this in other all other file
+ * operations (read, write, flush, release, fsync).
+ *
+ * Filesystem may also implement stateless file I/O and not store
+ * anything in fi->fh.
+ *
+ * There are also some flags (direct_io, keep_cache) which the
+ * filesystem may set in fi, to change the way the file is opened.
+ * See fuse_file_info structure in <fuse_common.h> for more details.
+ *
+ * If this request is answered with an error code of ENOSYS
+ * and FUSE_CAP_NO_OPEN_SUPPORT is set in
+ * `fuse_conn_info.capable`, this is treated as success and
+ * future calls to open will also succeed without being send
+ * to the filesystem process.
+ *
+ */
+ int (*open) (const char *, struct fuse_file_info *);
+
+ /** Read data from an open file
+ *
+ * Read should return exactly the number of bytes requested except
+ * on EOF or error, otherwise the rest of the data will be
+ * substituted with zeroes. An exception to this is when the
+ * 'direct_io' mount option is specified, in which case the return
+ * value of the read system call will reflect the return value of
+ * this operation.
+ */
+ int (*read) (const char *, char *, size_t, off_t,
+ struct fuse_file_info *);
+
+ /** Write data to an open file
+ *
+ * Write should return exactly the number of bytes requested
+ * except on error. An exception to this is when the 'direct_io'
+ * mount option is specified (see read operation).
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ */
+ int (*write) (const char *, const char *, size_t, off_t,
+ struct fuse_file_info *);
+
+ /** Get file system statistics
+ *
+ * The 'f_favail', 'f_fsid' and 'f_flag' fields are ignored
+ */
+ int (*statfs) (const char *, struct statvfs *);
+
+ /** Possibly flush cached data
+ *
+ * BIG NOTE: This is not equivalent to fsync(). It's not a
+ * request to sync dirty data.
+ *
+ * Flush is called on each close() of a file descriptor, as opposed to
+ * release which is called on the close of the last file descriptor for
+ * a file. Under Linux, errors returned by flush() will be passed to
+ * userspace as errors from close(), so flush() is a good place to write
+ * back any cached dirty data. However, many applications ignore errors
+ * on close(), and on non-Linux systems, close() may succeed even if flush()
+ * returns an error. For these reasons, filesystems should not assume
+ * that errors returned by flush will ever be noticed or even
+ * delivered.
+ *
+ * NOTE: The flush() method may be called more than once for each
+ * open(). This happens if more than one file descriptor refers to an
+ * open file handle, e.g. due to dup(), dup2() or fork() calls. It is
+ * not possible to determine if a flush is final, so each flush should
+ * be treated equally. Multiple write-flush sequences are relatively
+ * rare, so this shouldn't be a problem.
+ *
+ * Filesystems shouldn't assume that flush will be called at any
+ * particular point. It may be called more times than expected, or not
+ * at all.
+ *
+ * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
+ */
+ int (*flush) (const char *, struct fuse_file_info *);
+
+ /** Release an open file
+ *
+ * Release is called when there are no more references to an open
+ * file: all file descriptors are closed and all memory mappings
+ * are unmapped.
+ *
+ * For every open() call there will be exactly one release() call
+ * with the same flags and file handle. It is possible to
+ * have a file opened more than once, in which case only the last
+ * release will mean, that no more reads/writes will happen on the
+ * file. The return value of release is ignored.
+ */
+ int (*release) (const char *, struct fuse_file_info *);
+
+ /** Synchronize file contents
+ *
+ * If the datasync parameter is non-zero, then only the user data
+ * should be flushed, not the meta data.
+ */
+ int (*fsync) (const char *, int, struct fuse_file_info *);
+
+ /** Set extended attributes */
+ int (*setxattr) (const char *, const char *, const char *, size_t, int);
+
+ /** Get extended attributes */
+ int (*getxattr) (const char *, const char *, char *, size_t);
+
+ /** List extended attributes */
+ int (*listxattr) (const char *, char *, size_t);
+
+ /** Remove extended attributes */
+ int (*removexattr) (const char *, const char *);
+
+ /** Open directory
+ *
+ * Unless the 'default_permissions' mount option is given,
+ * this method should check if opendir is permitted for this
+ * directory. Optionally opendir may also return an arbitrary
+ * filehandle in the fuse_file_info structure, which will be
+ * passed to readdir, releasedir and fsyncdir.
+ */
+ int (*opendir) (const char *, struct fuse_file_info *);
+
+ /** Read directory
+ *
+ * The filesystem may choose between two modes of operation:
+ *
+ * 1) The readdir implementation ignores the offset parameter, and
+ * passes zero to the filler function's offset. The filler
+ * function will not return '1' (unless an error happens), so the
+ * whole directory is read in a single readdir operation.
+ *
+ * 2) The readdir implementation keeps track of the offsets of the
+ * directory entries. It uses the offset parameter and always
+ * passes non-zero offset to the filler function. When the buffer
+ * is full (or an error happens) the filler function will return
+ * '1'.
+ */
+ int (*readdir) (const char *, void *, fuse_fill_dir_t, off_t,
+ struct fuse_file_info *, enum fuse_readdir_flags);
+
+ /** Release directory
+ */
+ int (*releasedir) (const char *, struct fuse_file_info *);
+
+ /** Synchronize directory contents
+ *
+ * If the datasync parameter is non-zero, then only the user data
+ * should be flushed, not the meta data
+ */
+ int (*fsyncdir) (const char *, int, struct fuse_file_info *);
+
+ /**
+ * Initialize filesystem
+ *
+ * The return value will passed in the `private_data` field of
+ * `struct fuse_context` to all file operations, and as a
+ * parameter to the destroy() method. It overrides the initial
+ * value provided to fuse_main() / fuse_new().
+ */
+ void *(*init) (struct fuse_conn_info *conn,
+ struct fuse_config *cfg);
+
+ /**
+ * Clean up filesystem
+ *
+ * Called on filesystem exit.
+ */
+ void (*destroy) (void *private_data);
+
+ /**
+ * Check file access permissions
+ *
+ * This will be called for the access() system call. If the
+ * 'default_permissions' mount option is given, this method is not
+ * called.
+ *
+ * This method is not called under Linux kernel versions 2.4.x
+ */
+ int (*access) (const char *, int);
+
+ /**
+ * Create and open a file
+ *
+ * If the file does not exist, first create it with the specified
+ * mode, and then open it.
+ *
+ * If this method is not implemented or under Linux kernel
+ * versions earlier than 2.6.15, the mknod() and open() methods
+ * will be called instead.
+ */
+ int (*create) (const char *, mode_t, struct fuse_file_info *);
+
+ /**
+ * Perform POSIX file locking operation
+ *
+ * The cmd argument will be either F_GETLK, F_SETLK or F_SETLKW.
+ *
+ * For the meaning of fields in 'struct flock' see the man page
+ * for fcntl(2). The l_whence field will always be set to
+ * SEEK_SET.
+ *
+ * For checking lock ownership, the 'fuse_file_info->owner'
+ * argument must be used.
+ *
+ * For F_GETLK operation, the library will first check currently
+ * held locks, and if a conflicting lock is found it will return
+ * information without calling this method. This ensures, that
+ * for local locks the l_pid field is correctly filled in. The
+ * results may not be accurate in case of race conditions and in
+ * the presence of hard links, but it's unlikely that an
+ * application would rely on accurate GETLK results in these
+ * cases. If a conflicting lock is not found, this method will be
+ * called, and the filesystem may fill out l_pid by a meaningful
+ * value, or it may leave this field zero.
+ *
+ * For F_SETLK and F_SETLKW the l_pid field will be set to the pid
+ * of the process performing the locking operation.
+ *
+ * Note: if this method is not implemented, the kernel will still
+ * allow file locking to work locally. Hence it is only
+ * interesting for network filesystems and similar.
+ */
+ int (*lock) (const char *, struct fuse_file_info *, int cmd,
+ struct flock *);
+
+ /**
+ * Change the access and modification times of a file with
+ * nanosecond resolution
+ *
+ * This supersedes the old utime() interface. New applications
+ * should use this.
+ *
+ * `fi` will always be NULL if the file is not currenlty open, but
+ * may also be NULL if the file is open.
+ *
+ * See the utimensat(2) man page for details.
+ */
+ int (*utimens) (const char *, const struct timespec tv[2],
+ struct fuse_file_info *fi);
+
+ /**
+ * Map block index within file to block index within device
+ *
+ * Note: This makes sense only for block device backed filesystems
+ * mounted with the 'blkdev' option
+ */
+ int (*bmap) (const char *, size_t blocksize, uint64_t *idx);
+
+ /**
+ * Ioctl
+ *
+ * flags will have FUSE_IOCTL_COMPAT set for 32bit ioctls in
+ * 64bit environment. The size and direction of data is
+ * determined by _IOC_*() decoding of cmd. For _IOC_NONE,
+ * data will be NULL, for _IOC_WRITE data is out area, for
+ * _IOC_READ in area and if both are set in/out area. In all
+ * non-NULL cases, the area is of _IOC_SIZE(cmd) bytes.
+ *
+ * If flags has FUSE_IOCTL_DIR then the fuse_file_info refers to a
+ * directory file handle.
+ *
+ * Note : the unsigned long request submitted by the application
+ * is truncated to 32 bits.
+ */
+ int (*ioctl) (const char *, unsigned int cmd, void *arg,
+ struct fuse_file_info *, unsigned int flags, void *data);
+
+ /**
+ * Poll for IO readiness events
+ *
+ * Note: If ph is non-NULL, the client should notify
+ * when IO readiness events occur by calling
+ * fuse_notify_poll() with the specified ph.
+ *
+ * Regardless of the number of times poll with a non-NULL ph
+ * is received, single notification is enough to clear all.
+ * Notifying more times incurs overhead but doesn't harm
+ * correctness.
+ *
+ * The callee is responsible for destroying ph with
+ * fuse_pollhandle_destroy() when no longer in use.
+ */
+ int (*poll) (const char *, struct fuse_file_info *,
+ struct fuse_pollhandle *ph, unsigned *reventsp);
+
+ /** Write contents of buffer to an open file
+ *
+ * Similar to the write() method, but data is supplied in a
+ * generic buffer. Use fuse_buf_copy() to transfer data to
+ * the destination.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ */
+ int (*write_buf) (const char *, struct fuse_bufvec *buf, off_t off,
+ struct fuse_file_info *);
+
+ /** Store data from an open file in a buffer
+ *
+ * Similar to the read() method, but data is stored and
+ * returned in a generic buffer.
+ *
+ * No actual copying of data has to take place, the source
+ * file descriptor may simply be stored in the buffer for
+ * later data transfer.
+ *
+ * The buffer must be allocated dynamically and stored at the
+ * location pointed to by bufp. If the buffer contains memory
+ * regions, they too must be allocated using malloc(). The
+ * allocated memory will be freed by the caller.
+ */
+ int (*read_buf) (const char *, struct fuse_bufvec **bufp,
+ size_t size, off_t off, struct fuse_file_info *);
+ /**
+ * Perform BSD file locking operation
+ *
+ * The op argument will be either LOCK_SH, LOCK_EX or LOCK_UN
+ *
+ * Nonblocking requests will be indicated by ORing LOCK_NB to
+ * the above operations
+ *
+ * For more information see the flock(2) manual page.
+ *
+ * Additionally fi->owner will be set to a value unique to
+ * this open file. This same value will be supplied to
+ * ->release() when the file is released.
+ *
+ * Note: if this method is not implemented, the kernel will still
+ * allow file locking to work locally. Hence it is only
+ * interesting for network filesystems and similar.
+ */
+ int (*flock) (const char *, struct fuse_file_info *, int op);
+
+ /**
+ * Allocates space for an open file
+ *
+ * This function ensures that required space is allocated for specified
+ * file. If this function returns success then any subsequent write
+ * request to specified range is guaranteed not to fail because of lack
+ * of space on the file system media.
+ */
+ int (*fallocate) (const char *, int, off_t, off_t,
+ struct fuse_file_info *);
+
+ /**
+ * Copy a range of data from one file to another
+ *
+ * Performs an optimized copy between two file descriptors without the
+ * additional cost of transferring data through the FUSE kernel module
+ * to user space (glibc) and then back into the FUSE filesystem again.
+ *
+ * In case this method is not implemented, glibc falls back to reading
+ * data from the source and writing to the destination. Effectively
+ * doing an inefficient copy of the data.
+ */
+ ssize_t (*copy_file_range) (const char *path_in,
+ struct fuse_file_info *fi_in,
+ off_t offset_in, const char *path_out,
+ struct fuse_file_info *fi_out,
+ off_t offset_out, size_t size, int flags);
+
+ /**
+ * Find next data or hole after the specified offset
+ */
+ off_t (*lseek) (const char *, off_t off, int whence, struct fuse_file_info *);
+};
+
+/** Extra context that may be needed by some filesystems
+ *
+ * The uid, gid and pid fields are not filled in case of a writepage
+ * operation.
+ */
+struct fuse_context {
+ /** Pointer to the fuse object */
+ struct fuse *fuse;
+
+ /** User ID of the calling process */
+ uid_t uid;
+
+ /** Group ID of the calling process */
+ gid_t gid;
+
+ /** Process ID of the calling thread */
+ pid_t pid;
+
+ /** Private filesystem data */
+ void *private_data;
+
+ /** Umask of the calling process */
+ mode_t umask;
+};
+
+/**
+ * Main function of FUSE.
+ *
+ * This is for the lazy. This is all that has to be called from the
+ * main() function.
+ *
+ * This function does the following:
+ * - parses command line options, and handles --help and
+ * --version
+ * - installs signal handlers for INT, HUP, TERM and PIPE
+ * - registers an exit handler to unmount the filesystem on program exit
+ * - creates a fuse handle
+ * - registers the operations
+ * - calls either the single-threaded or the multi-threaded event loop
+ *
+ * Most file systems will have to parse some file-system specific
+ * arguments before calling this function. It is recommended to do
+ * this with fuse_opt_parse() and a processing function that passes
+ * through any unknown options (this can also be achieved by just
+ * passing NULL as the processing function). That way, the remaining
+ * options can be passed directly to fuse_main().
+ *
+ * fuse_main() accepts all options that can be passed to
+ * fuse_parse_cmdline(), fuse_new(), or fuse_session_new().
+ *
+ * Option parsing skips argv[0], which is assumed to contain the
+ * program name. This element must always be present and is used to
+ * construct a basic ``usage: `` message for the --help
+ * output. argv[0] may also be set to the empty string. In this case
+ * the usage message is suppressed. This can be used by file systems
+ * to print their own usage line first. See hello.c for an example of
+ * how to do this.
+ *
+ * Note: this is currently implemented as a macro.
+ *
+ * The following error codes may be returned from fuse_main():
+ * 1: Invalid option arguments
+ * 2: No mount point specified
+ * 3: FUSE setup failed
+ * 4: Mounting failed
+ * 5: Failed to daemonize (detach from session)
+ * 6: Failed to set up signal handlers
+ * 7: An error occured during the life of the file system
+ *
+ * @param argc the argument counter passed to the main() function
+ * @param argv the argument vector passed to the main() function
+ * @param op the file system operation
+ * @param private_data Initial value for the `private_data`
+ * field of `struct fuse_context`. May be overridden by the
+ * `struct fuse_operations.init` handler.
+ * @return 0 on success, nonzero on failure
+ *
+ * Example usage, see hello.c
+ */
+/*
+ int fuse_main(int argc, char *argv[], const struct fuse_operations *op,
+ void *private_data);
+*/
+#define fuse_main(argc, argv, op, private_data) \
+ fuse_main_real(argc, argv, op, sizeof(*(op)), private_data)
+
+/* ----------------------------------------------------------- *
+ * More detailed API *
+ * ----------------------------------------------------------- */
+
+/**
+ * Print available options (high- and low-level) to stdout. This is
+ * not an exhaustive list, but includes only those options that may be
+ * of interest to an end-user of a file system.
+ *
+ * The function looks at the argument vector only to determine if
+ * there are additional modules to be loaded (module=foo option),
+ * and attempts to call their help functions as well.
+ *
+ * @param args the argument vector.
+ */
+void fuse_lib_help(struct fuse_args *args);
+
+/**
+ * Create a new FUSE filesystem.
+ *
+ * This function accepts most file-system independent mount options
+ * (like context, nodev, ro - see mount(8)), as well as the
+ * FUSE-specific mount options from mount.fuse(8).
+ *
+ * If the --help option is specified, the function writes a help text
+ * to stdout and returns NULL.
+ *
+ * Option parsing skips argv[0], which is assumed to contain the
+ * program name. This element must always be present and is used to
+ * construct a basic ``usage: `` message for the --help output. If
+ * argv[0] is set to the empty string, no usage message is included in
+ * the --help output.
+ *
+ * If an unknown option is passed in, an error message is written to
+ * stderr and the function returns NULL.
+ *
+ * @param args argument vector
+ * @param op the filesystem operations
+ * @param op_size the size of the fuse_operations structure
+ * @param private_data Initial value for the `private_data`
+ * field of `struct fuse_context`. May be overridden by the
+ * `struct fuse_operations.init` handler.
+ * @return the created FUSE handle
+ */
+#if FUSE_USE_VERSION == 30
+struct fuse *fuse_new_30(struct fuse_args *args, const struct fuse_operations *op,
+ size_t op_size, void *private_data);
+#define fuse_new(args, op, size, data) fuse_new_30(args, op, size, data)
+#else
+struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op,
+ size_t op_size, void *private_data);
+#endif
+
+/**
+ * Mount a FUSE file system.
+ *
+ * @param mountpoint the mount point path
+ * @param f the FUSE handle
+ *
+ * @return 0 on success, -1 on failure.
+ **/
+int fuse_mount(struct fuse *f, const char *mountpoint);
+
+/**
+ * Unmount a FUSE file system.
+ *
+ * See fuse_session_unmount() for additional information.
+ *
+ * @param f the FUSE handle
+ **/
+void fuse_unmount(struct fuse *f);
+
+/**
+ * Destroy the FUSE handle.
+ *
+ * NOTE: This function does not unmount the filesystem. If this is
+ * needed, call fuse_unmount() before calling this function.
+ *
+ * @param f the FUSE handle
+ */
+void fuse_destroy(struct fuse *f);
+
+/**
+ * FUSE event loop.
+ *
+ * Requests from the kernel are processed, and the appropriate
+ * operations are called.
+ *
+ * For a description of the return value and the conditions when the
+ * event loop exits, refer to the documentation of
+ * fuse_session_loop().
+ *
+ * @param f the FUSE handle
+ * @return see fuse_session_loop()
+ *
+ * See also: fuse_loop_mt()
+ */
+int fuse_loop(struct fuse *f);
+
+/**
+ * Flag session as terminated
+ *
+ * This function will cause any running event loops to exit on
+ * the next opportunity.
+ *
+ * @param f the FUSE handle
+ */
+void fuse_exit(struct fuse *f);
+
+/**
+ * FUSE event loop with multiple threads
+ *
+ * Requests from the kernel are processed, and the appropriate
+ * operations are called. Request are processed in parallel by
+ * distributing them between multiple threads.
+ *
+ * For a description of the return value and the conditions when the
+ * event loop exits, refer to the documentation of
+ * fuse_session_loop().
+ *
+ * Note: using fuse_loop() instead of fuse_loop_mt() means you are running in
+ * single-threaded mode, and that you will not have to worry about reentrancy,
+ * though you will have to worry about recursive lookups. In single-threaded
+ * mode, FUSE will wait for one callback to return before calling another.
+ *
+ * Enabling multiple threads, by using fuse_loop_mt(), will cause FUSE to make
+ * multiple simultaneous calls into the various callback functions given by your
+ * fuse_operations record.
+ *
+ * If you are using multiple threads, you can enjoy all the parallel execution
+ * and interactive response benefits of threads, and you get to enjoy all the
+ * benefits of race conditions and locking bugs, too. Ensure that any code used
+ * in the callback function of fuse_operations is also thread-safe.
+ *
+ * @param f the FUSE handle
+ * @param config loop configuration
+ * @return see fuse_session_loop()
+ *
+ * See also: fuse_loop()
+ */
+#if FUSE_USE_VERSION < 32
+int fuse_loop_mt_31(struct fuse *f, int clone_fd);
+#define fuse_loop_mt(f, clone_fd) fuse_loop_mt_31(f, clone_fd)
+#else
+int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config);
+#endif
+
+/**
+ * Get the current context
+ *
+ * The context is only valid for the duration of a filesystem
+ * operation, and thus must not be stored and used later.
+ *
+ * @return the context
+ */
+struct fuse_context *fuse_get_context(void);
+
+/**
+ * Get the current supplementary group IDs for the current request
+ *
+ * Similar to the getgroups(2) system call, except the return value is
+ * always the total number of group IDs, even if it is larger than the
+ * specified size.
+ *
+ * The current fuse kernel module in linux (as of 2.6.30) doesn't pass
+ * the group list to userspace, hence this function needs to parse
+ * "/proc/$TID/task/$TID/status" to get the group IDs.
+ *
+ * This feature may not be supported on all operating systems. In
+ * such a case this function will return -ENOSYS.
+ *
+ * @param size size of given array
+ * @param list array of group IDs to be filled in
+ * @return the total number of supplementary group IDs or -errno on failure
+ */
+int fuse_getgroups(int size, gid_t list[]);
+
+/**
+ * Check if the current request has already been interrupted
+ *
+ * @return 1 if the request has been interrupted, 0 otherwise
+ */
+int fuse_interrupted(void);
+
+/**
+ * Invalidates cache for the given path.
+ *
+ * This calls fuse_lowlevel_notify_inval_inode internally.
+ *
+ * @return 0 on successful invalidation, negative error value otherwise.
+ * This routine may return -ENOENT to indicate that there was
+ * no entry to be invalidated, e.g., because the path has not
+ * been seen before or has been forgotten; this should not be
+ * considered to be an error.
+ */
+int fuse_invalidate_path(struct fuse *f, const char *path);
+
+/**
+ * The real main function
+ *
+ * Do not call this directly, use fuse_main()
+ */
+int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
+ size_t op_size, void *private_data);
+
+/**
+ * Start the cleanup thread when using option "remember".
+ *
+ * This is done automatically by fuse_loop_mt()
+ * @param fuse struct fuse pointer for fuse instance
+ * @return 0 on success and -1 on error
+ */
+int fuse_start_cleanup_thread(struct fuse *fuse);
+
+/**
+ * Stop the cleanup thread when using option "remember".
+ *
+ * This is done automatically by fuse_loop_mt()
+ * @param fuse struct fuse pointer for fuse instance
+ */
+void fuse_stop_cleanup_thread(struct fuse *fuse);
+
+/**
+ * Iterate over cache removing stale entries
+ * use in conjunction with "-oremember"
+ *
+ * NOTE: This is already done for the standard sessions
+ *
+ * @param fuse struct fuse pointer for fuse instance
+ * @return the number of seconds until the next cleanup
+ */
+int fuse_clean_cache(struct fuse *fuse);
+
+/*
+ * Stacking API
+ */
+
+/**
+ * Fuse filesystem object
+ *
+ * This is opaque object represents a filesystem layer
+ */
+struct fuse_fs;
+
+/*
+ * These functions call the relevant filesystem operation, and return
+ * the result.
+ *
+ * If the operation is not defined, they return -ENOSYS, with the
+ * exception of fuse_fs_open, fuse_fs_release, fuse_fs_opendir,
+ * fuse_fs_releasedir and fuse_fs_statfs, which return 0.
+ */
+
+int fuse_fs_getattr(struct fuse_fs *fs, const char *path, struct stat *buf,
+ struct fuse_file_info *fi);
+int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath,
+ const char *newpath, unsigned int flags);
+int fuse_fs_unlink(struct fuse_fs *fs, const char *path);
+int fuse_fs_rmdir(struct fuse_fs *fs, const char *path);
+int fuse_fs_symlink(struct fuse_fs *fs, const char *linkname,
+ const char *path);
+int fuse_fs_link(struct fuse_fs *fs, const char *oldpath, const char *newpath);
+int fuse_fs_release(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi);
+int fuse_fs_open(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi);
+int fuse_fs_read(struct fuse_fs *fs, const char *path, char *buf, size_t size,
+ off_t off, struct fuse_file_info *fi);
+int fuse_fs_read_buf(struct fuse_fs *fs, const char *path,
+ struct fuse_bufvec **bufp, size_t size, off_t off,
+ struct fuse_file_info *fi);
+int fuse_fs_write(struct fuse_fs *fs, const char *path, const char *buf,
+ size_t size, off_t off, struct fuse_file_info *fi);
+int fuse_fs_write_buf(struct fuse_fs *fs, const char *path,
+ struct fuse_bufvec *buf, off_t off,
+ struct fuse_file_info *fi);
+int fuse_fs_fsync(struct fuse_fs *fs, const char *path, int datasync,
+ struct fuse_file_info *fi);
+int fuse_fs_flush(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi);
+int fuse_fs_statfs(struct fuse_fs *fs, const char *path, struct statvfs *buf);
+int fuse_fs_opendir(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi);
+int fuse_fs_readdir(struct fuse_fs *fs, const char *path, void *buf,
+ fuse_fill_dir_t filler, off_t off,
+ struct fuse_file_info *fi, enum fuse_readdir_flags flags);
+int fuse_fs_fsyncdir(struct fuse_fs *fs, const char *path, int datasync,
+ struct fuse_file_info *fi);
+int fuse_fs_releasedir(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi);
+int fuse_fs_create(struct fuse_fs *fs, const char *path, mode_t mode,
+ struct fuse_file_info *fi);
+int fuse_fs_lock(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi, int cmd, struct flock *lock);
+int fuse_fs_flock(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi, int op);
+int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode,
+ struct fuse_file_info *fi);
+int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid,
+ struct fuse_file_info *fi);
+int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size,
+ struct fuse_file_info *fi);
+int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
+ const struct timespec tv[2], struct fuse_file_info *fi);
+int fuse_fs_access(struct fuse_fs *fs, const char *path, int mask);
+int fuse_fs_readlink(struct fuse_fs *fs, const char *path, char *buf,
+ size_t len);
+int fuse_fs_mknod(struct fuse_fs *fs, const char *path, mode_t mode,
+ dev_t rdev);
+int fuse_fs_mkdir(struct fuse_fs *fs, const char *path, mode_t mode);
+int fuse_fs_setxattr(struct fuse_fs *fs, const char *path, const char *name,
+ const char *value, size_t size, int flags);
+int fuse_fs_getxattr(struct fuse_fs *fs, const char *path, const char *name,
+ char *value, size_t size);
+int fuse_fs_listxattr(struct fuse_fs *fs, const char *path, char *list,
+ size_t size);
+int fuse_fs_removexattr(struct fuse_fs *fs, const char *path,
+ const char *name);
+int fuse_fs_bmap(struct fuse_fs *fs, const char *path, size_t blocksize,
+ uint64_t *idx);
+int fuse_fs_ioctl(struct fuse_fs *fs, const char *path, unsigned int cmd,
+ void *arg, struct fuse_file_info *fi, unsigned int flags,
+ void *data);
+int fuse_fs_poll(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi, struct fuse_pollhandle *ph,
+ unsigned *reventsp);
+int fuse_fs_fallocate(struct fuse_fs *fs, const char *path, int mode,
+ off_t offset, off_t length, struct fuse_file_info *fi);
+ssize_t fuse_fs_copy_file_range(struct fuse_fs *fs, const char *path_in,
+ struct fuse_file_info *fi_in, off_t off_in,
+ const char *path_out,
+ struct fuse_file_info *fi_out, off_t off_out,
+ size_t len, int flags);
+off_t fuse_fs_lseek(struct fuse_fs *fs, const char *path, off_t off, int whence,
+ struct fuse_file_info *fi);
+void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn,
+ struct fuse_config *cfg);
+void fuse_fs_destroy(struct fuse_fs *fs);
+
+int fuse_notify_poll(struct fuse_pollhandle *ph);
+
+/**
+ * Create a new fuse filesystem object
+ *
+ * This is usually called from the factory of a fuse module to create
+ * a new instance of a filesystem.
+ *
+ * @param op the filesystem operations
+ * @param op_size the size of the fuse_operations structure
+ * @param private_data Initial value for the `private_data`
+ * field of `struct fuse_context`. May be overridden by the
+ * `struct fuse_operations.init` handler.
+ * @return a new filesystem object
+ */
+struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size,
+ void *private_data);
+
+/**
+ * Factory for creating filesystem objects
+ *
+ * The function may use and remove options from 'args' that belong
+ * to this module.
+ *
+ * For now the 'fs' vector always contains exactly one filesystem.
+ * This is the filesystem which will be below the newly created
+ * filesystem in the stack.
+ *
+ * @param args the command line arguments
+ * @param fs NULL terminated filesystem object vector
+ * @return the new filesystem object
+ */
+typedef struct fuse_fs *(*fuse_module_factory_t)(struct fuse_args *args,
+ struct fuse_fs *fs[]);
+/**
+ * Register filesystem module
+ *
+ * If the "-omodules=*name*_:..." option is present, filesystem
+ * objects are created and pushed onto the stack with the *factory_*
+ * function.
+ *
+ * @param name_ the name of this filesystem module
+ * @param factory_ the factory function for this filesystem module
+ */
+#define FUSE_REGISTER_MODULE(name_, factory_) \
+ fuse_module_factory_t fuse_module_ ## name_ ## _factory = factory_
+
+/** Get session from fuse object */
+struct fuse_session *fuse_get_session(struct fuse *f);
+
+/**
+ * Open a FUSE file descriptor and set up the mount for the given
+ * mountpoint and flags.
+ *
+ * @param mountpoint reference to the mount in the file system
+ * @param options mount options
+ * @return the FUSE file descriptor or -1 upon error
+ */
+int fuse_open_channel(const char *mountpoint, const char *options);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FUSE_H_ */
diff --git a/tools/virtiofsd/fuse_common.h b/tools/virtiofsd/fuse_common.h
new file mode 100644
index 0000000000..2d686b2ac4
--- /dev/null
+++ b/tools/virtiofsd/fuse_common.h
@@ -0,0 +1,823 @@
+/* FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU LGPLv2.
+ See the file COPYING.LIB.
+*/
+
+/** @file */
+
+#if !defined(FUSE_H_) && !defined(FUSE_LOWLEVEL_H_)
+#error "Never include <fuse_common.h> directly; use <fuse.h> or <fuse_lowlevel.h> instead."
+#endif
+
+#ifndef FUSE_COMMON_H_
+#define FUSE_COMMON_H_
+
+#include "fuse_opt.h"
+#include "fuse_log.h"
+#include <stdint.h>
+#include <sys/types.h>
+
+/** Major version of FUSE library interface */
+#define FUSE_MAJOR_VERSION 3
+
+/** Minor version of FUSE library interface */
+#define FUSE_MINOR_VERSION 2
+
+#define FUSE_MAKE_VERSION(maj, min) ((maj) * 10 + (min))
+#define FUSE_VERSION FUSE_MAKE_VERSION(FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Information about an open file.
+ *
+ * File Handles are created by the open, opendir, and create methods and closed
+ * by the release and releasedir methods. Multiple file handles may be
+ * concurrently open for the same file. Generally, a client will create one
+ * file handle per file descriptor, though in some cases multiple file
+ * descriptors can share a single file handle.
+ */
+struct fuse_file_info {
+ /** Open flags. Available in open() and release() */
+ int flags;
+
+ /** In case of a write operation indicates if this was caused
+ by a delayed write from the page cache. If so, then the
+ context's pid, uid, and gid fields will not be valid, and
+ the *fh* value may not match the *fh* value that would
+ have been sent with the corresponding individual write
+ requests if write caching had been disabled. */
+ unsigned int writepage : 1;
+
+ /** Can be filled in by open, to use direct I/O on this file. */
+ unsigned int direct_io : 1;
+
+ /** Can be filled in by open. It signals the kernel that any
+ currently cached file data (ie., data that the filesystem
+ provided the last time the file was open) need not be
+ invalidated. Has no effect when set in other contexts (in
+ particular it does nothing when set by opendir()). */
+ unsigned int keep_cache : 1;
+
+ /** Indicates a flush operation. Set in flush operation, also
+ maybe set in highlevel lock operation and lowlevel release
+ operation. */
+ unsigned int flush : 1;
+
+ /** Can be filled in by open, to indicate that the file is not
+ seekable. */
+ unsigned int nonseekable : 1;
+
+ /* Indicates that flock locks for this file should be
+ released. If set, lock_owner shall contain a valid value.
+ May only be set in ->release(). */
+ unsigned int flock_release : 1;
+
+ /** Can be filled in by opendir. It signals the kernel to
+ enable caching of entries returned by readdir(). Has no
+ effect when set in other contexts (in particular it does
+ nothing when set by open()). */
+ unsigned int cache_readdir : 1;
+
+ /** Padding. Reserved for future use*/
+ unsigned int padding : 25;
+ unsigned int padding2 : 32;
+
+ /** File handle id. May be filled in by filesystem in create,
+ * open, and opendir(). Available in most other file operations on the
+ * same file handle. */
+ uint64_t fh;
+
+ /** Lock owner id. Available in locking operations and flush */
+ uint64_t lock_owner;
+
+ /** Requested poll events. Available in ->poll. Only set on kernels
+ which support it. If unsupported, this field is set to zero. */
+ uint32_t poll_events;
+};
+
+/**
+ * Configuration parameters passed to fuse_session_loop_mt() and
+ * fuse_loop_mt().
+ */
+struct fuse_loop_config {
+ /**
+ * whether to use separate device fds for each thread
+ * (may increase performance)
+ */
+ int clone_fd;
+
+ /**
+ * The maximum number of available worker threads before they
+ * start to get deleted when they become idle. If not
+ * specified, the default is 10.
+ *
+ * Adjusting this has performance implications; a very small number
+ * of threads in the pool will cause a lot of thread creation and
+ * deletion overhead and performance may suffer. When set to 0, a new
+ * thread will be created to service every operation.
+ */
+ unsigned int max_idle_threads;
+};
+
+/**************************************************************************
+ * Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want' *
+ **************************************************************************/
+
+/**
+ * Indicates that the filesystem supports asynchronous read requests.
+ *
+ * If this capability is not requested/available, the kernel will
+ * ensure that there is at most one pending read request per
+ * file-handle at any time, and will attempt to order read requests by
+ * increasing offset.
+ *
+ * This feature is enabled by default when supported by the kernel.
+ */
+#define FUSE_CAP_ASYNC_READ (1 << 0)
+
+/**
+ * Indicates that the filesystem supports "remote" locking.
+ *
+ * This feature is enabled by default when supported by the kernel,
+ * and if getlk() and setlk() handlers are implemented.
+ */
+#define FUSE_CAP_POSIX_LOCKS (1 << 1)
+
+/**
+ * Indicates that the filesystem supports the O_TRUNC open flag. If
+ * disabled, and an application specifies O_TRUNC, fuse first calls
+ * truncate() and then open() with O_TRUNC filtered out.
+ *
+ * This feature is enabled by default when supported by the kernel.
+ */
+#define FUSE_CAP_ATOMIC_O_TRUNC (1 << 3)
+
+/**
+ * Indicates that the filesystem supports lookups of "." and "..".
+ *
+ * This feature is disabled by default.
+ */
+#define FUSE_CAP_EXPORT_SUPPORT (1 << 4)
+
+/**
+ * Indicates that the kernel should not apply the umask to the
+ * file mode on create operations.
+ *
+ * This feature is disabled by default.
+ */
+#define FUSE_CAP_DONT_MASK (1 << 6)
+
+/**
+ * Indicates that libfuse should try to use splice() when writing to
+ * the fuse device. This may improve performance.
+ *
+ * This feature is disabled by default.
+ */
+#define FUSE_CAP_SPLICE_WRITE (1 << 7)
+
+/**
+ * Indicates that libfuse should try to move pages instead of copying when
+ * writing to / reading from the fuse device. This may improve performance.
+ *
+ * This feature is disabled by default.
+ */
+#define FUSE_CAP_SPLICE_MOVE (1 << 8)
+
+/**
+ * Indicates that libfuse should try to use splice() when reading from
+ * the fuse device. This may improve performance.
+ *
+ * This feature is enabled by default when supported by the kernel and
+ * if the filesystem implements a write_buf() handler.
+ */
+#define FUSE_CAP_SPLICE_READ (1 << 9)
+
+/**
+ * If set, the calls to flock(2) will be emulated using POSIX locks and must
+ * then be handled by the filesystem's setlock() handler.
+ *
+ * If not set, flock(2) calls will be handled by the FUSE kernel module
+ * internally (so any access that does not go through the kernel cannot be taken
+ * into account).
+ *
+ * This feature is enabled by default when supported by the kernel and
+ * if the filesystem implements a flock() handler.
+ */
+#define FUSE_CAP_FLOCK_LOCKS (1 << 10)
+
+/**
+ * Indicates that the filesystem supports ioctl's on directories.
+ *
+ * This feature is enabled by default when supported by the kernel.
+ */
+#define FUSE_CAP_IOCTL_DIR (1 << 11)
+
+/**
+ * Traditionally, while a file is open the FUSE kernel module only
+ * asks the filesystem for an update of the file's attributes when a
+ * client attempts to read beyond EOF. This is unsuitable for
+ * e.g. network filesystems, where the file contents may change
+ * without the kernel knowing about it.
+ *
+ * If this flag is set, FUSE will check the validity of the attributes
+ * on every read. If the attributes are no longer valid (i.e., if the
+ * *attr_timeout* passed to fuse_reply_attr() or set in `struct
+ * fuse_entry_param` has passed), it will first issue a `getattr`
+ * request. If the new mtime differs from the previous value, any
+ * cached file *contents* will be invalidated as well.
+ *
+ * This flag should always be set when available. If all file changes
+ * go through the kernel, *attr_timeout* should be set to a very large
+ * number to avoid unnecessary getattr() calls.
+ *
+ * This feature is enabled by default when supported by the kernel.
+ */
+#define FUSE_CAP_AUTO_INVAL_DATA (1 << 12)
+
+/**
+ * Indicates that the filesystem supports readdirplus.
+ *
+ * This feature is enabled by default when supported by the kernel and if the
+ * filesystem implements a readdirplus() handler.
+ */
+#define FUSE_CAP_READDIRPLUS (1 << 13)
+
+/**
+ * Indicates that the filesystem supports adaptive readdirplus.
+ *
+ * If FUSE_CAP_READDIRPLUS is not set, this flag has no effect.
+ *
+ * If FUSE_CAP_READDIRPLUS is set and this flag is not set, the kernel
+ * will always issue readdirplus() requests to retrieve directory
+ * contents.
+ *
+ * If FUSE_CAP_READDIRPLUS is set and this flag is set, the kernel
+ * will issue both readdir() and readdirplus() requests, depending on
+ * how much information is expected to be required.
+ *
+ * As of Linux 4.20, the algorithm is as follows: when userspace
+ * starts to read directory entries, issue a READDIRPLUS request to
+ * the filesystem. If any entry attributes have been looked up by the
+ * time userspace requests the next batch of entries continue with
+ * READDIRPLUS, otherwise switch to plain READDIR. This will reasult
+ * in eg plain "ls" triggering READDIRPLUS first then READDIR after
+ * that because it doesn't do lookups. "ls -l" should result in all
+ * READDIRPLUS, except if dentries are already cached.
+ *
+ * This feature is enabled by default when supported by the kernel and
+ * if the filesystem implements both a readdirplus() and a readdir()
+ * handler.
+ */
+#define FUSE_CAP_READDIRPLUS_AUTO (1 << 14)
+
+/**
+ * Indicates that the filesystem supports asynchronous direct I/O submission.
+ *
+ * If this capability is not requested/available, the kernel will ensure that
+ * there is at most one pending read and one pending write request per direct
+ * I/O file-handle at any time.
+ *
+ * This feature is enabled by default when supported by the kernel.
+ */
+#define FUSE_CAP_ASYNC_DIO (1 << 15)
+
+/**
+ * Indicates that writeback caching should be enabled. This means that
+ * individual write request may be buffered and merged in the kernel
+ * before they are send to the filesystem.
+ *
+ * This feature is disabled by default.
+ */
+#define FUSE_CAP_WRITEBACK_CACHE (1 << 16)
+
+/**
+ * Indicates support for zero-message opens. If this flag is set in
+ * the `capable` field of the `fuse_conn_info` structure, then the
+ * filesystem may return `ENOSYS` from the open() handler to indicate
+ * success. Further attempts to open files will be handled in the
+ * kernel. (If this flag is not set, returning ENOSYS will be treated
+ * as an error and signaled to the caller).
+ *
+ * Setting (or unsetting) this flag in the `want` field has *no
+ * effect*.
+ */
+#define FUSE_CAP_NO_OPEN_SUPPORT (1 << 17)
+
+/**
+ * Indicates support for parallel directory operations. If this flag
+ * is unset, the FUSE kernel module will ensure that lookup() and
+ * readdir() requests are never issued concurrently for the same
+ * directory.
+ *
+ * This feature is enabled by default when supported by the kernel.
+ */
+#define FUSE_CAP_PARALLEL_DIROPS (1 << 18)
+
+/**
+ * Indicates support for POSIX ACLs.
+ *
+ * If this feature is enabled, the kernel will cache and have
+ * responsibility for enforcing ACLs. ACL will be stored as xattrs and
+ * passed to userspace, which is responsible for updating the ACLs in
+ * the filesystem, keeping the file mode in sync with the ACL, and
+ * ensuring inheritance of default ACLs when new filesystem nodes are
+ * created. Note that this requires that the file system is able to
+ * parse and interpret the xattr representation of ACLs.
+ *
+ * Enabling this feature implicitly turns on the
+ * ``default_permissions`` mount option (even if it was not passed to
+ * mount(2)).
+ *
+ * This feature is disabled by default.
+ */
+#define FUSE_CAP_POSIX_ACL (1 << 19)
+
+/**
+ * Indicates that the filesystem is responsible for unsetting
+ * setuid and setgid bits when a file is written, truncated, or
+ * its owner is changed.
+ *
+ * This feature is enabled by default when supported by the kernel.
+ */
+#define FUSE_CAP_HANDLE_KILLPRIV (1 << 20)
+
+/**
+ * Indicates support for zero-message opendirs. If this flag is set in
+ * the `capable` field of the `fuse_conn_info` structure, then the filesystem
+ * may return `ENOSYS` from the opendir() handler to indicate success. Further
+ * opendir and releasedir messages will be handled in the kernel. (If this
+ * flag is not set, returning ENOSYS will be treated as an error and signalled
+ * to the caller.)
+ *
+ * Setting (or unsetting) this flag in the `want` field has *no effect*.
+ */
+#define FUSE_CAP_NO_OPENDIR_SUPPORT (1 << 24)
+
+/**
+ * Ioctl flags
+ *
+ * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
+ * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed
+ * FUSE_IOCTL_RETRY: retry with new iovecs
+ * FUSE_IOCTL_DIR: is a directory
+ *
+ * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
+ */
+#define FUSE_IOCTL_COMPAT (1 << 0)
+#define FUSE_IOCTL_UNRESTRICTED (1 << 1)
+#define FUSE_IOCTL_RETRY (1 << 2)
+#define FUSE_IOCTL_DIR (1 << 4)
+
+#define FUSE_IOCTL_MAX_IOV 256
+
+/**
+ * Connection information, passed to the ->init() method
+ *
+ * Some of the elements are read-write, these can be changed to
+ * indicate the value requested by the filesystem. The requested
+ * value must usually be smaller than the indicated value.
+ */
+struct fuse_conn_info {
+ /**
+ * Major version of the protocol (read-only)
+ */
+ unsigned proto_major;
+
+ /**
+ * Minor version of the protocol (read-only)
+ */
+ unsigned proto_minor;
+
+ /**
+ * Maximum size of the write buffer
+ */
+ unsigned max_write;
+
+ /**
+ * Maximum size of read requests. A value of zero indicates no
+ * limit. However, even if the filesystem does not specify a
+ * limit, the maximum size of read requests will still be
+ * limited by the kernel.
+ *
+ * NOTE: For the time being, the maximum size of read requests
+ * must be set both here *and* passed to fuse_session_new()
+ * using the ``-o max_read=<n>`` mount option. At some point
+ * in the future, specifying the mount option will no longer
+ * be necessary.
+ */
+ unsigned max_read;
+
+ /**
+ * Maximum readahead
+ */
+ unsigned max_readahead;
+
+ /**
+ * Capability flags that the kernel supports (read-only)
+ */
+ unsigned capable;
+
+ /**
+ * Capability flags that the filesystem wants to enable.
+ *
+ * libfuse attempts to initialize this field with
+ * reasonable default values before calling the init() handler.
+ */
+ unsigned want;
+
+ /**
+ * Maximum number of pending "background" requests. A
+ * background request is any type of request for which the
+ * total number is not limited by other means. As of kernel
+ * 4.8, only two types of requests fall into this category:
+ *
+ * 1. Read-ahead requests
+ * 2. Asynchronous direct I/O requests
+ *
+ * Read-ahead requests are generated (if max_readahead is
+ * non-zero) by the kernel to preemptively fill its caches
+ * when it anticipates that userspace will soon read more
+ * data.
+ *
+ * Asynchronous direct I/O requests are generated if
+ * FUSE_CAP_ASYNC_DIO is enabled and userspace submits a large
+ * direct I/O request. In this case the kernel will internally
+ * split it up into multiple smaller requests and submit them
+ * to the filesystem concurrently.
+ *
+ * Note that the following requests are *not* background
+ * requests: writeback requests (limited by the kernel's
+ * flusher algorithm), regular (i.e., synchronous and
+ * buffered) userspace read/write requests (limited to one per
+ * thread), asynchronous read requests (Linux's io_submit(2)
+ * call actually blocks, so these are also limited to one per
+ * thread).
+ */
+ unsigned max_background;
+
+ /**
+ * Kernel congestion threshold parameter. If the number of pending
+ * background requests exceeds this number, the FUSE kernel module will
+ * mark the filesystem as "congested". This instructs the kernel to
+ * expect that queued requests will take some time to complete, and to
+ * adjust its algorithms accordingly (e.g. by putting a waiting thread
+ * to sleep instead of using a busy-loop).
+ */
+ unsigned congestion_threshold;
+
+ /**
+ * When FUSE_CAP_WRITEBACK_CACHE is enabled, the kernel is responsible
+ * for updating mtime and ctime when write requests are received. The
+ * updated values are passed to the filesystem with setattr() requests.
+ * However, if the filesystem does not support the full resolution of
+ * the kernel timestamps (nanoseconds), the mtime and ctime values used
+ * by kernel and filesystem will differ (and result in an apparent
+ * change of times after a cache flush).
+ *
+ * To prevent this problem, this variable can be used to inform the
+ * kernel about the timestamp granularity supported by the file-system.
+ * The value should be power of 10. The default is 1, i.e. full
+ * nano-second resolution. Filesystems supporting only second resolution
+ * should set this to 1000000000.
+ */
+ unsigned time_gran;
+
+ /**
+ * For future use.
+ */
+ unsigned reserved[22];
+};
+
+struct fuse_session;
+struct fuse_pollhandle;
+struct fuse_conn_info_opts;
+
+/**
+ * This function parses several command-line options that can be used
+ * to override elements of struct fuse_conn_info. The pointer returned
+ * by this function should be passed to the
+ * fuse_apply_conn_info_opts() method by the file system's init()
+ * handler.
+ *
+ * Before using this function, think twice if you really want these
+ * parameters to be adjustable from the command line. In most cases,
+ * they should be determined by the file system internally.
+ *
+ * The following options are recognized:
+ *
+ * -o max_write=N sets conn->max_write
+ * -o max_readahead=N sets conn->max_readahead
+ * -o max_background=N sets conn->max_background
+ * -o congestion_threshold=N sets conn->congestion_threshold
+ * -o async_read sets FUSE_CAP_ASYNC_READ in conn->want
+ * -o sync_read unsets FUSE_CAP_ASYNC_READ in conn->want
+ * -o atomic_o_trunc sets FUSE_CAP_ATOMIC_O_TRUNC in conn->want
+ * -o no_remote_lock Equivalent to -o no_remote_flock,no_remote_posix_lock
+ * -o no_remote_flock Unsets FUSE_CAP_FLOCK_LOCKS in conn->want
+ * -o no_remote_posix_lock Unsets FUSE_CAP_POSIX_LOCKS in conn->want
+ * -o [no_]splice_write (un-)sets FUSE_CAP_SPLICE_WRITE in conn->want
+ * -o [no_]splice_move (un-)sets FUSE_CAP_SPLICE_MOVE in conn->want
+ * -o [no_]splice_read (un-)sets FUSE_CAP_SPLICE_READ in conn->want
+ * -o [no_]auto_inval_data (un-)sets FUSE_CAP_AUTO_INVAL_DATA in conn->want
+ * -o readdirplus=no unsets FUSE_CAP_READDIRPLUS in conn->want
+ * -o readdirplus=yes sets FUSE_CAP_READDIRPLUS and unsets
+ * FUSE_CAP_READDIRPLUS_AUTO in conn->want
+ * -o readdirplus=auto sets FUSE_CAP_READDIRPLUS and
+ * FUSE_CAP_READDIRPLUS_AUTO in conn->want
+ * -o [no_]async_dio (un-)sets FUSE_CAP_ASYNC_DIO in conn->want
+ * -o [no_]writeback_cache (un-)sets FUSE_CAP_WRITEBACK_CACHE in conn->want
+ * -o time_gran=N sets conn->time_gran
+ *
+ * Known options will be removed from *args*, unknown options will be
+ * passed through unchanged.
+ *
+ * @param args argument vector (input+output)
+ * @return parsed options
+ **/
+struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args);
+
+/**
+ * This function applies the (parsed) parameters in *opts* to the
+ * *conn* pointer. It may modify the following fields: wants,
+ * max_write, max_readahead, congestion_threshold, max_background,
+ * time_gran. A field is only set (or unset) if the corresponding
+ * option has been explicitly set.
+ */
+void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts,
+ struct fuse_conn_info *conn);
+
+/**
+ * Go into the background
+ *
+ * @param foreground if true, stay in the foreground
+ * @return 0 on success, -1 on failure
+ */
+int fuse_daemonize(int foreground);
+
+/**
+ * Get the version of the library
+ *
+ * @return the version
+ */
+int fuse_version(void);
+
+/**
+ * Get the full package version string of the library
+ *
+ * @return the package version
+ */
+const char *fuse_pkgversion(void);
+
+/**
+ * Destroy poll handle
+ *
+ * @param ph the poll handle
+ */
+void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);
+
+/* ----------------------------------------------------------- *
+ * Data buffer *
+ * ----------------------------------------------------------- */
+
+/**
+ * Buffer flags
+ */
+enum fuse_buf_flags {
+ /**
+ * Buffer contains a file descriptor
+ *
+ * If this flag is set, the .fd field is valid, otherwise the
+ * .mem fields is valid.
+ */
+ FUSE_BUF_IS_FD = (1 << 1),
+
+ /**
+ * Seek on the file descriptor
+ *
+ * If this flag is set then the .pos field is valid and is
+ * used to seek to the given offset before performing
+ * operation on file descriptor.
+ */
+ FUSE_BUF_FD_SEEK = (1 << 2),
+
+ /**
+ * Retry operation on file descriptor
+ *
+ * If this flag is set then retry operation on file descriptor
+ * until .size bytes have been copied or an error or EOF is
+ * detected.
+ */
+ FUSE_BUF_FD_RETRY = (1 << 3),
+};
+
+/**
+ * Buffer copy flags
+ */
+enum fuse_buf_copy_flags {
+ /**
+ * Don't use splice(2)
+ *
+ * Always fall back to using read and write instead of
+ * splice(2) to copy data from one file descriptor to another.
+ *
+ * If this flag is not set, then only fall back if splice is
+ * unavailable.
+ */
+ FUSE_BUF_NO_SPLICE = (1 << 1),
+
+ /**
+ * Force splice
+ *
+ * Always use splice(2) to copy data from one file descriptor
+ * to another. If splice is not available, return -EINVAL.
+ */
+ FUSE_BUF_FORCE_SPLICE = (1 << 2),
+
+ /**
+ * Try to move data with splice.
+ *
+ * If splice is used, try to move pages from the source to the
+ * destination instead of copying. See documentation of
+ * SPLICE_F_MOVE in splice(2) man page.
+ */
+ FUSE_BUF_SPLICE_MOVE = (1 << 3),
+
+ /**
+ * Don't block on the pipe when copying data with splice
+ *
+ * Makes the operations on the pipe non-blocking (if the pipe
+ * is full or empty). See SPLICE_F_NONBLOCK in the splice(2)
+ * man page.
+ */
+ FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
+};
+
+/**
+ * Single data buffer
+ *
+ * Generic data buffer for I/O, extended attributes, etc... Data may
+ * be supplied as a memory pointer or as a file descriptor
+ */
+struct fuse_buf {
+ /**
+ * Size of data in bytes
+ */
+ size_t size;
+
+ /**
+ * Buffer flags
+ */
+ enum fuse_buf_flags flags;
+
+ /**
+ * Memory pointer
+ *
+ * Used unless FUSE_BUF_IS_FD flag is set.
+ */
+ void *mem;
+
+ /**
+ * File descriptor
+ *
+ * Used if FUSE_BUF_IS_FD flag is set.
+ */
+ int fd;
+
+ /**
+ * File position
+ *
+ * Used if FUSE_BUF_FD_SEEK flag is set.
+ */
+ off_t pos;
+};
+
+/**
+ * Data buffer vector
+ *
+ * An array of data buffers, each containing a memory pointer or a
+ * file descriptor.
+ *
+ * Allocate dynamically to add more than one buffer.
+ */
+struct fuse_bufvec {
+ /**
+ * Number of buffers in the array
+ */
+ size_t count;
+
+ /**
+ * Index of current buffer within the array
+ */
+ size_t idx;
+
+ /**
+ * Current offset within the current buffer
+ */
+ size_t off;
+
+ /**
+ * Array of buffers
+ */
+ struct fuse_buf buf[1];
+};
+
+/* Initialize bufvec with a single buffer of given size */
+#define FUSE_BUFVEC_INIT(size__) \
+ ((struct fuse_bufvec) { \
+ /* .count= */ 1, \
+ /* .idx = */ 0, \
+ /* .off = */ 0, \
+ /* .buf = */ { /* [0] = */ { \
+ /* .size = */ (size__), \
+ /* .flags = */ (enum fuse_buf_flags) 0, \
+ /* .mem = */ NULL, \
+ /* .fd = */ -1, \
+ /* .pos = */ 0, \
+ } } \
+ } )
+
+/**
+ * Get total size of data in a fuse buffer vector
+ *
+ * @param bufv buffer vector
+ * @return size of data
+ */
+size_t fuse_buf_size(const struct fuse_bufvec *bufv);
+
+/**
+ * Copy data from one buffer vector to another
+ *
+ * @param dst destination buffer vector
+ * @param src source buffer vector
+ * @param flags flags controlling the copy
+ * @return actual number of bytes copied or -errno on error
+ */
+ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
+ enum fuse_buf_copy_flags flags);
+
+/* ----------------------------------------------------------- *
+ * Signal handling *
+ * ----------------------------------------------------------- */
+
+/**
+ * Exit session on HUP, TERM and INT signals and ignore PIPE signal
+ *
+ * Stores session in a global variable. May only be called once per
+ * process until fuse_remove_signal_handlers() is called.
+ *
+ * Once either of the POSIX signals arrives, the signal handler calls
+ * fuse_session_exit().
+ *
+ * @param se the session to exit
+ * @return 0 on success, -1 on failure
+ *
+ * See also:
+ * fuse_remove_signal_handlers()
+ */
+int fuse_set_signal_handlers(struct fuse_session *se);
+
+/**
+ * Restore default signal handlers
+ *
+ * Resets global session. After this fuse_set_signal_handlers() may
+ * be called again.
+ *
+ * @param se the same session as given in fuse_set_signal_handlers()
+ *
+ * See also:
+ * fuse_set_signal_handlers()
+ */
+void fuse_remove_signal_handlers(struct fuse_session *se);
+
+/* ----------------------------------------------------------- *
+ * Compatibility stuff *
+ * ----------------------------------------------------------- */
+
+#if !defined(FUSE_USE_VERSION) || FUSE_USE_VERSION < 30
+# error only API version 30 or greater is supported
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/*
+ * This interface uses 64 bit off_t.
+ *
+ * On 32bit systems please add -D_FILE_OFFSET_BITS=64 to your compile flags!
+ */
+
+#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
+_Static_assert(sizeof(off_t) == 8, "fuse: off_t must be 64bit");
+#else
+struct _fuse_off_t_must_be_64bit_dummy_struct \
+ { unsigned _fuse_off_t_must_be_64bit:((sizeof(off_t) == 8) ? 1 : -1); };
+#endif
+
+#endif /* FUSE_COMMON_H_ */
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
new file mode 100644
index 0000000000..d38b630ac5
--- /dev/null
+++ b/tools/virtiofsd/fuse_i.h
@@ -0,0 +1,139 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU LGPLv2.
+ See the file COPYING.LIB
+*/
+
+#include "fuse.h"
+#include "fuse_lowlevel.h"
+
+struct mount_opts;
+
+struct fuse_req {
+ struct fuse_session *se;
+ uint64_t unique;
+ int ctr;
+ pthread_mutex_t lock;
+ struct fuse_ctx ctx;
+ struct fuse_chan *ch;
+ int interrupted;
+ unsigned int ioctl_64bit : 1;
+ union {
+ struct {
+ uint64_t unique;
+ } i;
+ struct {
+ fuse_interrupt_func_t func;
+ void *data;
+ } ni;
+ } u;
+ struct fuse_req *next;
+ struct fuse_req *prev;
+};
+
+struct fuse_notify_req {
+ uint64_t unique;
+ void (*reply)(struct fuse_notify_req *, fuse_req_t, fuse_ino_t,
+ const void *, const struct fuse_buf *);
+ struct fuse_notify_req *next;
+ struct fuse_notify_req *prev;
+};
+
+struct fuse_session {
+ char *mountpoint;
+ volatile int exited;
+ int fd;
+ struct mount_opts *mo;
+ int debug;
+ int deny_others;
+ struct fuse_lowlevel_ops op;
+ int got_init;
+ struct cuse_data *cuse_data;
+ void *userdata;
+ uid_t owner;
+ struct fuse_conn_info conn;
+ struct fuse_req list;
+ struct fuse_req interrupts;
+ pthread_mutex_t lock;
+ int got_destroy;
+ pthread_key_t pipe_key;
+ int broken_splice_nonblock;
+ uint64_t notify_ctr;
+ struct fuse_notify_req notify_list;
+ size_t bufsize;
+ int error;
+};
+
+struct fuse_chan {
+ pthread_mutex_t lock;
+ int ctr;
+ int fd;
+};
+
+/**
+ * Filesystem module
+ *
+ * Filesystem modules are registered with the FUSE_REGISTER_MODULE()
+ * macro.
+ *
+ */
+struct fuse_module {
+ char *name;
+ fuse_module_factory_t factory;
+ struct fuse_module *next;
+ struct fusemod_so *so;
+ int ctr;
+};
+
+/* ----------------------------------------------------------- *
+ * Channel interface (when using -o clone_fd) *
+ * ----------------------------------------------------------- */
+
+/**
+ * Obtain counted reference to the channel
+ *
+ * @param ch the channel
+ * @return the channel
+ */
+struct fuse_chan *fuse_chan_get(struct fuse_chan *ch);
+
+/**
+ * Drop counted reference to a channel
+ *
+ * @param ch the channel
+ */
+void fuse_chan_put(struct fuse_chan *ch);
+
+struct mount_opts *parse_mount_opts(struct fuse_args *args);
+void destroy_mount_opts(struct mount_opts *mo);
+void fuse_mount_version(void);
+unsigned get_max_read(struct mount_opts *o);
+void fuse_kern_unmount(const char *mountpoint, int fd);
+int fuse_kern_mount(const char *mountpoint, struct mount_opts *mo);
+
+int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
+ int count);
+void fuse_free_req(fuse_req_t req);
+
+void cuse_lowlevel_init(fuse_req_t req, fuse_ino_t nodeide, const void *inarg);
+
+int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg);
+
+int fuse_session_receive_buf_int(struct fuse_session *se, struct fuse_buf *buf,
+ struct fuse_chan *ch);
+void fuse_session_process_buf_int(struct fuse_session *se,
+ const struct fuse_buf *buf, struct fuse_chan *ch);
+
+struct fuse *fuse_new_31(struct fuse_args *args, const struct fuse_operations *op,
+ size_t op_size, void *private_data);
+int fuse_loop_mt_32(struct fuse *f, struct fuse_loop_config *config);
+int fuse_session_loop_mt_32(struct fuse_session *se, struct fuse_loop_config *config);
+
+#define FUSE_MAX_MAX_PAGES 256
+#define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32
+
+/* room needed in buffer to accommodate header */
+#define FUSE_BUFFER_HEADER_SIZE 0x1000
+
diff --git a/tools/virtiofsd/fuse_log.h b/tools/virtiofsd/fuse_log.h
new file mode 100644
index 0000000000..5e112e0f53
--- /dev/null
+++ b/tools/virtiofsd/fuse_log.h
@@ -0,0 +1,82 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2019 Red Hat, Inc.
+
+ This program can be distributed under the terms of the GNU LGPLv2.
+ See the file COPYING.LIB.
+*/
+
+#ifndef FUSE_LOG_H_
+#define FUSE_LOG_H_
+
+/** @file
+ *
+ * This file defines the logging interface of FUSE
+ */
+
+#include <stdarg.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Log severity level
+ *
+ * These levels correspond to syslog(2) log levels since they are widely used.
+ */
+enum fuse_log_level {
+ FUSE_LOG_EMERG,
+ FUSE_LOG_ALERT,
+ FUSE_LOG_CRIT,
+ FUSE_LOG_ERR,
+ FUSE_LOG_WARNING,
+ FUSE_LOG_NOTICE,
+ FUSE_LOG_INFO,
+ FUSE_LOG_DEBUG
+};
+
+/**
+ * Log message handler function.
+ *
+ * This function must be thread-safe. It may be called from any libfuse
+ * function, including fuse_parse_cmdline() and other functions invoked before
+ * a FUSE filesystem is created.
+ *
+ * Install a custom log message handler function using fuse_set_log_func().
+ *
+ * @param level log severity level
+ * @param fmt sprintf-style format string including newline
+ * @param ap format string arguments
+ */
+typedef void (*fuse_log_func_t)(enum fuse_log_level level,
+ const char *fmt, va_list ap);
+
+/**
+ * Install a custom log handler function.
+ *
+ * Log messages are emitted by libfuse functions to report errors and debug
+ * information. Messages are printed to stderr by default but this can be
+ * overridden by installing a custom log message handler function.
+ *
+ * The log message handler function is global and affects all FUSE filesystems
+ * created within this process.
+ *
+ * @param func a custom log message handler function or NULL to revert to
+ * the default
+ */
+void fuse_set_log_func(fuse_log_func_t func);
+
+/**
+ * Emit a log message
+ *
+ * @param level severity level (FUSE_LOG_ERR, FUSE_LOG_DEBUG, etc)
+ * @param fmt sprintf-style format string including newline
+ */
+void fuse_log(enum fuse_log_level level, const char *fmt, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FUSE_LOG_H_ */
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
new file mode 100644
index 0000000000..18c6363f07
--- /dev/null
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -0,0 +1,2089 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU LGPLv2.
+ See the file COPYING.LIB.
+*/
+
+#ifndef FUSE_LOWLEVEL_H_
+#define FUSE_LOWLEVEL_H_
+
+/** @file
+ *
+ * Low level API
+ *
+ * IMPORTANT: you should define FUSE_USE_VERSION before including this
+ * header. To use the newest API define it to 31 (recommended for any
+ * new application).
+ */
+
+#ifndef FUSE_USE_VERSION
+#error FUSE_USE_VERSION not defined
+#endif
+
+#include "fuse_common.h"
+
+#include <utime.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sys/uio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ----------------------------------------------------------- *
+ * Miscellaneous definitions *
+ * ----------------------------------------------------------- */
+
+/** The node ID of the root inode */
+#define FUSE_ROOT_ID 1
+
+/** Inode number type */
+typedef uint64_t fuse_ino_t;
+
+/** Request pointer type */
+typedef struct fuse_req *fuse_req_t;
+
+/**
+ * Session
+ *
+ * This provides hooks for processing requests, and exiting
+ */
+struct fuse_session;
+
+/** Directory entry parameters supplied to fuse_reply_entry() */
+struct fuse_entry_param {
+ /** Unique inode number
+ *
+ * In lookup, zero means negative entry (from version 2.5)
+ * Returning ENOENT also means negative entry, but by setting zero
+ * ino the kernel may cache negative entries for entry_timeout
+ * seconds.
+ */
+ fuse_ino_t ino;
+
+ /** Generation number for this entry.
+ *
+ * If the file system will be exported over NFS, the
+ * ino/generation pairs need to be unique over the file
+ * system's lifetime (rather than just the mount time). So if
+ * the file system reuses an inode after it has been deleted,
+ * it must assign a new, previously unused generation number
+ * to the inode at the same time.
+ *
+ */
+ uint64_t generation;
+
+ /** Inode attributes.
+ *
+ * Even if attr_timeout == 0, attr must be correct. For example,
+ * for open(), FUSE uses attr.st_size from lookup() to determine
+ * how many bytes to request. If this value is not correct,
+ * incorrect data will be returned.
+ */
+ struct stat attr;
+
+ /** Validity timeout (in seconds) for inode attributes. If
+ attributes only change as a result of requests that come
+ through the kernel, this should be set to a very large
+ value. */
+ double attr_timeout;
+
+ /** Validity timeout (in seconds) for the name. If directory
+ entries are changed/deleted only as a result of requests
+ that come through the kernel, this should be set to a very
+ large value. */
+ double entry_timeout;
+};
+
+/**
+ * Additional context associated with requests.
+ *
+ * Note that the reported client uid, gid and pid may be zero in some
+ * situations. For example, if the FUSE file system is running in a
+ * PID or user namespace but then accessed from outside the namespace,
+ * there is no valid uid/pid/gid that could be reported.
+ */
+struct fuse_ctx {
+ /** User ID of the calling process */
+ uid_t uid;
+
+ /** Group ID of the calling process */
+ gid_t gid;
+
+ /** Thread ID of the calling process */
+ pid_t pid;
+
+ /** Umask of the calling process */
+ mode_t umask;
+};
+
+struct fuse_forget_data {
+ fuse_ino_t ino;
+ uint64_t nlookup;
+};
+
+/* 'to_set' flags in setattr */
+#define FUSE_SET_ATTR_MODE (1 << 0)
+#define FUSE_SET_ATTR_UID (1 << 1)
+#define FUSE_SET_ATTR_GID (1 << 2)
+#define FUSE_SET_ATTR_SIZE (1 << 3)
+#define FUSE_SET_ATTR_ATIME (1 << 4)
+#define FUSE_SET_ATTR_MTIME (1 << 5)
+#define FUSE_SET_ATTR_ATIME_NOW (1 << 7)
+#define FUSE_SET_ATTR_MTIME_NOW (1 << 8)
+#define FUSE_SET_ATTR_CTIME (1 << 10)
+
+/* ----------------------------------------------------------- *
+ * Request methods and replies *
+ * ----------------------------------------------------------- */
+
+/**
+ * Low level filesystem operations
+ *
+ * Most of the methods (with the exception of init and destroy)
+ * receive a request handle (fuse_req_t) as their first argument.
+ * This handle must be passed to one of the specified reply functions.
+ *
+ * This may be done inside the method invocation, or after the call
+ * has returned. The request handle is valid until one of the reply
+ * functions is called.
+ *
+ * Other pointer arguments (name, fuse_file_info, etc) are not valid
+ * after the call has returned, so if they are needed later, their
+ * contents have to be copied.
+ *
+ * In general, all methods are expected to perform any necessary
+ * permission checking. However, a filesystem may delegate this task
+ * to the kernel by passing the `default_permissions` mount option to
+ * `fuse_session_new()`. In this case, methods will only be called if
+ * the kernel's permission check has succeeded.
+ *
+ * The filesystem sometimes needs to handle a return value of -ENOENT
+ * from the reply function, which means, that the request was
+ * interrupted, and the reply discarded. For example if
+ * fuse_reply_open() return -ENOENT means, that the release method for
+ * this file will not be called.
+ */
+struct fuse_lowlevel_ops {
+ /**
+ * Initialize filesystem
+ *
+ * This function is called when libfuse establishes
+ * communication with the FUSE kernel module. The file system
+ * should use this module to inspect and/or modify the
+ * connection parameters provided in the `conn` structure.
+ *
+ * Note that some parameters may be overwritten by options
+ * passed to fuse_session_new() which take precedence over the
+ * values set in this handler.
+ *
+ * There's no reply to this function
+ *
+ * @param userdata the user data passed to fuse_session_new()
+ */
+ void (*init) (void *userdata, struct fuse_conn_info *conn);
+
+ /**
+ * Clean up filesystem.
+ *
+ * Called on filesystem exit. When this method is called, the
+ * connection to the kernel may be gone already, so that eg. calls
+ * to fuse_lowlevel_notify_* will fail.
+ *
+ * There's no reply to this function
+ *
+ * @param userdata the user data passed to fuse_session_new()
+ */
+ void (*destroy) (void *userdata);
+
+ /**
+ * Look up a directory entry by name and get its attributes.
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name the name to look up
+ */
+ void (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name);
+
+ /**
+ * Forget about an inode
+ *
+ * This function is called when the kernel removes an inode
+ * from its internal caches.
+ *
+ * The inode's lookup count increases by one for every call to
+ * fuse_reply_entry and fuse_reply_create. The nlookup parameter
+ * indicates by how much the lookup count should be decreased.
+ *
+ * Inodes with a non-zero lookup count may receive request from
+ * the kernel even after calls to unlink, rmdir or (when
+ * overwriting an existing file) rename. Filesystems must handle
+ * such requests properly and it is recommended to defer removal
+ * of the inode until the lookup count reaches zero. Calls to
+ * unlink, rmdir or rename will be followed closely by forget
+ * unless the file or directory is open, in which case the
+ * kernel issues forget only after the release or releasedir
+ * calls.
+ *
+ * Note that if a file system will be exported over NFS the
+ * inodes lifetime must extend even beyond forget. See the
+ * generation field in struct fuse_entry_param above.
+ *
+ * On unmount the lookup count for all inodes implicitly drops
+ * to zero. It is not guaranteed that the file system will
+ * receive corresponding forget messages for the affected
+ * inodes.
+ *
+ * Valid replies:
+ * fuse_reply_none
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param nlookup the number of lookups to forget
+ */
+ void (*forget) (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup);
+
+ /**
+ * Get file attributes.
+ *
+ * If writeback caching is enabled, the kernel may have a
+ * better idea of a file's length than the FUSE file system
+ * (eg if there has been a write that extended the file size,
+ * but that has not yet been passed to the filesystem.n
+ *
+ * In this case, the st_size value provided by the file system
+ * will be ignored.
+ *
+ * Valid replies:
+ * fuse_reply_attr
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi for future use, currently always NULL
+ */
+ void (*getattr) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi);
+
+ /**
+ * Set file attributes
+ *
+ * In the 'attr' argument only members indicated by the 'to_set'
+ * bitmask contain valid values. Other members contain undefined
+ * values.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits if the file
+ * size or owner is being changed.
+ *
+ * If the setattr was invoked from the ftruncate() system call
+ * under Linux kernel versions 2.6.15 or later, the fi->fh will
+ * contain the value set by the open method or will be undefined
+ * if the open method didn't set any value. Otherwise (not
+ * ftruncate call, or kernel version earlier than 2.6.15) the fi
+ * parameter will be NULL.
+ *
+ * Valid replies:
+ * fuse_reply_attr
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param attr the attributes
+ * @param to_set bit mask of attributes which should be set
+ * @param fi file information, or NULL
+ */
+ void (*setattr) (fuse_req_t req, fuse_ino_t ino, struct stat *attr,
+ int to_set, struct fuse_file_info *fi);
+
+ /**
+ * Read symbolic link
+ *
+ * Valid replies:
+ * fuse_reply_readlink
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ */
+ void (*readlink) (fuse_req_t req, fuse_ino_t ino);
+
+ /**
+ * Create file node
+ *
+ * Create a regular file, character device, block device, fifo or
+ * socket node.
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to create
+ * @param mode file type and mode with which to create the new file
+ * @param rdev the device number (only valid if created file is a device)
+ */
+ void (*mknod) (fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode, dev_t rdev);
+
+ /**
+ * Create a directory
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to create
+ * @param mode with which to create the new file
+ */
+ void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode);
+
+ /**
+ * Remove a file
+ *
+ * If the file's inode's lookup count is non-zero, the file
+ * system is expected to postpone any removal of the inode
+ * until the lookup count reaches zero (see description of the
+ * forget function).
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to remove
+ */
+ void (*unlink) (fuse_req_t req, fuse_ino_t parent, const char *name);
+
+ /**
+ * Remove a directory
+ *
+ * If the directory's inode's lookup count is non-zero, the
+ * file system is expected to postpone any removal of the
+ * inode until the lookup count reaches zero (see description
+ * of the forget function).
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to remove
+ */
+ void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const char *name);
+
+ /**
+ * Create a symbolic link
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param link the contents of the symbolic link
+ * @param parent inode number of the parent directory
+ * @param name to create
+ */
+ void (*symlink) (fuse_req_t req, const char *link, fuse_ino_t parent,
+ const char *name);
+
+ /** Rename a file
+ *
+ * If the target exists it should be atomically replaced. If
+ * the target's inode's lookup count is non-zero, the file
+ * system is expected to postpone any removal of the inode
+ * until the lookup count reaches zero (see description of the
+ * forget function).
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EINVAL, i.e. all
+ * future bmap requests will fail with EINVAL without being
+ * send to the filesystem process.
+ *
+ * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If
+ * RENAME_NOREPLACE is specified, the filesystem must not
+ * overwrite *newname* if it exists and return an error
+ * instead. If `RENAME_EXCHANGE` is specified, the filesystem
+ * must atomically exchange the two files, i.e. both must
+ * exist and neither may be deleted.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the old parent directory
+ * @param name old name
+ * @param newparent inode number of the new parent directory
+ * @param newname new name
+ */
+ void (*rename) (fuse_req_t req, fuse_ino_t parent, const char *name,
+ fuse_ino_t newparent, const char *newname,
+ unsigned int flags);
+
+ /**
+ * Create a hard link
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the old inode number
+ * @param newparent inode number of the new parent directory
+ * @param newname new name to create
+ */
+ void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
+ const char *newname);
+
+ /**
+ * Open a file
+ *
+ * Open flags are available in fi->flags. The following rules
+ * apply.
+ *
+ * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be
+ * filtered out / handled by the kernel.
+ *
+ * - Access modes (O_RDONLY, O_WRONLY, O_RDWR) should be used
+ * by the filesystem to check if the operation is
+ * permitted. If the ``-o default_permissions`` mount
+ * option is given, this check is already done by the
+ * kernel before calling open() and may thus be omitted by
+ * the filesystem.
+ *
+ * - When writeback caching is enabled, the kernel may send
+ * read requests even for files opened with O_WRONLY. The
+ * filesystem should be prepared to handle this.
+ *
+ * - When writeback caching is disabled, the filesystem is
+ * expected to properly handle the O_APPEND flag and ensure
+ * that each write is appending to the end of the file.
+ *
+ * - When writeback caching is enabled, the kernel will
+ * handle O_APPEND. However, unless all changes to the file
+ * come through the kernel this will not work reliably. The
+ * filesystem should thus either ignore the O_APPEND flag
+ * (and let the kernel handle it), or return an error
+ * (indicating that reliably O_APPEND is not available).
+ *
+ * Filesystem may store an arbitrary file handle (pointer,
+ * index, etc) in fi->fh, and use this in other all other file
+ * operations (read, write, flush, release, fsync).
+ *
+ * Filesystem may also implement stateless file I/O and not store
+ * anything in fi->fh.
+ *
+ * There are also some flags (direct_io, keep_cache) which the
+ * filesystem may set in fi, to change the way the file is opened.
+ * See fuse_file_info structure in <fuse_common.h> for more details.
+ *
+ * If this request is answered with an error code of ENOSYS
+ * and FUSE_CAP_NO_OPEN_SUPPORT is set in
+ * `fuse_conn_info.capable`, this is treated as success and
+ * future calls to open and release will also succeed without being
+ * sent to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_open
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ */
+ void (*open) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi);
+
+ /**
+ * Read data
+ *
+ * Read should send exactly the number of bytes requested except
+ * on EOF or error, otherwise the rest of the data will be
+ * substituted with zeroes. An exception to this is when the file
+ * has been opened in 'direct_io' mode, in which case the return
+ * value of the read system call will reflect the return value of
+ * this operation.
+ *
+ * fi->fh will contain the value set by the open method, or will
+ * be undefined if the open method didn't set any value.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_iov
+ * fuse_reply_data
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param size number of bytes to read
+ * @param off offset to read from
+ * @param fi file information
+ */
+ void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
+ struct fuse_file_info *fi);
+
+ /**
+ * Write data
+ *
+ * Write should return exactly the number of bytes requested
+ * except on error. An exception to this is when the file has
+ * been opened in 'direct_io' mode, in which case the return value
+ * of the write system call will reflect the return value of this
+ * operation.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ *
+ * fi->fh will contain the value set by the open method, or will
+ * be undefined if the open method didn't set any value.
+ *
+ * Valid replies:
+ * fuse_reply_write
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param buf data to write
+ * @param size number of bytes to write
+ * @param off offset to write to
+ * @param fi file information
+ */
+ void (*write) (fuse_req_t req, fuse_ino_t ino, const char *buf,
+ size_t size, off_t off, struct fuse_file_info *fi);
+
+ /**
+ * Flush method
+ *
+ * This is called on each close() of the opened file.
+ *
+ * Since file descriptors can be duplicated (dup, dup2, fork), for
+ * one open call there may be many flush calls.
+ *
+ * Filesystems shouldn't assume that flush will always be called
+ * after some writes, or that if will be called at all.
+ *
+ * fi->fh will contain the value set by the open method, or will
+ * be undefined if the open method didn't set any value.
+ *
+ * NOTE: the name of the method is misleading, since (unlike
+ * fsync) the filesystem is not forced to flush pending writes.
+ * One reason to flush data is if the filesystem wants to return
+ * write errors during close. However, such use is non-portable
+ * because POSIX does not require [close] to wait for delayed I/O to
+ * complete.
+ *
+ * If the filesystem supports file locking operations (setlk,
+ * getlk) it should remove all locks belonging to 'fi->owner'.
+ *
+ * If this request is answered with an error code of ENOSYS,
+ * this is treated as success and future calls to flush() will
+ * succeed automatically without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ *
+ * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
+ */
+ void (*flush) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi);
+
+ /**
+ * Release an open file
+ *
+ * Release is called when there are no more references to an open
+ * file: all file descriptors are closed and all memory mappings
+ * are unmapped.
+ *
+ * For every open call there will be exactly one release call (unless
+ * the filesystem is force-unmounted).
+ *
+ * The filesystem may reply with an error, but error values are
+ * not returned to close() or munmap() which triggered the
+ * release.
+ *
+ * fi->fh will contain the value set by the open method, or will
+ * be undefined if the open method didn't set any value.
+ * fi->flags will contain the same flags as for open.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ */
+ void (*release) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi);
+
+ /**
+ * Synchronize file contents
+ *
+ * If the datasync parameter is non-zero, then only the user data
+ * should be flushed, not the meta data.
+ *
+ * If this request is answered with an error code of ENOSYS,
+ * this is treated as success and future calls to fsync() will
+ * succeed automatically without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param datasync flag indicating if only data should be flushed
+ * @param fi file information
+ */
+ void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync,
+ struct fuse_file_info *fi);
+
+ /**
+ * Open a directory
+ *
+ * Filesystem may store an arbitrary file handle (pointer, index,
+ * etc) in fi->fh, and use this in other all other directory
+ * stream operations (readdir, releasedir, fsyncdir).
+ *
+ * If this request is answered with an error code of ENOSYS and
+ * FUSE_CAP_NO_OPENDIR_SUPPORT is set in `fuse_conn_info.capable`,
+ * this is treated as success and future calls to opendir and
+ * releasedir will also succeed without being sent to the filesystem
+ * process. In addition, the kernel will cache readdir results
+ * as if opendir returned FOPEN_KEEP_CACHE | FOPEN_CACHE_DIR.
+ *
+ * Valid replies:
+ * fuse_reply_open
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ */
+ void (*opendir) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi);
+
+ /**
+ * Read directory
+ *
+ * Send a buffer filled using fuse_add_direntry(), with size not
+ * exceeding the requested size. Send an empty buffer on end of
+ * stream.
+ *
+ * fi->fh will contain the value set by the opendir method, or
+ * will be undefined if the opendir method didn't set any value.
+ *
+ * Returning a directory entry from readdir() does not affect
+ * its lookup count.
+ *
+ * If off_t is non-zero, then it will correspond to one of the off_t
+ * values that was previously returned by readdir() for the same
+ * directory handle. In this case, readdir() should skip over entries
+ * coming before the position defined by the off_t value. If entries
+ * are added or removed while the directory handle is open, they filesystem
+ * may still include the entries that have been removed, and may not
+ * report the entries that have been created. However, addition or
+ * removal of entries must never cause readdir() to skip over unrelated
+ * entries or to report them more than once. This means
+ * that off_t can not be a simple index that enumerates the entries
+ * that have been returned but must contain sufficient information to
+ * uniquely determine the next directory entry to return even when the
+ * set of entries is changing.
+ *
+ * The function does not have to report the '.' and '..'
+ * entries, but is allowed to do so. Note that, if readdir does
+ * not return '.' or '..', they will not be implicitly returned,
+ * and this behavior is observable by the caller.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_data
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param size maximum number of bytes to send
+ * @param off offset to continue reading the directory stream
+ * @param fi file information
+ */
+ void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
+ struct fuse_file_info *fi);
+
+ /**
+ * Release an open directory
+ *
+ * For every opendir call there will be exactly one releasedir
+ * call (unless the filesystem is force-unmounted).
+ *
+ * fi->fh will contain the value set by the opendir method, or
+ * will be undefined if the opendir method didn't set any value.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ */
+ void (*releasedir) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi);
+
+ /**
+ * Synchronize directory contents
+ *
+ * If the datasync parameter is non-zero, then only the directory
+ * contents should be flushed, not the meta data.
+ *
+ * fi->fh will contain the value set by the opendir method, or
+ * will be undefined if the opendir method didn't set any value.
+ *
+ * If this request is answered with an error code of ENOSYS,
+ * this is treated as success and future calls to fsyncdir() will
+ * succeed automatically without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param datasync flag indicating if only data should be flushed
+ * @param fi file information
+ */
+ void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync,
+ struct fuse_file_info *fi);
+
+ /**
+ * Get file system statistics
+ *
+ * Valid replies:
+ * fuse_reply_statfs
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number, zero means "undefined"
+ */
+ void (*statfs) (fuse_req_t req, fuse_ino_t ino);
+
+ /**
+ * Set an extended attribute
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future setxattr() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ */
+ void (*setxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
+ const char *value, size_t size, int flags);
+
+ /**
+ * Get an extended attribute
+ *
+ * If size is zero, the size of the value should be sent with
+ * fuse_reply_xattr.
+ *
+ * If the size is non-zero, and the value fits in the buffer, the
+ * value should be sent with fuse_reply_buf.
+ *
+ * If the size is too small for the value, the ERANGE error should
+ * be sent.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future getxattr() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_data
+ * fuse_reply_xattr
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param name of the extended attribute
+ * @param size maximum size of the value to send
+ */
+ void (*getxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
+ size_t size);
+
+ /**
+ * List extended attribute names
+ *
+ * If size is zero, the total size of the attribute list should be
+ * sent with fuse_reply_xattr.
+ *
+ * If the size is non-zero, and the null character separated
+ * attribute list fits in the buffer, the list should be sent with
+ * fuse_reply_buf.
+ *
+ * If the size is too small for the list, the ERANGE error should
+ * be sent.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future listxattr() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_data
+ * fuse_reply_xattr
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param size maximum size of the list to send
+ */
+ void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size);
+
+ /**
+ * Remove an extended attribute
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future removexattr() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param name of the extended attribute
+ */
+ void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const char *name);
+
+ /**
+ * Check file access permissions
+ *
+ * This will be called for the access() and chdir() system
+ * calls. If the 'default_permissions' mount option is given,
+ * this method is not called.
+ *
+ * This method is not called under Linux kernel versions 2.4.x
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent success, i.e. this and all future access()
+ * requests will succeed without being send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param mask requested access mode
+ */
+ void (*access) (fuse_req_t req, fuse_ino_t ino, int mask);
+
+ /**
+ * Create and open a file
+ *
+ * If the file does not exist, first create it with the specified
+ * mode, and then open it.
+ *
+ * See the description of the open handler for more
+ * information.
+ *
+ * If this method is not implemented or under Linux kernel
+ * versions earlier than 2.6.15, the mknod() and open() methods
+ * will be called instead.
+ *
+ * If this request is answered with an error code of ENOSYS, the handler
+ * is treated as not implemented (i.e., for this and future requests the
+ * mknod() and open() handlers will be called instead).
+ *
+ * Valid replies:
+ * fuse_reply_create
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to create
+ * @param mode file type and mode with which to create the new file
+ * @param fi file information
+ */
+ void (*create) (fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode, struct fuse_file_info *fi);
+
+ /**
+ * Test for a POSIX file lock
+ *
+ * Valid replies:
+ * fuse_reply_lock
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ * @param lock the region/type to test
+ */
+ void (*getlk) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi, struct flock *lock);
+
+ /**
+ * Acquire, modify or release a POSIX file lock
+ *
+ * For POSIX threads (NPTL) there's a 1-1 relation between pid and
+ * owner, but otherwise this is not always the case. For checking
+ * lock ownership, 'fi->owner' must be used. The l_pid field in
+ * 'struct flock' should only be used to fill in this field in
+ * getlk().
+ *
+ * Note: if the locking methods are not implemented, the kernel
+ * will still allow file locking to work locally. Hence these are
+ * only interesting for network filesystems and similar.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ * @param lock the region/type to set
+ * @param sleep locking operation may sleep
+ */
+ void (*setlk) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi,
+ struct flock *lock, int sleep);
+
+ /**
+ * Map block index within file to block index within device
+ *
+ * Note: This makes sense only for block device backed filesystems
+ * mounted with the 'blkdev' option
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure, i.e. all future bmap() requests will
+ * fail with the same error code without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_bmap
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param blocksize unit of block index
+ * @param idx block index within file
+ */
+ void (*bmap) (fuse_req_t req, fuse_ino_t ino, size_t blocksize,
+ uint64_t idx);
+
+ /**
+ * Ioctl
+ *
+ * Note: For unrestricted ioctls (not allowed for FUSE
+ * servers), data in and out areas can be discovered by giving
+ * iovs and setting FUSE_IOCTL_RETRY in *flags*. For
+ * restricted ioctls, kernel prepares in/out data area
+ * according to the information encoded in cmd.
+ *
+ * Valid replies:
+ * fuse_reply_ioctl_retry
+ * fuse_reply_ioctl
+ * fuse_reply_ioctl_iov
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param cmd ioctl command
+ * @param arg ioctl argument
+ * @param fi file information
+ * @param flags for FUSE_IOCTL_* flags
+ * @param in_buf data fetched from the caller
+ * @param in_bufsz number of fetched bytes
+ * @param out_bufsz maximum size of output data
+ *
+ * Note : the unsigned long request submitted by the application
+ * is truncated to 32 bits.
+ */
+ void (*ioctl) (fuse_req_t req, fuse_ino_t ino, unsigned int cmd,
+ void *arg, struct fuse_file_info *fi, unsigned flags,
+ const void *in_buf, size_t in_bufsz, size_t out_bufsz);
+
+ /**
+ * Poll for IO readiness
+ *
+ * Note: If ph is non-NULL, the client should notify
+ * when IO readiness events occur by calling
+ * fuse_lowlevel_notify_poll() with the specified ph.
+ *
+ * Regardless of the number of times poll with a non-NULL ph
+ * is received, single notification is enough to clear all.
+ * Notifying more times incurs overhead but doesn't harm
+ * correctness.
+ *
+ * The callee is responsible for destroying ph with
+ * fuse_pollhandle_destroy() when no longer in use.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as success (with a kernel-defined default poll-mask) and
+ * future calls to pull() will succeed the same way without being send
+ * to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_poll
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ * @param ph poll handle to be used for notification
+ */
+ void (*poll) (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
+ struct fuse_pollhandle *ph);
+
+ /**
+ * Write data made available in a buffer
+ *
+ * This is a more generic version of the ->write() method. If
+ * FUSE_CAP_SPLICE_READ is set in fuse_conn_info.want and the
+ * kernel supports splicing from the fuse device, then the
+ * data will be made available in pipe for supporting zero
+ * copy data transfer.
+ *
+ * buf->count is guaranteed to be one (and thus buf->idx is
+ * always zero). The write_buf handler must ensure that
+ * bufv->off is correctly updated (reflecting the number of
+ * bytes read from bufv->buf[0]).
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ *
+ * Valid replies:
+ * fuse_reply_write
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param bufv buffer containing the data
+ * @param off offset to write to
+ * @param fi file information
+ */
+ void (*write_buf) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_bufvec *bufv, off_t off,
+ struct fuse_file_info *fi);
+
+ /**
+ * Callback function for the retrieve request
+ *
+ * Valid replies:
+ * fuse_reply_none
+ *
+ * @param req request handle
+ * @param cookie user data supplied to fuse_lowlevel_notify_retrieve()
+ * @param ino the inode number supplied to fuse_lowlevel_notify_retrieve()
+ * @param offset the offset supplied to fuse_lowlevel_notify_retrieve()
+ * @param bufv the buffer containing the returned data
+ */
+ void (*retrieve_reply) (fuse_req_t req, void *cookie, fuse_ino_t ino,
+ off_t offset, struct fuse_bufvec *bufv);
+
+ /**
+ * Forget about multiple inodes
+ *
+ * See description of the forget function for more
+ * information.
+ *
+ * Valid replies:
+ * fuse_reply_none
+ *
+ * @param req request handle
+ */
+ void (*forget_multi) (fuse_req_t req, size_t count,
+ struct fuse_forget_data *forgets);
+
+ /**
+ * Acquire, modify or release a BSD file lock
+ *
+ * Note: if the locking methods are not implemented, the kernel
+ * will still allow file locking to work locally. Hence these are
+ * only interesting for network filesystems and similar.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ * @param op the locking operation, see flock(2)
+ */
+ void (*flock) (fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi, int op);
+
+ /**
+ * Allocate requested space. If this function returns success then
+ * subsequent writes to the specified range shall not fail due to the lack
+ * of free space on the file system storage media.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future fallocate() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param offset starting point for allocated region
+ * @param length size of allocated region
+ * @param mode determines the operation to be performed on the given range,
+ * see fallocate(2)
+ */
+ void (*fallocate) (fuse_req_t req, fuse_ino_t ino, int mode,
+ off_t offset, off_t length, struct fuse_file_info *fi);
+
+ /**
+ * Read directory with attributes
+ *
+ * Send a buffer filled using fuse_add_direntry_plus(), with size not
+ * exceeding the requested size. Send an empty buffer on end of
+ * stream.
+ *
+ * fi->fh will contain the value set by the opendir method, or
+ * will be undefined if the opendir method didn't set any value.
+ *
+ * In contrast to readdir() (which does not affect the lookup counts),
+ * the lookup count of every entry returned by readdirplus(), except "."
+ * and "..", is incremented by one.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_data
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param size maximum number of bytes to send
+ * @param off offset to continue reading the directory stream
+ * @param fi file information
+ */
+ void (*readdirplus) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
+ struct fuse_file_info *fi);
+
+ /**
+ * Copy a range of data from one file to another
+ *
+ * Performs an optimized copy between two file descriptors without the
+ * additional cost of transferring data through the FUSE kernel module
+ * to user space (glibc) and then back into the FUSE filesystem again.
+ *
+ * In case this method is not implemented, glibc falls back to reading
+ * data from the source and writing to the destination. Effectively
+ * doing an inefficient copy of the data.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future copy_file_range() requests will fail with EOPNOTSUPP without
+ * being send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_write
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino_in the inode number or the source file
+ * @param off_in starting point from were the data should be read
+ * @param fi_in file information of the source file
+ * @param ino_out the inode number or the destination file
+ * @param off_out starting point where the data should be written
+ * @param fi_out file information of the destination file
+ * @param len maximum size of the data to copy
+ * @param flags passed along with the copy_file_range() syscall
+ */
+ void (*copy_file_range) (fuse_req_t req, fuse_ino_t ino_in,
+ off_t off_in, struct fuse_file_info *fi_in,
+ fuse_ino_t ino_out, off_t off_out,
+ struct fuse_file_info *fi_out, size_t len,
+ int flags);
+
+ /**
+ * Find next data or hole after the specified offset
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure, i.e. all future lseek() requests will
+ * fail with the same error code without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_lseek
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param off offset to start search from
+ * @param whence either SEEK_DATA or SEEK_HOLE
+ * @param fi file information
+ */
+ void (*lseek) (fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
+ struct fuse_file_info *fi);
+};
+
+/**
+ * Reply with an error code or success.
+ *
+ * Possible requests:
+ * all except forget
+ *
+ * Whereever possible, error codes should be chosen from the list of
+ * documented error conditions in the corresponding system calls
+ * manpage.
+ *
+ * An error code of ENOSYS is sometimes treated specially. This is
+ * indicated in the documentation of the affected handler functions.
+ *
+ * The following requests may be answered with a zero error code:
+ * unlink, rmdir, rename, flush, release, fsync, fsyncdir, setxattr,
+ * removexattr, setlk.
+ *
+ * @param req request handle
+ * @param err the positive error value, or zero for success
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_err(fuse_req_t req, int err);
+
+/**
+ * Don't send reply
+ *
+ * Possible requests:
+ * forget
+ * forget_multi
+ * retrieve_reply
+ *
+ * @param req request handle
+ */
+void fuse_reply_none(fuse_req_t req);
+
+/**
+ * Reply with a directory entry
+ *
+ * Possible requests:
+ * lookup, mknod, mkdir, symlink, link
+ *
+ * Side effects:
+ * increments the lookup count on success
+ *
+ * @param req request handle
+ * @param e the entry parameters
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e);
+
+/**
+ * Reply with a directory entry and open parameters
+ *
+ * currently the following members of 'fi' are used:
+ * fh, direct_io, keep_cache
+ *
+ * Possible requests:
+ * create
+ *
+ * Side effects:
+ * increments the lookup count on success
+ *
+ * @param req request handle
+ * @param e the entry parameters
+ * @param fi file information
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
+ const struct fuse_file_info *fi);
+
+/**
+ * Reply with attributes
+ *
+ * Possible requests:
+ * getattr, setattr
+ *
+ * @param req request handle
+ * @param attr the attributes
+ * @param attr_timeout validity timeout (in seconds) for the attributes
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_attr(fuse_req_t req, const struct stat *attr,
+ double attr_timeout);
+
+/**
+ * Reply with the contents of a symbolic link
+ *
+ * Possible requests:
+ * readlink
+ *
+ * @param req request handle
+ * @param link symbolic link contents
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_readlink(fuse_req_t req, const char *link);
+
+/**
+ * Reply with open parameters
+ *
+ * currently the following members of 'fi' are used:
+ * fh, direct_io, keep_cache
+ *
+ * Possible requests:
+ * open, opendir
+ *
+ * @param req request handle
+ * @param fi file information
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *fi);
+
+/**
+ * Reply with number of bytes written
+ *
+ * Possible requests:
+ * write
+ *
+ * @param req request handle
+ * @param count the number of bytes written
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_write(fuse_req_t req, size_t count);
+
+/**
+ * Reply with data
+ *
+ * Possible requests:
+ * read, readdir, getxattr, listxattr
+ *
+ * @param req request handle
+ * @param buf buffer containing data
+ * @param size the size of data in bytes
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
+
+/**
+ * Reply with data copied/moved from buffer(s)
+ *
+ * Zero copy data transfer ("splicing") will be used under
+ * the following circumstances:
+ *
+ * 1. FUSE_CAP_SPLICE_WRITE is set in fuse_conn_info.want, and
+ * 2. the kernel supports splicing from the fuse device
+ * (FUSE_CAP_SPLICE_WRITE is set in fuse_conn_info.capable), and
+ * 3. *flags* does not contain FUSE_BUF_NO_SPLICE
+ * 4. The amount of data that is provided in file-descriptor backed
+ * buffers (i.e., buffers for which bufv[n].flags == FUSE_BUF_FD)
+ * is at least twice the page size.
+ *
+ * In order for SPLICE_F_MOVE to be used, the following additional
+ * conditions have to be fulfilled:
+ *
+ * 1. FUSE_CAP_SPLICE_MOVE is set in fuse_conn_info.want, and
+ * 2. the kernel supports it (i.e, FUSE_CAP_SPLICE_MOVE is set in
+ fuse_conn_info.capable), and
+ * 3. *flags* contains FUSE_BUF_SPLICE_MOVE
+ *
+ * Note that, if splice is used, the data is actually spliced twice:
+ * once into a temporary pipe (to prepend header data), and then again
+ * into the kernel. If some of the provided buffers are memory-backed,
+ * the data in them is copied in step one and spliced in step two.
+ *
+ * The FUSE_BUF_SPLICE_FORCE_SPLICE and FUSE_BUF_SPLICE_NONBLOCK flags
+ * are silently ignored.
+ *
+ * Possible requests:
+ * read, readdir, getxattr, listxattr
+ *
+ * Side effects:
+ * when used to return data from a readdirplus() (but not readdir())
+ * call, increments the lookup count of each returned entry by one
+ * on success.
+ *
+ * @param req request handle
+ * @param bufv buffer vector
+ * @param flags flags controlling the copy
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
+ enum fuse_buf_copy_flags flags);
+
+/**
+ * Reply with data vector
+ *
+ * Possible requests:
+ * read, readdir, getxattr, listxattr
+ *
+ * @param req request handle
+ * @param iov the vector containing the data
+ * @param count the size of vector
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count);
+
+/**
+ * Reply with filesystem statistics
+ *
+ * Possible requests:
+ * statfs
+ *
+ * @param req request handle
+ * @param stbuf filesystem statistics
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf);
+
+/**
+ * Reply with needed buffer size
+ *
+ * Possible requests:
+ * getxattr, listxattr
+ *
+ * @param req request handle
+ * @param count the buffer size needed in bytes
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_xattr(fuse_req_t req, size_t count);
+
+/**
+ * Reply with file lock information
+ *
+ * Possible requests:
+ * getlk
+ *
+ * @param req request handle
+ * @param lock the lock information
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_lock(fuse_req_t req, const struct flock *lock);
+
+/**
+ * Reply with block index
+ *
+ * Possible requests:
+ * bmap
+ *
+ * @param req request handle
+ * @param idx block index within device
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_bmap(fuse_req_t req, uint64_t idx);
+
+/* ----------------------------------------------------------- *
+ * Filling a buffer in readdir *
+ * ----------------------------------------------------------- */
+
+/**
+ * Add a directory entry to the buffer
+ *
+ * Buffer needs to be large enough to hold the entry. If it's not,
+ * then the entry is not filled in but the size of the entry is still
+ * returned. The caller can check this by comparing the bufsize
+ * parameter with the returned entry size. If the entry size is
+ * larger than the buffer size, the operation failed.
+ *
+ * From the 'stbuf' argument the st_ino field and bits 12-15 of the
+ * st_mode field are used. The other fields are ignored.
+ *
+ * *off* should be any non-zero value that the filesystem can use to
+ * identify the current point in the directory stream. It does not
+ * need to be the actual physical position. A value of zero is
+ * reserved to mean "from the beginning", and should therefore never
+ * be used (the first call to fuse_add_direntry should be passed the
+ * offset of the second directory entry).
+ *
+ * @param req request handle
+ * @param buf the point where the new entry will be added to the buffer
+ * @param bufsize remaining size of the buffer
+ * @param name the name of the entry
+ * @param stbuf the file attributes
+ * @param off the offset of the next entry
+ * @return the space needed for the entry
+ */
+size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,
+ const char *name, const struct stat *stbuf,
+ off_t off);
+
+/**
+ * Add a directory entry to the buffer with the attributes
+ *
+ * See documentation of `fuse_add_direntry()` for more details.
+ *
+ * @param req request handle
+ * @param buf the point where the new entry will be added to the buffer
+ * @param bufsize remaining size of the buffer
+ * @param name the name of the entry
+ * @param e the directory entry
+ * @param off the offset of the next entry
+ * @return the space needed for the entry
+ */
+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);
+
+/**
+ * Reply to ask for data fetch and output buffer preparation. ioctl
+ * will be retried with the specified input data fetched and output
+ * buffer prepared.
+ *
+ * Possible requests:
+ * ioctl
+ *
+ * @param req request handle
+ * @param in_iov iovec specifying data to fetch from the caller
+ * @param in_count number of entries in in_iov
+ * @param out_iov iovec specifying addresses to write output to
+ * @param out_count number of entries in out_iov
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_ioctl_retry(fuse_req_t req,
+ const struct iovec *in_iov, size_t in_count,
+ const struct iovec *out_iov, size_t out_count);
+
+/**
+ * Reply to finish ioctl
+ *
+ * Possible requests:
+ * ioctl
+ *
+ * @param req request handle
+ * @param result result to be passed to the caller
+ * @param buf buffer containing output data
+ * @param size length of output data
+ */
+int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size);
+
+/**
+ * Reply to finish ioctl with iov buffer
+ *
+ * Possible requests:
+ * ioctl
+ *
+ * @param req request handle
+ * @param result result to be passed to the caller
+ * @param iov the vector containing the data
+ * @param count the size of vector
+ */
+int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
+ int count);
+
+/**
+ * Reply with poll result event mask
+ *
+ * @param req request handle
+ * @param revents poll result event mask
+ */
+int fuse_reply_poll(fuse_req_t req, unsigned revents);
+
+/**
+ * Reply with offset
+ *
+ * Possible requests:
+ * lseek
+ *
+ * @param req request handle
+ * @param off offset of next data or hole
+ * @return zero for success, -errno for failure to send reply
+ */
+int fuse_reply_lseek(fuse_req_t req, off_t off);
+
+/* ----------------------------------------------------------- *
+ * Notification *
+ * ----------------------------------------------------------- */
+
+/**
+ * Notify IO readiness event
+ *
+ * For more information, please read comment for poll operation.
+ *
+ * @param ph poll handle to notify IO readiness event for
+ */
+int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph);
+
+/**
+ * Notify to invalidate cache for an inode.
+ *
+ * Added in FUSE protocol version 7.12. If the kernel does not support
+ * this (or a newer) version, the function will return -ENOSYS and do
+ * nothing.
+ *
+ * If the filesystem has writeback caching enabled, invalidating an
+ * inode will first trigger a writeback of all dirty pages. The call
+ * will block until all writeback requests have completed and the
+ * inode has been invalidated. It will, however, not wait for
+ * completion of pending writeback requests that have been issued
+ * before.
+ *
+ * If there are no dirty pages, this function will never block.
+ *
+ * @param se the session object
+ * @param ino the inode number
+ * @param off the offset in the inode where to start invalidating
+ * or negative to invalidate attributes only
+ * @param len the amount of cache to invalidate or 0 for all
+ * @return zero for success, -errno for failure
+ */
+int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
+ off_t off, off_t len);
+
+/**
+ * Notify to invalidate parent attributes and the dentry matching
+ * parent/name
+ *
+ * To avoid a deadlock this function must not be called in the
+ * execution path of a related filesytem operation or within any code
+ * that could hold a lock that could be needed to execute such an
+ * operation. As of kernel 4.18, a "related operation" is a lookup(),
+ * symlink(), mknod(), mkdir(), unlink(), rename(), link() or create()
+ * request for the parent, and a setattr(), unlink(), rmdir(),
+ * rename(), setxattr(), removexattr(), readdir() or readdirplus()
+ * request for the inode itself.
+ *
+ * When called correctly, this function will never block.
+ *
+ * Added in FUSE protocol version 7.12. If the kernel does not support
+ * this (or a newer) version, the function will return -ENOSYS and do
+ * nothing.
+ *
+ * @param se the session object
+ * @param parent inode number
+ * @param name file name
+ * @param namelen strlen() of file name
+ * @return zero for success, -errno for failure
+ */
+int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
+ const char *name, size_t namelen);
+
+/**
+ * This function behaves like fuse_lowlevel_notify_inval_entry() with
+ * the following additional effect (at least as of Linux kernel 4.8):
+ *
+ * If the provided *child* inode matches the inode that is currently
+ * associated with the cached dentry, and if there are any inotify
+ * watches registered for the dentry, then the watchers are informed
+ * that the dentry has been deleted.
+ *
+ * To avoid a deadlock this function must not be called while
+ * executing a related filesytem operation or while holding a lock
+ * that could be needed to execute such an operation (see the
+ * description of fuse_lowlevel_notify_inval_entry() for more
+ * details).
+ *
+ * When called correctly, this function will never block.
+ *
+ * Added in FUSE protocol version 7.18. If the kernel does not support
+ * this (or a newer) version, the function will return -ENOSYS and do
+ * nothing.
+ *
+ * @param se the session object
+ * @param parent inode number
+ * @param child inode number
+ * @param name file name
+ * @param namelen strlen() of file name
+ * @return zero for success, -errno for failure
+ */
+int fuse_lowlevel_notify_delete(struct fuse_session *se,
+ fuse_ino_t parent, fuse_ino_t child,
+ const char *name, size_t namelen);
+
+/**
+ * Store data to the kernel buffers
+ *
+ * Synchronously store data in the kernel buffers belonging to the
+ * given inode. The stored data is marked up-to-date (no read will be
+ * performed against it, unless it's invalidated or evicted from the
+ * cache).
+ *
+ * If the stored data overflows the current file size, then the size
+ * is extended, similarly to a write(2) on the filesystem.
+ *
+ * If this function returns an error, then the store wasn't fully
+ * completed, but it may have been partially completed.
+ *
+ * Added in FUSE protocol version 7.15. If the kernel does not support
+ * this (or a newer) version, the function will return -ENOSYS and do
+ * nothing.
+ *
+ * @param se the session object
+ * @param ino the inode number
+ * @param offset the starting offset into the file to store to
+ * @param bufv buffer vector
+ * @param flags flags controlling the copy
+ * @return zero for success, -errno for failure
+ */
+int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
+ off_t offset, struct fuse_bufvec *bufv,
+ enum fuse_buf_copy_flags flags);
+/**
+ * Retrieve data from the kernel buffers
+ *
+ * Retrieve data in the kernel buffers belonging to the given inode.
+ * If successful then the retrieve_reply() method will be called with
+ * the returned data.
+ *
+ * Only present pages are returned in the retrieve reply. Retrieving
+ * stops when it finds a non-present page and only data prior to that
+ * is returned.
+ *
+ * If this function returns an error, then the retrieve will not be
+ * completed and no reply will be sent.
+ *
+ * This function doesn't change the dirty state of pages in the kernel
+ * buffer. For dirty pages the write() method will be called
+ * regardless of having been retrieved previously.
+ *
+ * Added in FUSE protocol version 7.15. If the kernel does not support
+ * this (or a newer) version, the function will return -ENOSYS and do
+ * nothing.
+ *
+ * @param se the session object
+ * @param ino the inode number
+ * @param size the number of bytes to retrieve
+ * @param offset the starting offset into the file to retrieve from
+ * @param cookie user data to supply to the reply callback
+ * @return zero for success, -errno for failure
+ */
+int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
+ size_t size, off_t offset, void *cookie);
+
+
+/* ----------------------------------------------------------- *
+ * Utility functions *
+ * ----------------------------------------------------------- */
+
+/**
+ * Get the userdata from the request
+ *
+ * @param req request handle
+ * @return the user data passed to fuse_session_new()
+ */
+void *fuse_req_userdata(fuse_req_t req);
+
+/**
+ * Get the context from the request
+ *
+ * The pointer returned by this function will only be valid for the
+ * request's lifetime
+ *
+ * @param req request handle
+ * @return the context structure
+ */
+const struct fuse_ctx *fuse_req_ctx(fuse_req_t req);
+
+/**
+ * Get the current supplementary group IDs for the specified request
+ *
+ * Similar to the getgroups(2) system call, except the return value is
+ * always the total number of group IDs, even if it is larger than the
+ * specified size.
+ *
+ * The current fuse kernel module in linux (as of 2.6.30) doesn't pass
+ * the group list to userspace, hence this function needs to parse
+ * "/proc/$TID/task/$TID/status" to get the group IDs.
+ *
+ * This feature may not be supported on all operating systems. In
+ * such a case this function will return -ENOSYS.
+ *
+ * @param req request handle
+ * @param size size of given array
+ * @param list array of group IDs to be filled in
+ * @return the total number of supplementary group IDs or -errno on failure
+ */
+int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[]);
+
+/**
+ * Callback function for an interrupt
+ *
+ * @param req interrupted request
+ * @param data user data
+ */
+typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data);
+
+/**
+ * Register/unregister callback for an interrupt
+ *
+ * If an interrupt has already happened, then the callback function is
+ * called from within this function, hence it's not possible for
+ * interrupts to be lost.
+ *
+ * @param req request handle
+ * @param func the callback function or NULL for unregister
+ * @param data user data passed to the callback function
+ */
+void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
+ void *data);
+
+/**
+ * Check if a request has already been interrupted
+ *
+ * @param req request handle
+ * @return 1 if the request has been interrupted, 0 otherwise
+ */
+int fuse_req_interrupted(fuse_req_t req);
+
+
+/* ----------------------------------------------------------- *
+ * Inquiry functions *
+ * ----------------------------------------------------------- */
+
+/**
+ * Print low-level version information to stdout.
+ */
+void fuse_lowlevel_version(void);
+
+/**
+ * Print available low-level options to stdout. This is not an
+ * exhaustive list, but includes only those options that may be of
+ * interest to an end-user of a file system.
+ */
+void fuse_lowlevel_help(void);
+
+/**
+ * Print available options for `fuse_parse_cmdline()`.
+ */
+void fuse_cmdline_help(void);
+
+/* ----------------------------------------------------------- *
+ * Filesystem setup & teardown *
+ * ----------------------------------------------------------- */
+
+struct fuse_cmdline_opts {
+ int singlethread;
+ int foreground;
+ int debug;
+ int nodefault_subtype;
+ char *mountpoint;
+ int show_version;
+ int show_help;
+ int clone_fd;
+ unsigned int max_idle_threads;
+};
+
+/**
+ * Utility function to parse common options for simple file systems
+ * using the low-level API. A help text that describes the available
+ * options can be printed with `fuse_cmdline_help`. A single
+ * non-option argument is treated as the mountpoint. Multiple
+ * non-option arguments will result in an error.
+ *
+ * If neither -o subtype= or -o fsname= options are given, a new
+ * subtype option will be added and set to the basename of the program
+ * (the fsname will remain unset, and then defaults to "fuse").
+ *
+ * Known options will be removed from *args*, unknown options will
+ * remain.
+ *
+ * @param args argument vector (input+output)
+ * @param opts output argument for parsed options
+ * @return 0 on success, -1 on failure
+ */
+int fuse_parse_cmdline(struct fuse_args *args,
+ struct fuse_cmdline_opts *opts);
+
+/**
+ * Create a low level session.
+ *
+ * Returns a session structure suitable for passing to
+ * fuse_session_mount() and fuse_session_loop().
+ *
+ * This function accepts most file-system independent mount options
+ * (like context, nodev, ro - see mount(8)), as well as the general
+ * fuse mount options listed in mount.fuse(8) (e.g. -o allow_root and
+ * -o default_permissions, but not ``-o use_ino``). Instead of `-o
+ * debug`, debugging may also enabled with `-d` or `--debug`.
+ *
+ * If not all options are known, an error message is written to stderr
+ * and the function returns NULL.
+ *
+ * Option parsing skips argv[0], which is assumed to contain the
+ * program name. To prevent accidentally passing an option in
+ * argv[0], this element must always be present (even if no options
+ * are specified). It may be set to the empty string ('\0') if no
+ * reasonable value can be provided.
+ *
+ * @param args argument vector
+ * @param op the (low-level) filesystem operations
+ * @param op_size sizeof(struct fuse_lowlevel_ops)
+ * @param userdata user data
+ *
+ * @return the fuse session on success, NULL on failure
+ **/
+struct fuse_session *fuse_session_new(struct fuse_args *args,
+ const struct fuse_lowlevel_ops *op,
+ size_t op_size, void *userdata);
+
+/**
+ * Mount a FUSE file system.
+ *
+ * @param mountpoint the mount point path
+ * @param se session object
+ *
+ * @return 0 on success, -1 on failure.
+ **/
+int fuse_session_mount(struct fuse_session *se, const char *mountpoint);
+
+/**
+ * Enter a single threaded, blocking event loop.
+ *
+ * When the event loop terminates because the connection to the FUSE
+ * kernel module has been closed, this function returns zero. This
+ * happens when the filesystem is unmounted regularly (by the
+ * filesystem owner or root running the umount(8) or fusermount(1)
+ * command), or if connection is explicitly severed by writing ``1``
+ * to the``abort`` file in ``/sys/fs/fuse/connections/NNN``. The only
+ * way to distinguish between these two conditions is to check if the
+ * filesystem is still mounted after the session loop returns.
+ *
+ * When some error occurs during request processing, the function
+ * returns a negated errno(3) value.
+ *
+ * If the loop has been terminated because of a signal handler
+ * installed by fuse_set_signal_handlers(), this function returns the
+ * (positive) signal value that triggered the exit.
+ *
+ * @param se the session
+ * @return 0, -errno, or a signal value
+ */
+int fuse_session_loop(struct fuse_session *se);
+
+/**
+ * Enter a multi-threaded event loop.
+ *
+ * For a description of the return value and the conditions when the
+ * event loop exits, refer to the documentation of
+ * fuse_session_loop().
+ *
+ * @param se the session
+ * @param config session loop configuration
+ * @return see fuse_session_loop()
+ */
+#if FUSE_USE_VERSION < 32
+int fuse_session_loop_mt_31(struct fuse_session *se, int clone_fd);
+#define fuse_session_loop_mt(se, clone_fd) fuse_session_loop_mt_31(se, clone_fd)
+#else
+int fuse_session_loop_mt(struct fuse_session *se, struct fuse_loop_config *config);
+#endif
+
+/**
+ * Flag a session as terminated.
+ *
+ * This function is invoked by the POSIX signal handlers, when
+ * registered using fuse_set_signal_handlers(). It will cause any
+ * running event loops to terminate on the next opportunity.
+ *
+ * @param se the session
+ */
+void fuse_session_exit(struct fuse_session *se);
+
+/**
+ * Reset the terminated flag of a session
+ *
+ * @param se the session
+ */
+void fuse_session_reset(struct fuse_session *se);
+
+/**
+ * Query the terminated flag of a session
+ *
+ * @param se the session
+ * @return 1 if exited, 0 if not exited
+ */
+int fuse_session_exited(struct fuse_session *se);
+
+/**
+ * Ensure that file system is unmounted.
+ *
+ * In regular operation, the file system is typically unmounted by the
+ * user calling umount(8) or fusermount(1), which then terminates the
+ * FUSE session loop. However, the session loop may also terminate as
+ * a result of an explicit call to fuse_session_exit() (e.g. by a
+ * signal handler installed by fuse_set_signal_handler()). In this
+ * case the filesystem remains mounted, but any attempt to access it
+ * will block (while the filesystem process is still running) or give
+ * an ESHUTDOWN error (after the filesystem process has terminated).
+ *
+ * If the communication channel with the FUSE kernel module is still
+ * open (i.e., if the session loop was terminated by an explicit call
+ * to fuse_session_exit()), this function will close it and unmount
+ * the filesystem. If the communication channel has been closed by the
+ * kernel, this method will do (almost) nothing.
+ *
+ * NOTE: The above semantics mean that if the connection to the kernel
+ * is terminated via the ``/sys/fs/fuse/connections/NNN/abort`` file,
+ * this method will *not* unmount the filesystem.
+ *
+ * @param se the session
+ */
+void fuse_session_unmount(struct fuse_session *se);
+
+/**
+ * Destroy a session
+ *
+ * @param se the session
+ */
+void fuse_session_destroy(struct fuse_session *se);
+
+/* ----------------------------------------------------------- *
+ * Custom event loop support *
+ * ----------------------------------------------------------- */
+
+/**
+ * Return file descriptor for communication with kernel.
+ *
+ * The file selector can be used to integrate FUSE with a custom event
+ * loop. Whenever data is available for reading on the provided fd,
+ * the event loop should call `fuse_session_receive_buf` followed by
+ * `fuse_session_process_buf` to process the request.
+ *
+ * The returned file descriptor is valid until `fuse_session_unmount`
+ * is called.
+ *
+ * @param se the session
+ * @return a file descriptor
+ */
+int fuse_session_fd(struct fuse_session *se);
+
+/**
+ * Process a raw request supplied in a generic buffer
+ *
+ * The fuse_buf may contain a memory buffer or a pipe file descriptor.
+ *
+ * @param se the session
+ * @param buf the fuse_buf containing the request
+ */
+void fuse_session_process_buf(struct fuse_session *se,
+ const struct fuse_buf *buf);
+
+/**
+ * Read a raw request from the kernel into the supplied buffer.
+ *
+ * Depending on file system options, system capabilities, and request
+ * size the request is either read into a memory buffer or spliced
+ * into a temporary pipe.
+ *
+ * @param se the session
+ * @param buf the fuse_buf to store the request in
+ * @return the actual size of the raw request, or -errno on error
+ */
+int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FUSE_LOWLEVEL_H_ */
diff --git a/tools/virtiofsd/fuse_misc.h b/tools/virtiofsd/fuse_misc.h
new file mode 100644
index 0000000000..2f6663ed7d
--- /dev/null
+++ b/tools/virtiofsd/fuse_misc.h
@@ -0,0 +1,59 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU LGPLv2.
+ See the file COPYING.LIB
+*/
+
+#include <pthread.h>
+
+/*
+ Versioned symbols cannot be used in some cases because it
+ - confuse the dynamic linker in uClibc
+ - not supported on MacOSX (in MachO binary format)
+*/
+#if (!defined(__UCLIBC__) && !defined(__APPLE__))
+#define FUSE_SYMVER(x) __asm__(x)
+#else
+#define FUSE_SYMVER(x)
+#endif
+
+#ifndef USE_UCLIBC
+#define fuse_mutex_init(mut) pthread_mutex_init(mut, NULL)
+#else
+/* Is this hack still needed? */
+static inline void fuse_mutex_init(pthread_mutex_t *mut)
+{
+ pthread_mutexattr_t attr;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
+ pthread_mutex_init(mut, &attr);
+ pthread_mutexattr_destroy(&attr);
+}
+#endif
+
+#ifdef HAVE_STRUCT_STAT_ST_ATIM
+/* Linux */
+#define ST_ATIM_NSEC(stbuf) ((stbuf)->st_atim.tv_nsec)
+#define ST_CTIM_NSEC(stbuf) ((stbuf)->st_ctim.tv_nsec)
+#define ST_MTIM_NSEC(stbuf) ((stbuf)->st_mtim.tv_nsec)
+#define ST_ATIM_NSEC_SET(stbuf, val) (stbuf)->st_atim.tv_nsec = (val)
+#define ST_CTIM_NSEC_SET(stbuf, val) (stbuf)->st_ctim.tv_nsec = (val)
+#define ST_MTIM_NSEC_SET(stbuf, val) (stbuf)->st_mtim.tv_nsec = (val)
+#elif defined(HAVE_STRUCT_STAT_ST_ATIMESPEC)
+/* FreeBSD */
+#define ST_ATIM_NSEC(stbuf) ((stbuf)->st_atimespec.tv_nsec)
+#define ST_CTIM_NSEC(stbuf) ((stbuf)->st_ctimespec.tv_nsec)
+#define ST_MTIM_NSEC(stbuf) ((stbuf)->st_mtimespec.tv_nsec)
+#define ST_ATIM_NSEC_SET(stbuf, val) (stbuf)->st_atimespec.tv_nsec = (val)
+#define ST_CTIM_NSEC_SET(stbuf, val) (stbuf)->st_ctimespec.tv_nsec = (val)
+#define ST_MTIM_NSEC_SET(stbuf, val) (stbuf)->st_mtimespec.tv_nsec = (val)
+#else
+#define ST_ATIM_NSEC(stbuf) 0
+#define ST_CTIM_NSEC(stbuf) 0
+#define ST_MTIM_NSEC(stbuf) 0
+#define ST_ATIM_NSEC_SET(stbuf, val) do { } while (0)
+#define ST_CTIM_NSEC_SET(stbuf, val) do { } while (0)
+#define ST_MTIM_NSEC_SET(stbuf, val) do { } while (0)
+#endif
diff --git a/tools/virtiofsd/fuse_opt.h b/tools/virtiofsd/fuse_opt.h
new file mode 100644
index 0000000000..d8573e74fd
--- /dev/null
+++ b/tools/virtiofsd/fuse_opt.h
@@ -0,0 +1,271 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU LGPLv2.
+ See the file COPYING.LIB.
+*/
+
+#ifndef FUSE_OPT_H_
+#define FUSE_OPT_H_
+
+/** @file
+ *
+ * This file defines the option parsing interface of FUSE
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Option description
+ *
+ * This structure describes a single option, and action associated
+ * with it, in case it matches.
+ *
+ * More than one such match may occur, in which case the action for
+ * each match is executed.
+ *
+ * There are three possible actions in case of a match:
+ *
+ * i) An integer (int or unsigned) variable determined by 'offset' is
+ * set to 'value'
+ *
+ * ii) The processing function is called, with 'value' as the key
+ *
+ * iii) An integer (any) or string (char *) variable determined by
+ * 'offset' is set to the value of an option parameter
+ *
+ * 'offset' should normally be either set to
+ *
+ * - 'offsetof(struct foo, member)' actions i) and iii)
+ *
+ * - -1 action ii)
+ *
+ * The 'offsetof()' macro is defined in the <stddef.h> header.
+ *
+ * The template determines which options match, and also have an
+ * effect on the action. Normally the action is either i) or ii), but
+ * if a format is present in the template, then action iii) is
+ * performed.
+ *
+ * The types of templates are:
+ *
+ * 1) "-x", "-foo", "--foo", "--foo-bar", etc. These match only
+ * themselves. Invalid values are "--" and anything beginning
+ * with "-o"
+ *
+ * 2) "foo", "foo-bar", etc. These match "-ofoo", "-ofoo-bar" or
+ * the relevant option in a comma separated option list
+ *
+ * 3) "bar=", "--foo=", etc. These are variations of 1) and 2)
+ * which have a parameter
+ *
+ * 4) "bar=%s", "--foo=%lu", etc. Same matching as above but perform
+ * action iii).
+ *
+ * 5) "-x ", etc. Matches either "-xparam" or "-x param" as
+ * two separate arguments
+ *
+ * 6) "-x %s", etc. Combination of 4) and 5)
+ *
+ * If the format is "%s", memory is allocated for the string unlike with
+ * scanf(). The previous value (if non-NULL) stored at the this location is
+ * freed.
+ */
+struct fuse_opt {
+ /** Matching template and optional parameter formatting */
+ const char *templ;
+
+ /**
+ * Offset of variable within 'data' parameter of fuse_opt_parse()
+ * or -1
+ */
+ unsigned long offset;
+
+ /**
+ * Value to set the variable to, or to be passed as 'key' to the
+ * processing function. Ignored if template has a format
+ */
+ int value;
+};
+
+/**
+ * Key option. In case of a match, the processing function will be
+ * called with the specified key.
+ */
+#define FUSE_OPT_KEY(templ, key) { templ, -1U, key }
+
+/**
+ * Last option. An array of 'struct fuse_opt' must end with a NULL
+ * template value
+ */
+#define FUSE_OPT_END { NULL, 0, 0 }
+
+/**
+ * Argument list
+ */
+struct fuse_args {
+ /** Argument count */
+ int argc;
+
+ /** Argument vector. NULL terminated */
+ char **argv;
+
+ /** Is 'argv' allocated? */
+ int allocated;
+};
+
+/**
+ * Initializer for 'struct fuse_args'
+ */
+#define FUSE_ARGS_INIT(argc, argv) { argc, argv, 0 }
+
+/**
+ * Key value passed to the processing function if an option did not
+ * match any template
+ */
+#define FUSE_OPT_KEY_OPT -1
+
+/**
+ * Key value passed to the processing function for all non-options
+ *
+ * Non-options are the arguments beginning with a character other than
+ * '-' or all arguments after the special '--' option
+ */
+#define FUSE_OPT_KEY_NONOPT -2
+
+/**
+ * Special key value for options to keep
+ *
+ * Argument is not passed to processing function, but behave as if the
+ * processing function returned 1
+ */
+#define FUSE_OPT_KEY_KEEP -3
+
+/**
+ * Special key value for options to discard
+ *
+ * Argument is not passed to processing function, but behave as if the
+ * processing function returned zero
+ */
+#define FUSE_OPT_KEY_DISCARD -4
+
+/**
+ * Processing function
+ *
+ * This function is called if
+ * - option did not match any 'struct fuse_opt'
+ * - argument is a non-option
+ * - option did match and offset was set to -1
+ *
+ * The 'arg' parameter will always contain the whole argument or
+ * option including the parameter if exists. A two-argument option
+ * ("-x foo") is always converted to single argument option of the
+ * form "-xfoo" before this function is called.
+ *
+ * Options of the form '-ofoo' are passed to this function without the
+ * '-o' prefix.
+ *
+ * The return value of this function determines whether this argument
+ * is to be inserted into the output argument vector, or discarded.
+ *
+ * @param data is the user data passed to the fuse_opt_parse() function
+ * @param arg is the whole argument or option
+ * @param key determines why the processing function was called
+ * @param outargs the current output argument list
+ * @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept
+ */
+typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
+ struct fuse_args *outargs);
+
+/**
+ * Option parsing function
+ *
+ * If 'args' was returned from a previous call to fuse_opt_parse() or
+ * it was constructed from
+ *
+ * A NULL 'args' is equivalent to an empty argument vector
+ *
+ * A NULL 'opts' is equivalent to an 'opts' array containing a single
+ * end marker
+ *
+ * A NULL 'proc' is equivalent to a processing function always
+ * returning '1'
+ *
+ * @param args is the input and output argument list
+ * @param data is the user data
+ * @param opts is the option description array
+ * @param proc is the processing function
+ * @return -1 on error, 0 on success
+ */
+int fuse_opt_parse(struct fuse_args *args, void *data,
+ const struct fuse_opt opts[], fuse_opt_proc_t proc);
+
+/**
+ * Add an option to a comma separated option list
+ *
+ * @param opts is a pointer to an option list, may point to a NULL value
+ * @param opt is the option to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_add_opt(char **opts, const char *opt);
+
+/**
+ * Add an option, escaping commas, to a comma separated option list
+ *
+ * @param opts is a pointer to an option list, may point to a NULL value
+ * @param opt is the option to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_add_opt_escaped(char **opts, const char *opt);
+
+/**
+ * Add an argument to a NULL terminated argument vector
+ *
+ * @param args is the structure containing the current argument list
+ * @param arg is the new argument to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_add_arg(struct fuse_args *args, const char *arg);
+
+/**
+ * Add an argument at the specified position in a NULL terminated
+ * argument vector
+ *
+ * Adds the argument to the N-th position. This is useful for adding
+ * options at the beginning of the array which must not come after the
+ * special '--' option.
+ *
+ * @param args is the structure containing the current argument list
+ * @param pos is the position at which to add the argument
+ * @param arg is the new argument to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg);
+
+/**
+ * Free the contents of argument list
+ *
+ * The structure itself is not freed
+ *
+ * @param args is the structure containing the argument list
+ */
+void fuse_opt_free_args(struct fuse_args *args);
+
+
+/**
+ * Check if an option matches
+ *
+ * @param opts is the option description array
+ * @param opt is the option to match
+ * @return 1 if a match is found, 0 if not
+ */
+int fuse_opt_match(const struct fuse_opt opts[], const char *opt);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FUSE_OPT_H_ */
diff --git a/tools/virtiofsd/passthrough_helpers.h b/tools/virtiofsd/passthrough_helpers.h
new file mode 100644
index 0000000000..6b77c33600
--- /dev/null
+++ b/tools/virtiofsd/passthrough_helpers.h
@@ -0,0 +1,76 @@
+/*
+ * FUSE: Filesystem in Userspace
+ *
+ * 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 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 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
+ */
+
+/*
+ * Creates files on the underlying file system in response to a FUSE_MKNOD
+ * operation
+ */
+static int mknod_wrapper(int dirfd, const char *path, const char *link,
+ int mode, dev_t rdev)
+{
+ int res;
+
+ if (S_ISREG(mode)) {
+ res = openat(dirfd, path, O_CREAT | O_EXCL | O_WRONLY, mode);
+ if (res >= 0)
+ res = close(res);
+ } else if (S_ISDIR(mode)) {
+ res = mkdirat(dirfd, path, mode);
+ } else if (S_ISLNK(mode) && link != NULL) {
+ res = symlinkat(link, dirfd, path);
+ } else if (S_ISFIFO(mode)) {
+ res = mkfifoat(dirfd, path, mode);
+#ifdef __FreeBSD__
+ } else if (S_ISSOCK(mode)) {
+ struct sockaddr_un su;
+ int fd;
+
+ if (strlen(path) >= sizeof(su.sun_path)) {
+ errno = ENAMETOOLONG;
+ return -1;
+ }
+ fd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (fd >= 0) {
+ /*
+ * We must bind the socket to the underlying file
+ * system to create the socket file, even though
+ * we'll never listen on this socket.
+ */
+ su.sun_family = AF_UNIX;
+ strncpy(su.sun_path, path, sizeof(su.sun_path));
+ res = bindat(dirfd, fd, (struct sockaddr*)&su,
+ sizeof(su));
+ if (res == 0)
+ close(fd);
+ } else {
+ res = -1;
+ }
+#endif
+ } else {
+ res = mknodat(dirfd, path, mode, rdev);
+ }
+
+ return res;
+}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 002/108] virtiofsd: Pull in kernel's fuse.h
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 001/108] virtiofsd: Pull in upstream headers Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 003/108] virtiofsd: Add auxiliary .c's Dr. David Alan Gilbert (git)
` (107 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Update scripts/update-linux-headers.sh to add fuse.h and
use it to pull in fuse.h from the kernel; from v5.5-rc1
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>
---
include/standard-headers/linux/fuse.h | 891 ++++++++++++++++++++++++++
| 1 +
2 files changed, 892 insertions(+)
create mode 100644 include/standard-headers/linux/fuse.h
diff --git a/include/standard-headers/linux/fuse.h b/include/standard-headers/linux/fuse.h
new file mode 100644
index 0000000000..f4df0a40f6
--- /dev/null
+++ b/include/standard-headers/linux/fuse.h
@@ -0,0 +1,891 @@
+/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
+/*
+ This file defines the kernel interface of FUSE
+ Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU GPL.
+ See the file COPYING.
+
+ This -- and only this -- header file may also be distributed under
+ the terms of the BSD Licence as follows:
+
+ Copyright (C) 2001-2007 Miklos Szeredi. 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 AUTHOR 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 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.
+*/
+
+/*
+ * This file defines the kernel interface of FUSE
+ *
+ * Protocol changelog:
+ *
+ * 7.1:
+ * - add the following messages:
+ * FUSE_SETATTR, FUSE_SYMLINK, FUSE_MKNOD, FUSE_MKDIR, FUSE_UNLINK,
+ * FUSE_RMDIR, FUSE_RENAME, FUSE_LINK, FUSE_OPEN, FUSE_READ, FUSE_WRITE,
+ * FUSE_RELEASE, FUSE_FSYNC, FUSE_FLUSH, FUSE_SETXATTR, FUSE_GETXATTR,
+ * FUSE_LISTXATTR, FUSE_REMOVEXATTR, FUSE_OPENDIR, FUSE_READDIR,
+ * FUSE_RELEASEDIR
+ * - add padding to messages to accommodate 32-bit servers on 64-bit kernels
+ *
+ * 7.2:
+ * - add FOPEN_DIRECT_IO and FOPEN_KEEP_CACHE flags
+ * - add FUSE_FSYNCDIR message
+ *
+ * 7.3:
+ * - add FUSE_ACCESS message
+ * - add FUSE_CREATE message
+ * - add filehandle to fuse_setattr_in
+ *
+ * 7.4:
+ * - add frsize to fuse_kstatfs
+ * - clean up request size limit checking
+ *
+ * 7.5:
+ * - add flags and max_write to fuse_init_out
+ *
+ * 7.6:
+ * - add max_readahead to fuse_init_in and fuse_init_out
+ *
+ * 7.7:
+ * - add FUSE_INTERRUPT message
+ * - add POSIX file lock support
+ *
+ * 7.8:
+ * - add lock_owner and flags fields to fuse_release_in
+ * - add FUSE_BMAP message
+ * - add FUSE_DESTROY message
+ *
+ * 7.9:
+ * - new fuse_getattr_in input argument of GETATTR
+ * - add lk_flags in fuse_lk_in
+ * - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
+ * - add blksize field to fuse_attr
+ * - add file flags field to fuse_read_in and fuse_write_in
+ * - Add ATIME_NOW and MTIME_NOW flags to fuse_setattr_in
+ *
+ * 7.10
+ * - add nonseekable open flag
+ *
+ * 7.11
+ * - add IOCTL message
+ * - add unsolicited notification support
+ * - add POLL message and NOTIFY_POLL notification
+ *
+ * 7.12
+ * - add umask flag to input argument of create, mknod and mkdir
+ * - add notification messages for invalidation of inodes and
+ * directory entries
+ *
+ * 7.13
+ * - make max number of background requests and congestion threshold
+ * tunables
+ *
+ * 7.14
+ * - add splice support to fuse device
+ *
+ * 7.15
+ * - add store notify
+ * - add retrieve notify
+ *
+ * 7.16
+ * - add BATCH_FORGET request
+ * - FUSE_IOCTL_UNRESTRICTED shall now return with array of 'struct
+ * fuse_ioctl_iovec' instead of ambiguous 'struct iovec'
+ * - add FUSE_IOCTL_32BIT flag
+ *
+ * 7.17
+ * - add FUSE_FLOCK_LOCKS and FUSE_RELEASE_FLOCK_UNLOCK
+ *
+ * 7.18
+ * - add FUSE_IOCTL_DIR flag
+ * - add FUSE_NOTIFY_DELETE
+ *
+ * 7.19
+ * - add FUSE_FALLOCATE
+ *
+ * 7.20
+ * - add FUSE_AUTO_INVAL_DATA
+ *
+ * 7.21
+ * - add FUSE_READDIRPLUS
+ * - send the requested events in POLL request
+ *
+ * 7.22
+ * - add FUSE_ASYNC_DIO
+ *
+ * 7.23
+ * - add FUSE_WRITEBACK_CACHE
+ * - add time_gran to fuse_init_out
+ * - add reserved space to fuse_init_out
+ * - add FATTR_CTIME
+ * - add ctime and ctimensec to fuse_setattr_in
+ * - add FUSE_RENAME2 request
+ * - add FUSE_NO_OPEN_SUPPORT flag
+ *
+ * 7.24
+ * - add FUSE_LSEEK for SEEK_HOLE and SEEK_DATA support
+ *
+ * 7.25
+ * - add FUSE_PARALLEL_DIROPS
+ *
+ * 7.26
+ * - add FUSE_HANDLE_KILLPRIV
+ * - add FUSE_POSIX_ACL
+ *
+ * 7.27
+ * - add FUSE_ABORT_ERROR
+ *
+ * 7.28
+ * - add FUSE_COPY_FILE_RANGE
+ * - add FOPEN_CACHE_DIR
+ * - add FUSE_MAX_PAGES, add max_pages to init_out
+ * - add FUSE_CACHE_SYMLINKS
+ *
+ * 7.29
+ * - add FUSE_NO_OPENDIR_SUPPORT flag
+ *
+ * 7.30
+ * - add FUSE_EXPLICIT_INVAL_DATA
+ * - add FUSE_IOCTL_COMPAT_X32
+ *
+ * 7.31
+ * - add FUSE_WRITE_KILL_PRIV flag
+ * - add FUSE_SETUPMAPPING and FUSE_REMOVEMAPPING
+ * - add map_alignment to fuse_init_out, add FUSE_MAP_ALIGNMENT flag
+ */
+
+#ifndef _LINUX_FUSE_H
+#define _LINUX_FUSE_H
+
+#include <stdint.h>
+
+/*
+ * Version negotiation:
+ *
+ * Both the kernel and userspace send the version they support in the
+ * INIT request and reply respectively.
+ *
+ * If the major versions match then both shall use the smallest
+ * of the two minor versions for communication.
+ *
+ * If the kernel supports a larger major version, then userspace shall
+ * reply with the major version it supports, ignore the rest of the
+ * INIT message and expect a new INIT message from the kernel with a
+ * matching major version.
+ *
+ * If the library supports a larger major version, then it shall fall
+ * back to the major protocol version sent by the kernel for
+ * communication and reply with that major version (and an arbitrary
+ * supported minor version).
+ */
+
+/** Version number of this interface */
+#define FUSE_KERNEL_VERSION 7
+
+/** Minor version number of this interface */
+#define FUSE_KERNEL_MINOR_VERSION 31
+
+/** The node ID of the root inode */
+#define FUSE_ROOT_ID 1
+
+/* Make sure all structures are padded to 64bit boundary, so 32bit
+ userspace works under 64bit kernels */
+
+struct fuse_attr {
+ uint64_t ino;
+ uint64_t size;
+ uint64_t blocks;
+ uint64_t atime;
+ uint64_t mtime;
+ uint64_t ctime;
+ uint32_t atimensec;
+ uint32_t mtimensec;
+ uint32_t ctimensec;
+ uint32_t mode;
+ uint32_t nlink;
+ uint32_t uid;
+ uint32_t gid;
+ uint32_t rdev;
+ uint32_t blksize;
+ uint32_t padding;
+};
+
+struct fuse_kstatfs {
+ uint64_t blocks;
+ uint64_t bfree;
+ uint64_t bavail;
+ uint64_t files;
+ uint64_t ffree;
+ uint32_t bsize;
+ uint32_t namelen;
+ uint32_t frsize;
+ uint32_t padding;
+ uint32_t spare[6];
+};
+
+struct fuse_file_lock {
+ uint64_t start;
+ uint64_t end;
+ uint32_t type;
+ uint32_t pid; /* tgid */
+};
+
+/**
+ * Bitmasks for fuse_setattr_in.valid
+ */
+#define FATTR_MODE (1 << 0)
+#define FATTR_UID (1 << 1)
+#define FATTR_GID (1 << 2)
+#define FATTR_SIZE (1 << 3)
+#define FATTR_ATIME (1 << 4)
+#define FATTR_MTIME (1 << 5)
+#define FATTR_FH (1 << 6)
+#define FATTR_ATIME_NOW (1 << 7)
+#define FATTR_MTIME_NOW (1 << 8)
+#define FATTR_LOCKOWNER (1 << 9)
+#define FATTR_CTIME (1 << 10)
+
+/**
+ * Flags returned by the OPEN request
+ *
+ * FOPEN_DIRECT_IO: bypass page cache for this open file
+ * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
+ * FOPEN_NONSEEKABLE: the file is not seekable
+ * FOPEN_CACHE_DIR: allow caching this directory
+ * FOPEN_STREAM: the file is stream-like (no file position at all)
+ */
+#define FOPEN_DIRECT_IO (1 << 0)
+#define FOPEN_KEEP_CACHE (1 << 1)
+#define FOPEN_NONSEEKABLE (1 << 2)
+#define FOPEN_CACHE_DIR (1 << 3)
+#define FOPEN_STREAM (1 << 4)
+
+/**
+ * INIT request/reply flags
+ *
+ * FUSE_ASYNC_READ: asynchronous read requests
+ * FUSE_POSIX_LOCKS: remote locking for POSIX file locks
+ * FUSE_FILE_OPS: kernel sends file handle for fstat, etc... (not yet supported)
+ * FUSE_ATOMIC_O_TRUNC: handles the O_TRUNC open flag in the filesystem
+ * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
+ * FUSE_BIG_WRITES: filesystem can handle write size larger than 4kB
+ * FUSE_DONT_MASK: don't apply umask to file mode on create operations
+ * FUSE_SPLICE_WRITE: kernel supports splice write on the device
+ * FUSE_SPLICE_MOVE: kernel supports splice move on the device
+ * FUSE_SPLICE_READ: kernel supports splice read on the device
+ * FUSE_FLOCK_LOCKS: remote locking for BSD style file locks
+ * FUSE_HAS_IOCTL_DIR: kernel supports ioctl on directories
+ * FUSE_AUTO_INVAL_DATA: automatically invalidate cached pages
+ * FUSE_DO_READDIRPLUS: do READDIRPLUS (READDIR+LOOKUP in one)
+ * FUSE_READDIRPLUS_AUTO: adaptive readdirplus
+ * FUSE_ASYNC_DIO: asynchronous direct I/O submission
+ * FUSE_WRITEBACK_CACHE: use writeback cache for buffered writes
+ * FUSE_NO_OPEN_SUPPORT: kernel supports zero-message opens
+ * FUSE_PARALLEL_DIROPS: allow parallel lookups and readdir
+ * FUSE_HANDLE_KILLPRIV: fs handles killing suid/sgid/cap on write/chown/trunc
+ * FUSE_POSIX_ACL: filesystem supports posix acls
+ * FUSE_ABORT_ERROR: reading the device after abort returns ECONNABORTED
+ * FUSE_MAX_PAGES: init_out.max_pages contains the max number of req pages
+ * FUSE_CACHE_SYMLINKS: cache READLINK responses
+ * FUSE_NO_OPENDIR_SUPPORT: kernel supports zero-message opendir
+ * FUSE_EXPLICIT_INVAL_DATA: only invalidate cached pages on explicit request
+ * FUSE_MAP_ALIGNMENT: map_alignment field is valid
+ */
+#define FUSE_ASYNC_READ (1 << 0)
+#define FUSE_POSIX_LOCKS (1 << 1)
+#define FUSE_FILE_OPS (1 << 2)
+#define FUSE_ATOMIC_O_TRUNC (1 << 3)
+#define FUSE_EXPORT_SUPPORT (1 << 4)
+#define FUSE_BIG_WRITES (1 << 5)
+#define FUSE_DONT_MASK (1 << 6)
+#define FUSE_SPLICE_WRITE (1 << 7)
+#define FUSE_SPLICE_MOVE (1 << 8)
+#define FUSE_SPLICE_READ (1 << 9)
+#define FUSE_FLOCK_LOCKS (1 << 10)
+#define FUSE_HAS_IOCTL_DIR (1 << 11)
+#define FUSE_AUTO_INVAL_DATA (1 << 12)
+#define FUSE_DO_READDIRPLUS (1 << 13)
+#define FUSE_READDIRPLUS_AUTO (1 << 14)
+#define FUSE_ASYNC_DIO (1 << 15)
+#define FUSE_WRITEBACK_CACHE (1 << 16)
+#define FUSE_NO_OPEN_SUPPORT (1 << 17)
+#define FUSE_PARALLEL_DIROPS (1 << 18)
+#define FUSE_HANDLE_KILLPRIV (1 << 19)
+#define FUSE_POSIX_ACL (1 << 20)
+#define FUSE_ABORT_ERROR (1 << 21)
+#define FUSE_MAX_PAGES (1 << 22)
+#define FUSE_CACHE_SYMLINKS (1 << 23)
+#define FUSE_NO_OPENDIR_SUPPORT (1 << 24)
+#define FUSE_EXPLICIT_INVAL_DATA (1 << 25)
+#define FUSE_MAP_ALIGNMENT (1 << 26)
+
+/**
+ * CUSE INIT request/reply flags
+ *
+ * CUSE_UNRESTRICTED_IOCTL: use unrestricted ioctl
+ */
+#define CUSE_UNRESTRICTED_IOCTL (1 << 0)
+
+/**
+ * Release flags
+ */
+#define FUSE_RELEASE_FLUSH (1 << 0)
+#define FUSE_RELEASE_FLOCK_UNLOCK (1 << 1)
+
+/**
+ * Getattr flags
+ */
+#define FUSE_GETATTR_FH (1 << 0)
+
+/**
+ * Lock flags
+ */
+#define FUSE_LK_FLOCK (1 << 0)
+
+/**
+ * WRITE flags
+ *
+ * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
+ * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
+ * FUSE_WRITE_KILL_PRIV: kill suid and sgid bits
+ */
+#define FUSE_WRITE_CACHE (1 << 0)
+#define FUSE_WRITE_LOCKOWNER (1 << 1)
+#define FUSE_WRITE_KILL_PRIV (1 << 2)
+
+/**
+ * Read flags
+ */
+#define FUSE_READ_LOCKOWNER (1 << 1)
+
+/**
+ * Ioctl flags
+ *
+ * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
+ * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed
+ * FUSE_IOCTL_RETRY: retry with new iovecs
+ * FUSE_IOCTL_32BIT: 32bit ioctl
+ * FUSE_IOCTL_DIR: is a directory
+ * FUSE_IOCTL_COMPAT_X32: x32 compat ioctl on 64bit machine (64bit time_t)
+ *
+ * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
+ */
+#define FUSE_IOCTL_COMPAT (1 << 0)
+#define FUSE_IOCTL_UNRESTRICTED (1 << 1)
+#define FUSE_IOCTL_RETRY (1 << 2)
+#define FUSE_IOCTL_32BIT (1 << 3)
+#define FUSE_IOCTL_DIR (1 << 4)
+#define FUSE_IOCTL_COMPAT_X32 (1 << 5)
+
+#define FUSE_IOCTL_MAX_IOV 256
+
+/**
+ * Poll flags
+ *
+ * FUSE_POLL_SCHEDULE_NOTIFY: request poll notify
+ */
+#define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
+
+/**
+ * Fsync flags
+ *
+ * FUSE_FSYNC_FDATASYNC: Sync data only, not metadata
+ */
+#define FUSE_FSYNC_FDATASYNC (1 << 0)
+
+enum fuse_opcode {
+ FUSE_LOOKUP = 1,
+ FUSE_FORGET = 2, /* no reply */
+ FUSE_GETATTR = 3,
+ FUSE_SETATTR = 4,
+ FUSE_READLINK = 5,
+ FUSE_SYMLINK = 6,
+ FUSE_MKNOD = 8,
+ FUSE_MKDIR = 9,
+ FUSE_UNLINK = 10,
+ FUSE_RMDIR = 11,
+ FUSE_RENAME = 12,
+ FUSE_LINK = 13,
+ FUSE_OPEN = 14,
+ FUSE_READ = 15,
+ FUSE_WRITE = 16,
+ FUSE_STATFS = 17,
+ FUSE_RELEASE = 18,
+ FUSE_FSYNC = 20,
+ FUSE_SETXATTR = 21,
+ FUSE_GETXATTR = 22,
+ FUSE_LISTXATTR = 23,
+ FUSE_REMOVEXATTR = 24,
+ FUSE_FLUSH = 25,
+ FUSE_INIT = 26,
+ FUSE_OPENDIR = 27,
+ FUSE_READDIR = 28,
+ FUSE_RELEASEDIR = 29,
+ FUSE_FSYNCDIR = 30,
+ FUSE_GETLK = 31,
+ FUSE_SETLK = 32,
+ FUSE_SETLKW = 33,
+ FUSE_ACCESS = 34,
+ FUSE_CREATE = 35,
+ FUSE_INTERRUPT = 36,
+ FUSE_BMAP = 37,
+ FUSE_DESTROY = 38,
+ FUSE_IOCTL = 39,
+ FUSE_POLL = 40,
+ FUSE_NOTIFY_REPLY = 41,
+ FUSE_BATCH_FORGET = 42,
+ FUSE_FALLOCATE = 43,
+ FUSE_READDIRPLUS = 44,
+ FUSE_RENAME2 = 45,
+ FUSE_LSEEK = 46,
+ FUSE_COPY_FILE_RANGE = 47,
+ FUSE_SETUPMAPPING = 48,
+ FUSE_REMOVEMAPPING = 49,
+
+ /* CUSE specific operations */
+ CUSE_INIT = 4096,
+
+ /* Reserved opcodes: helpful to detect structure endian-ness */
+ CUSE_INIT_BSWAP_RESERVED = 1048576, /* CUSE_INIT << 8 */
+ FUSE_INIT_BSWAP_RESERVED = 436207616, /* FUSE_INIT << 24 */
+};
+
+enum fuse_notify_code {
+ FUSE_NOTIFY_POLL = 1,
+ FUSE_NOTIFY_INVAL_INODE = 2,
+ FUSE_NOTIFY_INVAL_ENTRY = 3,
+ FUSE_NOTIFY_STORE = 4,
+ FUSE_NOTIFY_RETRIEVE = 5,
+ FUSE_NOTIFY_DELETE = 6,
+ FUSE_NOTIFY_CODE_MAX,
+};
+
+/* The read buffer is required to be at least 8k, but may be much larger */
+#define FUSE_MIN_READ_BUFFER 8192
+
+#define FUSE_COMPAT_ENTRY_OUT_SIZE 120
+
+struct fuse_entry_out {
+ uint64_t nodeid; /* Inode ID */
+ uint64_t generation; /* Inode generation: nodeid:gen must
+ be unique for the fs's lifetime */
+ uint64_t entry_valid; /* Cache timeout for the name */
+ uint64_t attr_valid; /* Cache timeout for the attributes */
+ uint32_t entry_valid_nsec;
+ uint32_t attr_valid_nsec;
+ struct fuse_attr attr;
+};
+
+struct fuse_forget_in {
+ uint64_t nlookup;
+};
+
+struct fuse_forget_one {
+ uint64_t nodeid;
+ uint64_t nlookup;
+};
+
+struct fuse_batch_forget_in {
+ uint32_t count;
+ uint32_t dummy;
+};
+
+struct fuse_getattr_in {
+ uint32_t getattr_flags;
+ uint32_t dummy;
+ uint64_t fh;
+};
+
+#define FUSE_COMPAT_ATTR_OUT_SIZE 96
+
+struct fuse_attr_out {
+ uint64_t attr_valid; /* Cache timeout for the attributes */
+ uint32_t attr_valid_nsec;
+ uint32_t dummy;
+ struct fuse_attr attr;
+};
+
+#define FUSE_COMPAT_MKNOD_IN_SIZE 8
+
+struct fuse_mknod_in {
+ uint32_t mode;
+ uint32_t rdev;
+ uint32_t umask;
+ uint32_t padding;
+};
+
+struct fuse_mkdir_in {
+ uint32_t mode;
+ uint32_t umask;
+};
+
+struct fuse_rename_in {
+ uint64_t newdir;
+};
+
+struct fuse_rename2_in {
+ uint64_t newdir;
+ uint32_t flags;
+ uint32_t padding;
+};
+
+struct fuse_link_in {
+ uint64_t oldnodeid;
+};
+
+struct fuse_setattr_in {
+ uint32_t valid;
+ uint32_t padding;
+ uint64_t fh;
+ uint64_t size;
+ uint64_t lock_owner;
+ uint64_t atime;
+ uint64_t mtime;
+ uint64_t ctime;
+ uint32_t atimensec;
+ uint32_t mtimensec;
+ uint32_t ctimensec;
+ uint32_t mode;
+ uint32_t unused4;
+ uint32_t uid;
+ uint32_t gid;
+ uint32_t unused5;
+};
+
+struct fuse_open_in {
+ uint32_t flags;
+ uint32_t unused;
+};
+
+struct fuse_create_in {
+ uint32_t flags;
+ uint32_t mode;
+ uint32_t umask;
+ uint32_t padding;
+};
+
+struct fuse_open_out {
+ uint64_t fh;
+ uint32_t open_flags;
+ uint32_t padding;
+};
+
+struct fuse_release_in {
+ uint64_t fh;
+ uint32_t flags;
+ uint32_t release_flags;
+ uint64_t lock_owner;
+};
+
+struct fuse_flush_in {
+ uint64_t fh;
+ uint32_t unused;
+ uint32_t padding;
+ uint64_t lock_owner;
+};
+
+struct fuse_read_in {
+ uint64_t fh;
+ uint64_t offset;
+ uint32_t size;
+ uint32_t read_flags;
+ uint64_t lock_owner;
+ uint32_t flags;
+ uint32_t padding;
+};
+
+#define FUSE_COMPAT_WRITE_IN_SIZE 24
+
+struct fuse_write_in {
+ uint64_t fh;
+ uint64_t offset;
+ uint32_t size;
+ uint32_t write_flags;
+ uint64_t lock_owner;
+ uint32_t flags;
+ uint32_t padding;
+};
+
+struct fuse_write_out {
+ uint32_t size;
+ uint32_t padding;
+};
+
+#define FUSE_COMPAT_STATFS_SIZE 48
+
+struct fuse_statfs_out {
+ struct fuse_kstatfs st;
+};
+
+struct fuse_fsync_in {
+ uint64_t fh;
+ uint32_t fsync_flags;
+ uint32_t padding;
+};
+
+struct fuse_setxattr_in {
+ uint32_t size;
+ uint32_t flags;
+};
+
+struct fuse_getxattr_in {
+ uint32_t size;
+ uint32_t padding;
+};
+
+struct fuse_getxattr_out {
+ uint32_t size;
+ uint32_t padding;
+};
+
+struct fuse_lk_in {
+ uint64_t fh;
+ uint64_t owner;
+ struct fuse_file_lock lk;
+ uint32_t lk_flags;
+ uint32_t padding;
+};
+
+struct fuse_lk_out {
+ struct fuse_file_lock lk;
+};
+
+struct fuse_access_in {
+ uint32_t mask;
+ uint32_t padding;
+};
+
+struct fuse_init_in {
+ uint32_t major;
+ uint32_t minor;
+ uint32_t max_readahead;
+ uint32_t flags;
+};
+
+#define FUSE_COMPAT_INIT_OUT_SIZE 8
+#define FUSE_COMPAT_22_INIT_OUT_SIZE 24
+
+struct fuse_init_out {
+ uint32_t major;
+ uint32_t minor;
+ uint32_t max_readahead;
+ uint32_t flags;
+ uint16_t max_background;
+ uint16_t congestion_threshold;
+ uint32_t max_write;
+ uint32_t time_gran;
+ uint16_t max_pages;
+ uint16_t map_alignment;
+ uint32_t unused[8];
+};
+
+#define CUSE_INIT_INFO_MAX 4096
+
+struct cuse_init_in {
+ uint32_t major;
+ uint32_t minor;
+ uint32_t unused;
+ uint32_t flags;
+};
+
+struct cuse_init_out {
+ uint32_t major;
+ uint32_t minor;
+ uint32_t unused;
+ uint32_t flags;
+ uint32_t max_read;
+ uint32_t max_write;
+ uint32_t dev_major; /* chardev major */
+ uint32_t dev_minor; /* chardev minor */
+ uint32_t spare[10];
+};
+
+struct fuse_interrupt_in {
+ uint64_t unique;
+};
+
+struct fuse_bmap_in {
+ uint64_t block;
+ uint32_t blocksize;
+ uint32_t padding;
+};
+
+struct fuse_bmap_out {
+ uint64_t block;
+};
+
+struct fuse_ioctl_in {
+ uint64_t fh;
+ uint32_t flags;
+ uint32_t cmd;
+ uint64_t arg;
+ uint32_t in_size;
+ uint32_t out_size;
+};
+
+struct fuse_ioctl_iovec {
+ uint64_t base;
+ uint64_t len;
+};
+
+struct fuse_ioctl_out {
+ int32_t result;
+ uint32_t flags;
+ uint32_t in_iovs;
+ uint32_t out_iovs;
+};
+
+struct fuse_poll_in {
+ uint64_t fh;
+ uint64_t kh;
+ uint32_t flags;
+ uint32_t events;
+};
+
+struct fuse_poll_out {
+ uint32_t revents;
+ uint32_t padding;
+};
+
+struct fuse_notify_poll_wakeup_out {
+ uint64_t kh;
+};
+
+struct fuse_fallocate_in {
+ uint64_t fh;
+ uint64_t offset;
+ uint64_t length;
+ uint32_t mode;
+ uint32_t padding;
+};
+
+struct fuse_in_header {
+ uint32_t len;
+ uint32_t opcode;
+ uint64_t unique;
+ uint64_t nodeid;
+ uint32_t uid;
+ uint32_t gid;
+ uint32_t pid;
+ uint32_t padding;
+};
+
+struct fuse_out_header {
+ uint32_t len;
+ int32_t error;
+ uint64_t unique;
+};
+
+struct fuse_dirent {
+ uint64_t ino;
+ uint64_t off;
+ uint32_t namelen;
+ uint32_t type;
+ char name[];
+};
+
+#define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
+#define FUSE_DIRENT_ALIGN(x) \
+ (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
+#define FUSE_DIRENT_SIZE(d) \
+ FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
+
+struct fuse_direntplus {
+ struct fuse_entry_out entry_out;
+ struct fuse_dirent dirent;
+};
+
+#define FUSE_NAME_OFFSET_DIRENTPLUS \
+ offsetof(struct fuse_direntplus, dirent.name)
+#define FUSE_DIRENTPLUS_SIZE(d) \
+ FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen)
+
+struct fuse_notify_inval_inode_out {
+ uint64_t ino;
+ int64_t off;
+ int64_t len;
+};
+
+struct fuse_notify_inval_entry_out {
+ uint64_t parent;
+ uint32_t namelen;
+ uint32_t padding;
+};
+
+struct fuse_notify_delete_out {
+ uint64_t parent;
+ uint64_t child;
+ uint32_t namelen;
+ uint32_t padding;
+};
+
+struct fuse_notify_store_out {
+ uint64_t nodeid;
+ uint64_t offset;
+ uint32_t size;
+ uint32_t padding;
+};
+
+struct fuse_notify_retrieve_out {
+ uint64_t notify_unique;
+ uint64_t nodeid;
+ uint64_t offset;
+ uint32_t size;
+ uint32_t padding;
+};
+
+/* Matches the size of fuse_write_in */
+struct fuse_notify_retrieve_in {
+ uint64_t dummy1;
+ uint64_t offset;
+ uint32_t size;
+ uint32_t dummy2;
+ uint64_t dummy3;
+ uint64_t dummy4;
+};
+
+/* Device ioctls: */
+#define FUSE_DEV_IOC_CLONE _IOR(229, 0, uint32_t)
+
+struct fuse_lseek_in {
+ uint64_t fh;
+ uint64_t offset;
+ uint32_t whence;
+ uint32_t padding;
+};
+
+struct fuse_lseek_out {
+ uint64_t offset;
+};
+
+struct fuse_copy_file_range_in {
+ uint64_t fh_in;
+ uint64_t off_in;
+ uint64_t nodeid_out;
+ uint64_t fh_out;
+ uint64_t off_out;
+ uint64_t len;
+ uint64_t flags;
+};
+
+#endif /* _LINUX_FUSE_H */
--git a/scripts/update-linux-headers.sh b/scripts/update-linux-headers.sh
index f76d77363b..29c27f4681 100755
--- a/scripts/update-linux-headers.sh
+++ b/scripts/update-linux-headers.sh
@@ -186,6 +186,7 @@ rm -rf "$output/include/standard-headers/linux"
mkdir -p "$output/include/standard-headers/linux"
for i in "$tmpdir"/include/linux/*virtio*.h \
"$tmpdir/include/linux/qemu_fw_cfg.h" \
+ "$tmpdir/include/linux/fuse.h" \
"$tmpdir/include/linux/input.h" \
"$tmpdir/include/linux/input-event-codes.h" \
"$tmpdir/include/linux/pci_regs.h" \
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 003/108] virtiofsd: Add auxiliary .c's
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 001/108] virtiofsd: Pull in upstream headers Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 002/108] virtiofsd: Pull in kernel's fuse.h Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 004/108] virtiofsd: Add fuse_lowlevel.c Dr. David Alan Gilbert (git)
` (106 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
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>
---
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' &&
+ s[2] >= '0' && s[2] <= '7') {
+ *d++ = (s[0] - '0') * 0100 +
+ (s[1] - '0') * 0010 +
+ (s[2] - '0');
+ s += 2;
+ } else {
+ *d++ = *s;
+ }
+ } else {
+ *d++ = *s;
+ }
+ }
+ s++;
+ }
+
+ return 0;
+}
+
+static int process_option_group(struct fuse_opt_context *ctx, const char *opts)
+{
+ int res;
+ char *copy = strdup(opts);
+
+ if (!copy) {
+ fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");
+ return -1;
+ }
+ res = process_real_option_group(ctx, copy);
+ free(copy);
+ return res;
+}
+
+static int process_one(struct fuse_opt_context *ctx, const char *arg)
+{
+ if (ctx->nonopt || arg[0] != '-')
+ return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
+ else if (arg[1] == 'o') {
+ if (arg[2])
+ return process_option_group(ctx, arg + 2);
+ else {
+ if (next_arg(ctx, arg) == -1)
+ return -1;
+
+ return process_option_group(ctx,
+ ctx->argv[ctx->argctr]);
+ }
+ } else if (arg[1] == '-' && !arg[2]) {
+ if (add_arg(ctx, arg) == -1)
+ return -1;
+ ctx->nonopt = ctx->outargs.argc;
+ return 0;
+ } else
+ return process_gopt(ctx, arg, 0);
+}
+
+static int opt_parse(struct fuse_opt_context *ctx)
+{
+ if (ctx->argc) {
+ if (add_arg(ctx, ctx->argv[0]) == -1)
+ return -1;
+ }
+
+ for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)
+ if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
+ return -1;
+
+ if (ctx->opts) {
+ if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
+ fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)
+ return -1;
+ }
+
+ /* If option separator ("--") is the last argument, remove it */
+ if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&
+ strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {
+ free(ctx->outargs.argv[ctx->outargs.argc - 1]);
+ ctx->outargs.argv[--ctx->outargs.argc] = NULL;
+ }
+
+ return 0;
+}
+
+int fuse_opt_parse(struct fuse_args *args, void *data,
+ const struct fuse_opt opts[], fuse_opt_proc_t proc)
+{
+ int res;
+ struct fuse_opt_context ctx = {
+ .data = data,
+ .opt = opts,
+ .proc = proc,
+ };
+
+ if (!args || !args->argv || !args->argc)
+ return 0;
+
+ ctx.argc = args->argc;
+ ctx.argv = args->argv;
+
+ res = opt_parse(&ctx);
+ if (res != -1) {
+ struct fuse_args tmp = *args;
+ *args = ctx.outargs;
+ ctx.outargs = tmp;
+ }
+ free(ctx.opts);
+ fuse_opt_free_args(&ctx.outargs);
+ return res;
+}
diff --git a/tools/virtiofsd/fuse_signals.c b/tools/virtiofsd/fuse_signals.c
new file mode 100644
index 0000000000..4271947bd4
--- /dev/null
+++ b/tools/virtiofsd/fuse_signals.c
@@ -0,0 +1,91 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ Utility functions for setting signal handlers.
+
+ This program can be distributed under the terms of the GNU LGPLv2.
+ See the file COPYING.LIB
+*/
+
+#include "config.h"
+#include "fuse_lowlevel.h"
+#include "fuse_i.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <stdlib.h>
+
+static struct fuse_session *fuse_instance;
+
+static void exit_handler(int sig)
+{
+ if (fuse_instance) {
+ fuse_session_exit(fuse_instance);
+ if(sig <= 0) {
+ fuse_log(FUSE_LOG_ERR, "assertion error: signal value <= 0\n");
+ abort();
+ }
+ fuse_instance->error = sig;
+ }
+}
+
+static void do_nothing(int sig)
+{
+ (void) sig;
+}
+
+static int set_one_signal_handler(int sig, void (*handler)(int), int remove)
+{
+ struct sigaction sa;
+ struct sigaction old_sa;
+
+ memset(&sa, 0, sizeof(struct sigaction));
+ sa.sa_handler = remove ? SIG_DFL : handler;
+ sigemptyset(&(sa.sa_mask));
+ sa.sa_flags = 0;
+
+ if (sigaction(sig, NULL, &old_sa) == -1) {
+ perror("fuse: cannot get old signal handler");
+ return -1;
+ }
+
+ if (old_sa.sa_handler == (remove ? handler : SIG_DFL) &&
+ sigaction(sig, &sa, NULL) == -1) {
+ perror("fuse: cannot set signal handler");
+ return -1;
+ }
+ return 0;
+}
+
+int fuse_set_signal_handlers(struct fuse_session *se)
+{
+ /* If we used SIG_IGN instead of the do_nothing function,
+ then we would be unable to tell if we set SIG_IGN (and
+ thus should reset to SIG_DFL in fuse_remove_signal_handlers)
+ or if it was already set to SIG_IGN (and should be left
+ untouched. */
+ if (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||
+ set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||
+ set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||
+ set_one_signal_handler(SIGPIPE, do_nothing, 0) == -1)
+ return -1;
+
+ fuse_instance = se;
+ return 0;
+}
+
+void fuse_remove_signal_handlers(struct fuse_session *se)
+{
+ if (fuse_instance != se)
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: fuse_remove_signal_handlers: unknown session\n");
+ else
+ fuse_instance = NULL;
+
+ set_one_signal_handler(SIGHUP, exit_handler, 1);
+ set_one_signal_handler(SIGINT, exit_handler, 1);
+ set_one_signal_handler(SIGTERM, exit_handler, 1);
+ set_one_signal_handler(SIGPIPE, do_nothing, 1);
+}
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
new file mode 100644
index 0000000000..64ff7ad6d5
--- /dev/null
+++ b/tools/virtiofsd/helper.c
@@ -0,0 +1,440 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ Helper functions to create (simple) standalone programs. With the
+ aid of these functions it should be possible to create full FUSE
+ file system by implementing nothing but the request handlers.
+
+ 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_misc.h"
+#include "fuse_opt.h"
+#include "fuse_lowlevel.h"
+#include "mount_util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <sys/param.h>
+
+#define FUSE_HELPER_OPT(t, p) \
+ { t, offsetof(struct fuse_cmdline_opts, p), 1 }
+
+static const struct fuse_opt fuse_helper_opts[] = {
+ FUSE_HELPER_OPT("-h", show_help),
+ FUSE_HELPER_OPT("--help", show_help),
+ FUSE_HELPER_OPT("-V", show_version),
+ FUSE_HELPER_OPT("--version", show_version),
+ FUSE_HELPER_OPT("-d", debug),
+ FUSE_HELPER_OPT("debug", debug),
+ FUSE_HELPER_OPT("-d", foreground),
+ FUSE_HELPER_OPT("debug", foreground),
+ FUSE_OPT_KEY("-d", FUSE_OPT_KEY_KEEP),
+ FUSE_OPT_KEY("debug", FUSE_OPT_KEY_KEEP),
+ FUSE_HELPER_OPT("-f", foreground),
+ FUSE_HELPER_OPT("-s", singlethread),
+ FUSE_HELPER_OPT("fsname=", nodefault_subtype),
+ FUSE_OPT_KEY("fsname=", FUSE_OPT_KEY_KEEP),
+#ifndef __FreeBSD__
+ FUSE_HELPER_OPT("subtype=", nodefault_subtype),
+ FUSE_OPT_KEY("subtype=", FUSE_OPT_KEY_KEEP),
+#endif
+ FUSE_HELPER_OPT("clone_fd", clone_fd),
+ FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),
+ FUSE_OPT_END
+};
+
+struct fuse_conn_info_opts {
+ int atomic_o_trunc;
+ int no_remote_posix_lock;
+ int no_remote_flock;
+ int splice_write;
+ int splice_move;
+ int splice_read;
+ int no_splice_write;
+ int no_splice_move;
+ int no_splice_read;
+ int auto_inval_data;
+ int no_auto_inval_data;
+ int no_readdirplus;
+ int no_readdirplus_auto;
+ int async_dio;
+ int no_async_dio;
+ int writeback_cache;
+ int no_writeback_cache;
+ int async_read;
+ int sync_read;
+ unsigned max_write;
+ unsigned max_readahead;
+ unsigned max_background;
+ unsigned congestion_threshold;
+ unsigned time_gran;
+ int set_max_write;
+ int set_max_readahead;
+ int set_max_background;
+ int set_congestion_threshold;
+ int set_time_gran;
+};
+
+#define CONN_OPTION(t, p, v) \
+ { t, offsetof(struct fuse_conn_info_opts, p), v }
+static const struct fuse_opt conn_info_opt_spec[] = {
+ CONN_OPTION("max_write=%u", max_write, 0),
+ CONN_OPTION("max_write=", set_max_write, 1),
+ CONN_OPTION("max_readahead=%u", max_readahead, 0),
+ CONN_OPTION("max_readahead=", set_max_readahead, 1),
+ CONN_OPTION("max_background=%u", max_background, 0),
+ CONN_OPTION("max_background=", set_max_background, 1),
+ CONN_OPTION("congestion_threshold=%u", congestion_threshold, 0),
+ CONN_OPTION("congestion_threshold=", set_congestion_threshold, 1),
+ CONN_OPTION("sync_read", sync_read, 1),
+ CONN_OPTION("async_read", async_read, 1),
+ CONN_OPTION("atomic_o_trunc", atomic_o_trunc, 1),
+ CONN_OPTION("no_remote_lock", no_remote_posix_lock, 1),
+ CONN_OPTION("no_remote_lock", no_remote_flock, 1),
+ CONN_OPTION("no_remote_flock", no_remote_flock, 1),
+ CONN_OPTION("no_remote_posix_lock", no_remote_posix_lock, 1),
+ CONN_OPTION("splice_write", splice_write, 1),
+ CONN_OPTION("no_splice_write", no_splice_write, 1),
+ CONN_OPTION("splice_move", splice_move, 1),
+ CONN_OPTION("no_splice_move", no_splice_move, 1),
+ CONN_OPTION("splice_read", splice_read, 1),
+ CONN_OPTION("no_splice_read", no_splice_read, 1),
+ CONN_OPTION("auto_inval_data", auto_inval_data, 1),
+ CONN_OPTION("no_auto_inval_data", no_auto_inval_data, 1),
+ CONN_OPTION("readdirplus=no", no_readdirplus, 1),
+ CONN_OPTION("readdirplus=yes", no_readdirplus, 0),
+ CONN_OPTION("readdirplus=yes", no_readdirplus_auto, 1),
+ CONN_OPTION("readdirplus=auto", no_readdirplus, 0),
+ CONN_OPTION("readdirplus=auto", no_readdirplus_auto, 0),
+ CONN_OPTION("async_dio", async_dio, 1),
+ CONN_OPTION("no_async_dio", no_async_dio, 1),
+ CONN_OPTION("writeback_cache", writeback_cache, 1),
+ CONN_OPTION("no_writeback_cache", no_writeback_cache, 1),
+ CONN_OPTION("time_gran=%u", time_gran, 0),
+ CONN_OPTION("time_gran=", set_time_gran, 1),
+ FUSE_OPT_END
+};
+
+
+void fuse_cmdline_help(void)
+{
+ printf(" -h --help print help\n"
+ " -V --version print version\n"
+ " -d -o debug enable debug output (implies -f)\n"
+ " -f foreground operation\n"
+ " -s disable multi-threaded operation\n"
+ " -o clone_fd use separate fuse device fd for each thread\n"
+ " (may improve performance)\n"
+ " -o max_idle_threads the maximum number of idle worker threads\n"
+ " allowed (default: 10)\n");
+}
+
+static int fuse_helper_opt_proc(void *data, const char *arg, int key,
+ struct fuse_args *outargs)
+{
+ (void) outargs;
+ struct fuse_cmdline_opts *opts = data;
+
+ switch (key) {
+ case FUSE_OPT_KEY_NONOPT:
+ if (!opts->mountpoint) {
+ if (fuse_mnt_parse_fuse_fd(arg) != -1) {
+ return fuse_opt_add_opt(&opts->mountpoint, arg);
+ }
+
+ char mountpoint[PATH_MAX] = "";
+ if (realpath(arg, mountpoint) == NULL) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: bad mount point `%s': %s\n",
+ arg, strerror(errno));
+ return -1;
+ }
+ return fuse_opt_add_opt(&opts->mountpoint, mountpoint);
+ } else {
+ fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
+ return -1;
+ }
+
+ default:
+ /* Pass through unknown options */
+ return 1;
+ }
+}
+
+/* Under FreeBSD, there is no subtype option so this
+ function actually sets the fsname */
+static int add_default_subtype(const char *progname, struct fuse_args *args)
+{
+ int res;
+ char *subtype_opt;
+
+ const char *basename = strrchr(progname, '/');
+ if (basename == NULL)
+ basename = progname;
+ else if (basename[1] != '\0')
+ basename++;
+
+ subtype_opt = (char *) malloc(strlen(basename) + 64);
+ if (subtype_opt == NULL) {
+ fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");
+ return -1;
+ }
+#ifdef __FreeBSD__
+ sprintf(subtype_opt, "-ofsname=%s", basename);
+#else
+ sprintf(subtype_opt, "-osubtype=%s", basename);
+#endif
+ res = fuse_opt_add_arg(args, subtype_opt);
+ free(subtype_opt);
+ return res;
+}
+
+int fuse_parse_cmdline(struct fuse_args *args,
+ struct fuse_cmdline_opts *opts)
+{
+ memset(opts, 0, sizeof(struct fuse_cmdline_opts));
+
+ opts->max_idle_threads = 10;
+
+ if (fuse_opt_parse(args, opts, fuse_helper_opts,
+ fuse_helper_opt_proc) == -1)
+ return -1;
+
+ /* *Linux*: if neither -o subtype nor -o fsname are specified,
+ set subtype to program's basename.
+ *FreeBSD*: if fsname is not specified, set to program's
+ basename. */
+ if (!opts->nodefault_subtype)
+ if (add_default_subtype(args->argv[0], args) == -1)
+ return -1;
+
+ return 0;
+}
+
+
+int fuse_daemonize(int foreground)
+{
+ if (!foreground) {
+ int nullfd;
+ int waiter[2];
+ char completed;
+
+ if (pipe(waiter)) {
+ perror("fuse_daemonize: pipe");
+ return -1;
+ }
+
+ /*
+ * demonize current process by forking it and killing the
+ * parent. This makes current process as a child of 'init'.
+ */
+ switch(fork()) {
+ case -1:
+ perror("fuse_daemonize: fork");
+ return -1;
+ case 0:
+ break;
+ default:
+ (void) read(waiter[0], &completed, sizeof(completed));
+ _exit(0);
+ }
+
+ if (setsid() == -1) {
+ perror("fuse_daemonize: setsid");
+ return -1;
+ }
+
+ (void) chdir("/");
+
+ nullfd = open("/dev/null", O_RDWR, 0);
+ if (nullfd != -1) {
+ (void) dup2(nullfd, 0);
+ (void) dup2(nullfd, 1);
+ (void) dup2(nullfd, 2);
+ if (nullfd > 2)
+ close(nullfd);
+ }
+
+ /* Propagate completion of daemon initialization */
+ completed = 1;
+ (void) write(waiter[1], &completed, sizeof(completed));
+ close(waiter[0]);
+ close(waiter[1]);
+ } else {
+ (void) chdir("/");
+ }
+ return 0;
+}
+
+int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
+ size_t op_size, void *user_data)
+{
+ struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
+ struct fuse *fuse;
+ struct fuse_cmdline_opts opts;
+ int res;
+
+ if (fuse_parse_cmdline(&args, &opts) != 0)
+ return 1;
+
+ if (opts.show_version) {
+ printf("FUSE library version %s\n", PACKAGE_VERSION);
+ fuse_lowlevel_version();
+ res = 0;
+ goto out1;
+ }
+
+ if (opts.show_help) {
+ if(args.argv[0][0] != '\0')
+ printf("usage: %s [options] <mountpoint>\n\n",
+ args.argv[0]);
+ printf("FUSE options:\n");
+ fuse_cmdline_help();
+ fuse_lib_help(&args);
+ res = 0;
+ goto out1;
+ }
+
+ if (!opts.show_help &&
+ !opts.mountpoint) {
+ fuse_log(FUSE_LOG_ERR, "error: no mountpoint specified\n");
+ res = 2;
+ goto out1;
+ }
+
+
+ fuse = fuse_new_31(&args, op, op_size, user_data);
+ if (fuse == NULL) {
+ res = 3;
+ goto out1;
+ }
+
+ if (fuse_mount(fuse,opts.mountpoint) != 0) {
+ res = 4;
+ goto out2;
+ }
+
+ if (fuse_daemonize(opts.foreground) != 0) {
+ res = 5;
+ goto out3;
+ }
+
+ struct fuse_session *se = fuse_get_session(fuse);
+ if (fuse_set_signal_handlers(se) != 0) {
+ res = 6;
+ goto out3;
+ }
+
+ if (opts.singlethread)
+ res = fuse_loop(fuse);
+ else {
+ struct fuse_loop_config loop_config;
+ loop_config.clone_fd = opts.clone_fd;
+ loop_config.max_idle_threads = opts.max_idle_threads;
+ res = fuse_loop_mt_32(fuse, &loop_config);
+ }
+ if (res)
+ res = 7;
+
+ fuse_remove_signal_handlers(se);
+out3:
+ fuse_unmount(fuse);
+out2:
+ fuse_destroy(fuse);
+out1:
+ free(opts.mountpoint);
+ fuse_opt_free_args(&args);
+ return res;
+}
+
+
+void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts,
+ struct fuse_conn_info *conn)
+{
+ if(opts->set_max_write)
+ conn->max_write = opts->max_write;
+ if(opts->set_max_background)
+ conn->max_background = opts->max_background;
+ if(opts->set_congestion_threshold)
+ conn->congestion_threshold = opts->congestion_threshold;
+ if(opts->set_time_gran)
+ conn->time_gran = opts->time_gran;
+ if(opts->set_max_readahead)
+ conn->max_readahead = opts->max_readahead;
+
+#define LL_ENABLE(cond,cap) \
+ if (cond) conn->want |= (cap)
+#define LL_DISABLE(cond,cap) \
+ if (cond) conn->want &= ~(cap)
+
+ LL_ENABLE(opts->splice_read, FUSE_CAP_SPLICE_READ);
+ LL_DISABLE(opts->no_splice_read, FUSE_CAP_SPLICE_READ);
+
+ LL_ENABLE(opts->splice_write, FUSE_CAP_SPLICE_WRITE);
+ LL_DISABLE(opts->no_splice_write, FUSE_CAP_SPLICE_WRITE);
+
+ LL_ENABLE(opts->splice_move, FUSE_CAP_SPLICE_MOVE);
+ LL_DISABLE(opts->no_splice_move, FUSE_CAP_SPLICE_MOVE);
+
+ LL_ENABLE(opts->auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
+ LL_DISABLE(opts->no_auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
+
+ LL_DISABLE(opts->no_readdirplus, FUSE_CAP_READDIRPLUS);
+ LL_DISABLE(opts->no_readdirplus_auto, FUSE_CAP_READDIRPLUS_AUTO);
+
+ LL_ENABLE(opts->async_dio, FUSE_CAP_ASYNC_DIO);
+ LL_DISABLE(opts->no_async_dio, FUSE_CAP_ASYNC_DIO);
+
+ LL_ENABLE(opts->writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
+ LL_DISABLE(opts->no_writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
+
+ LL_ENABLE(opts->async_read, FUSE_CAP_ASYNC_READ);
+ LL_DISABLE(opts->sync_read, FUSE_CAP_ASYNC_READ);
+
+ LL_DISABLE(opts->no_remote_posix_lock, FUSE_CAP_POSIX_LOCKS);
+ LL_DISABLE(opts->no_remote_flock, FUSE_CAP_FLOCK_LOCKS);
+}
+
+struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args)
+{
+ struct fuse_conn_info_opts *opts;
+
+ opts = calloc(1, sizeof(struct fuse_conn_info_opts));
+ if(opts == NULL) {
+ fuse_log(FUSE_LOG_ERR, "calloc failed\n");
+ return NULL;
+ }
+ if(fuse_opt_parse(args, opts, conn_info_opt_spec, NULL) == -1) {
+ free(opts);
+ return NULL;
+ }
+ return opts;
+}
+
+int fuse_open_channel(const char *mountpoint, const char* options)
+{
+ struct mount_opts *opts = NULL;
+ int fd = -1;
+ const char *argv[] = { "", "-o", options };
+ int argc = sizeof(argv) / sizeof(argv[0]);
+ struct fuse_args args = FUSE_ARGS_INIT(argc, (char**) argv);
+
+ opts = parse_mount_opts(&args);
+ if (opts == NULL)
+ return -1;
+
+ fd = fuse_kern_mount(mountpoint, opts);
+ destroy_mount_opts(opts);
+
+ return fd;
+}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 004/108] virtiofsd: Add fuse_lowlevel.c
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (2 preceding siblings ...)
2020-01-23 16:44 ` [PULL 003/108] virtiofsd: Add auxiliary .c's Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 005/108] virtiofsd: Add passthrough_ll Dr. David Alan Gilbert (git)
` (105 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
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>
---
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;
+
+ if (llp->size < pipesize) {
+ if (llp->can_grow) {
+ res = fcntl(llp->pipe[0], F_SETPIPE_SZ, pipesize);
+ if (res == -1) {
+ res = grow_pipe_to_max(llp->pipe[0]);
+ if (res > 0)
+ llp->size = res;
+ llp->can_grow = 0;
+ goto fallback;
+ }
+ llp->size = res;
+ }
+ if (llp->size < pipesize)
+ goto fallback;
+ }
+
+
+ res = vmsplice(llp->pipe[1], iov, iov_count, SPLICE_F_NONBLOCK);
+ if (res == -1)
+ goto fallback;
+
+ if (res != headerlen) {
+ res = -EIO;
+ fuse_log(FUSE_LOG_ERR, "fuse: short vmsplice to pipe: %u/%zu\n", res,
+ headerlen);
+ goto clear_pipe;
+ }
+
+ pipe_buf.buf[0].flags = FUSE_BUF_IS_FD;
+ pipe_buf.buf[0].fd = llp->pipe[1];
+
+ res = fuse_buf_copy(&pipe_buf, buf,
+ FUSE_BUF_FORCE_SPLICE | FUSE_BUF_SPLICE_NONBLOCK);
+ if (res < 0) {
+ if (res == -EAGAIN || res == -EINVAL) {
+ /*
+ * Should only get EAGAIN on kernels with
+ * broken SPLICE_F_NONBLOCK support (<=
+ * 2.6.35) where this error or a short read is
+ * returned even if the pipe itself is not
+ * full
+ *
+ * EINVAL might mean that splice can't handle
+ * this combination of input and output.
+ */
+ if (res == -EAGAIN)
+ se->broken_splice_nonblock = 1;
+
+ pthread_setspecific(se->pipe_key, NULL);
+ fuse_ll_pipe_free(llp);
+ goto fallback;
+ }
+ res = -res;
+ goto clear_pipe;
+ }
+
+ if (res != 0 && res < len) {
+ struct fuse_bufvec mem_buf = FUSE_BUFVEC_INIT(len);
+ void *mbuf;
+ size_t now_len = res;
+ /*
+ * For regular files a short count is either
+ * 1) due to EOF, or
+ * 2) because of broken SPLICE_F_NONBLOCK (see above)
+ *
+ * For other inputs it's possible that we overflowed
+ * the pipe because of small buffer fragments.
+ */
+
+ res = posix_memalign(&mbuf, pagesize, len);
+ if (res != 0)
+ goto clear_pipe;
+
+ mem_buf.buf[0].mem = mbuf;
+ mem_buf.off = now_len;
+ res = fuse_buf_copy(&mem_buf, buf, 0);
+ if (res > 0) {
+ char *tmpbuf;
+ size_t extra_len = res;
+ /*
+ * Trickiest case: got more data. Need to get
+ * back the data from the pipe and then fall
+ * back to regular write.
+ */
+ tmpbuf = malloc(headerlen);
+ if (tmpbuf == NULL) {
+ free(mbuf);
+ res = ENOMEM;
+ goto clear_pipe;
+ }
+ res = read_back(llp->pipe[0], tmpbuf, headerlen);
+ free(tmpbuf);
+ if (res != 0) {
+ free(mbuf);
+ goto clear_pipe;
+ }
+ res = read_back(llp->pipe[0], mbuf, now_len);
+ if (res != 0) {
+ free(mbuf);
+ goto clear_pipe;
+ }
+ len = now_len + extra_len;
+ 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;
+ }
+ free(mbuf);
+ res = now_len;
+ }
+ len = res;
+ out->len = headerlen + len;
+
+ if (se->debug) {
+ fuse_log(FUSE_LOG_DEBUG,
+ " unique: %llu, success, outsize: %i (splice)\n",
+ (unsigned long long) out->unique, out->len);
+ }
+
+ splice_flags = 0;
+ if ((flags & FUSE_BUF_SPLICE_MOVE) &&
+ (se->conn.want & FUSE_CAP_SPLICE_MOVE))
+ splice_flags |= SPLICE_F_MOVE;
+
+ res = splice(llp->pipe[0], NULL, ch ? ch->fd : se->fd,
+ NULL, out->len, splice_flags);
+ if (res == -1) {
+ res = -errno;
+ perror("fuse: splice from pipe");
+ goto clear_pipe;
+ }
+ if (res != out->len) {
+ res = -EIO;
+ fuse_log(FUSE_LOG_ERR, "fuse: short splice from pipe: %u/%u\n",
+ res, out->len);
+ goto clear_pipe;
+ }
+ return 0;
+
+clear_pipe:
+ fuse_ll_clear_pipe(se);
+ return res;
+
+fallback:
+ return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
+}
+#else
+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)
+{
+ size_t len = fuse_buf_size(buf);
+ (void) flags;
+
+ return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
+}
+#endif
+
+int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
+ enum fuse_buf_copy_flags flags)
+{
+ struct iovec iov[2];
+ struct fuse_out_header out;
+ int res;
+
+ iov[0].iov_base = &out;
+ iov[0].iov_len = sizeof(struct fuse_out_header);
+
+ out.unique = req->unique;
+ out.error = 0;
+
+ res = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv, flags);
+ if (res <= 0) {
+ fuse_free_req(req);
+ return res;
+ } else {
+ return fuse_reply_err(req, res);
+ }
+}
+
+int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
+{
+ struct fuse_statfs_out arg;
+ size_t size = req->se->conn.proto_minor < 4 ?
+ FUSE_COMPAT_STATFS_SIZE : sizeof(arg);
+
+ memset(&arg, 0, sizeof(arg));
+ convert_statfs(stbuf, &arg.st);
+
+ return send_reply_ok(req, &arg, size);
+}
+
+int fuse_reply_xattr(fuse_req_t req, size_t count)
+{
+ struct fuse_getxattr_out arg;
+
+ memset(&arg, 0, sizeof(arg));
+ arg.size = count;
+
+ return send_reply_ok(req, &arg, sizeof(arg));
+}
+
+int fuse_reply_lock(fuse_req_t req, const struct flock *lock)
+{
+ struct fuse_lk_out arg;
+
+ memset(&arg, 0, sizeof(arg));
+ arg.lk.type = lock->l_type;
+ if (lock->l_type != F_UNLCK) {
+ arg.lk.start = lock->l_start;
+ if (lock->l_len == 0)
+ arg.lk.end = OFFSET_MAX;
+ else
+ arg.lk.end = lock->l_start + lock->l_len - 1;
+ }
+ arg.lk.pid = lock->l_pid;
+ return send_reply_ok(req, &arg, sizeof(arg));
+}
+
+int fuse_reply_bmap(fuse_req_t req, uint64_t idx)
+{
+ struct fuse_bmap_out arg;
+
+ memset(&arg, 0, sizeof(arg));
+ arg.block = idx;
+
+ return send_reply_ok(req, &arg, sizeof(arg));
+}
+
+static struct fuse_ioctl_iovec *fuse_ioctl_iovec_copy(const struct iovec *iov,
+ size_t count)
+{
+ struct fuse_ioctl_iovec *fiov;
+ size_t i;
+
+ fiov = malloc(sizeof(fiov[0]) * count);
+ if (!fiov)
+ return NULL;
+
+ for (i = 0; i < count; i++) {
+ fiov[i].base = (uintptr_t) iov[i].iov_base;
+ fiov[i].len = iov[i].iov_len;
+ }
+
+ return fiov;
+}
+
+int fuse_reply_ioctl_retry(fuse_req_t req,
+ const struct iovec *in_iov, size_t in_count,
+ const struct iovec *out_iov, size_t out_count)
+{
+ struct fuse_ioctl_out arg;
+ struct fuse_ioctl_iovec *in_fiov = NULL;
+ struct fuse_ioctl_iovec *out_fiov = NULL;
+ struct iovec iov[4];
+ size_t count = 1;
+ int res;
+
+ memset(&arg, 0, sizeof(arg));
+ arg.flags |= FUSE_IOCTL_RETRY;
+ arg.in_iovs = in_count;
+ arg.out_iovs = out_count;
+ iov[count].iov_base = &arg;
+ iov[count].iov_len = sizeof(arg);
+ count++;
+
+ if (req->se->conn.proto_minor < 16) {
+ if (in_count) {
+ iov[count].iov_base = (void *)in_iov;
+ iov[count].iov_len = sizeof(in_iov[0]) * in_count;
+ count++;
+ }
+
+ if (out_count) {
+ iov[count].iov_base = (void *)out_iov;
+ iov[count].iov_len = sizeof(out_iov[0]) * out_count;
+ count++;
+ }
+ } else {
+ /* Can't handle non-compat 64bit ioctls on 32bit */
+ if (sizeof(void *) == 4 && req->ioctl_64bit) {
+ res = fuse_reply_err(req, EINVAL);
+ goto out;
+ }
+
+ if (in_count) {
+ in_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);
+ if (!in_fiov)
+ goto enomem;
+
+ iov[count].iov_base = (void *)in_fiov;
+ iov[count].iov_len = sizeof(in_fiov[0]) * in_count;
+ count++;
+ }
+ if (out_count) {
+ out_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);
+ if (!out_fiov)
+ goto enomem;
+
+ iov[count].iov_base = (void *)out_fiov;
+ iov[count].iov_len = sizeof(out_fiov[0]) * out_count;
+ count++;
+ }
+ }
+
+ res = send_reply_iov(req, 0, iov, count);
+out:
+ free(in_fiov);
+ free(out_fiov);
+
+ return res;
+
+enomem:
+ res = fuse_reply_err(req, ENOMEM);
+ goto out;
+}
+
+int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size)
+{
+ struct fuse_ioctl_out arg;
+ struct iovec iov[3];
+ size_t count = 1;
+
+ memset(&arg, 0, sizeof(arg));
+ arg.result = result;
+ iov[count].iov_base = &arg;
+ iov[count].iov_len = sizeof(arg);
+ count++;
+
+ if (size) {
+ iov[count].iov_base = (char *) buf;
+ iov[count].iov_len = size;
+ count++;
+ }
+
+ return send_reply_iov(req, 0, iov, count);
+}
+
+int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
+ int count)
+{
+ struct iovec *padded_iov;
+ struct fuse_ioctl_out arg;
+ int res;
+
+ padded_iov = malloc((count + 2) * sizeof(struct iovec));
+ if (padded_iov == NULL)
+ return fuse_reply_err(req, ENOMEM);
+
+ memset(&arg, 0, sizeof(arg));
+ arg.result = result;
+ padded_iov[1].iov_base = &arg;
+ padded_iov[1].iov_len = sizeof(arg);
+
+ memcpy(&padded_iov[2], iov, count * sizeof(struct iovec));
+
+ res = send_reply_iov(req, 0, padded_iov, count + 2);
+ free(padded_iov);
+
+ return res;
+}
+
+int fuse_reply_poll(fuse_req_t req, unsigned revents)
+{
+ struct fuse_poll_out arg;
+
+ memset(&arg, 0, sizeof(arg));
+ arg.revents = revents;
+
+ return send_reply_ok(req, &arg, sizeof(arg));
+}
+
+int fuse_reply_lseek(fuse_req_t req, off_t off)
+{
+ struct fuse_lseek_out arg;
+
+ memset(&arg, 0, sizeof(arg));
+ arg.offset = off;
+
+ return send_reply_ok(req, &arg, sizeof(arg));
+}
+
+static void do_lookup(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ char *name = (char *) inarg;
+
+ if (req->se->op.lookup)
+ req->se->op.lookup(req, nodeid, name);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_forget(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_forget_in *arg = (struct fuse_forget_in *) inarg;
+
+ if (req->se->op.forget)
+ req->se->op.forget(req, nodeid, arg->nlookup);
+ else
+ fuse_reply_none(req);
+}
+
+static void do_batch_forget(fuse_req_t req, fuse_ino_t nodeid,
+ const void *inarg)
+{
+ struct fuse_batch_forget_in *arg = (void *) inarg;
+ struct fuse_forget_one *param = (void *) PARAM(arg);
+ unsigned int i;
+
+ (void) nodeid;
+
+ if (req->se->op.forget_multi) {
+ req->se->op.forget_multi(req, arg->count,
+ (struct fuse_forget_data *) param);
+ } else if (req->se->op.forget) {
+ for (i = 0; i < arg->count; i++) {
+ struct fuse_forget_one *forget = ¶m[i];
+ struct fuse_req *dummy_req;
+
+ dummy_req = fuse_ll_alloc_req(req->se);
+ if (dummy_req == NULL)
+ break;
+
+ dummy_req->unique = req->unique;
+ dummy_req->ctx = req->ctx;
+ dummy_req->ch = NULL;
+
+ req->se->op.forget(dummy_req, forget->nodeid,
+ forget->nlookup);
+ }
+ fuse_reply_none(req);
+ } else {
+ fuse_reply_none(req);
+ }
+}
+
+static void do_getattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_file_info *fip = NULL;
+ struct fuse_file_info fi;
+
+ if (req->se->conn.proto_minor >= 9) {
+ struct fuse_getattr_in *arg = (struct fuse_getattr_in *) inarg;
+
+ if (arg->getattr_flags & FUSE_GETATTR_FH) {
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fip = &fi;
+ }
+ }
+
+ if (req->se->op.getattr)
+ req->se->op.getattr(req, nodeid, fip);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_setattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_setattr_in *arg = (struct fuse_setattr_in *) inarg;
+
+ if (req->se->op.setattr) {
+ struct fuse_file_info *fi = NULL;
+ struct fuse_file_info fi_store;
+ struct stat stbuf;
+ memset(&stbuf, 0, sizeof(stbuf));
+ convert_attr(arg, &stbuf);
+ if (arg->valid & FATTR_FH) {
+ arg->valid &= ~FATTR_FH;
+ memset(&fi_store, 0, sizeof(fi_store));
+ fi = &fi_store;
+ fi->fh = arg->fh;
+ }
+ arg->valid &=
+ FUSE_SET_ATTR_MODE |
+ FUSE_SET_ATTR_UID |
+ FUSE_SET_ATTR_GID |
+ FUSE_SET_ATTR_SIZE |
+ FUSE_SET_ATTR_ATIME |
+ FUSE_SET_ATTR_MTIME |
+ FUSE_SET_ATTR_ATIME_NOW |
+ FUSE_SET_ATTR_MTIME_NOW |
+ FUSE_SET_ATTR_CTIME;
+
+ req->se->op.setattr(req, nodeid, &stbuf, arg->valid, fi);
+ } else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_access(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_access_in *arg = (struct fuse_access_in *) inarg;
+
+ if (req->se->op.access)
+ req->se->op.access(req, nodeid, arg->mask);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_readlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ (void) inarg;
+
+ if (req->se->op.readlink)
+ req->se->op.readlink(req, nodeid);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_mknod(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_mknod_in *arg = (struct fuse_mknod_in *) inarg;
+ char *name = PARAM(arg);
+
+ if (req->se->conn.proto_minor >= 12)
+ req->ctx.umask = arg->umask;
+ else
+ name = (char *) inarg + FUSE_COMPAT_MKNOD_IN_SIZE;
+
+ if (req->se->op.mknod)
+ req->se->op.mknod(req, nodeid, name, arg->mode, arg->rdev);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_mkdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *) inarg;
+
+ if (req->se->conn.proto_minor >= 12)
+ req->ctx.umask = arg->umask;
+
+ if (req->se->op.mkdir)
+ req->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_unlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ char *name = (char *) inarg;
+
+ if (req->se->op.unlink)
+ req->se->op.unlink(req, nodeid, name);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_rmdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ char *name = (char *) inarg;
+
+ if (req->se->op.rmdir)
+ req->se->op.rmdir(req, nodeid, name);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_symlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ char *name = (char *) inarg;
+ char *linkname = ((char *) inarg) + strlen((char *) inarg) + 1;
+
+ if (req->se->op.symlink)
+ req->se->op.symlink(req, linkname, nodeid, name);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_rename(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_rename_in *arg = (struct fuse_rename_in *) inarg;
+ char *oldname = PARAM(arg);
+ char *newname = oldname + strlen(oldname) + 1;
+
+ if (req->se->op.rename)
+ req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
+ 0);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_rename2(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_rename2_in *arg = (struct fuse_rename2_in *) inarg;
+ char *oldname = PARAM(arg);
+ char *newname = oldname + strlen(oldname) + 1;
+
+ if (req->se->op.rename)
+ req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
+ arg->flags);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_link(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_link_in *arg = (struct fuse_link_in *) inarg;
+
+ if (req->se->op.link)
+ req->se->op.link(req, arg->oldnodeid, nodeid, PARAM(arg));
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_create(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_create_in *arg = (struct fuse_create_in *) inarg;
+
+ if (req->se->op.create) {
+ struct fuse_file_info fi;
+ char *name = PARAM(arg);
+
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
+
+ if (req->se->conn.proto_minor >= 12)
+ req->ctx.umask = arg->umask;
+ else
+ name = (char *) inarg + sizeof(struct fuse_open_in);
+
+ req->se->op.create(req, nodeid, name, arg->mode, &fi);
+ } else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_open(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_open_in *arg = (struct fuse_open_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
+
+ if (req->se->op.open)
+ req->se->op.open(req, nodeid, &fi);
+ else
+ fuse_reply_open(req, &fi);
+}
+
+static void do_read(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
+
+ if (req->se->op.read) {
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ if (req->se->conn.proto_minor >= 9) {
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ }
+ req->se->op.read(req, nodeid, arg->size, arg->offset, &fi);
+ } else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_write_in *arg = (struct fuse_write_in *) inarg;
+ struct fuse_file_info fi;
+ char *param;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.writepage = (arg->write_flags & FUSE_WRITE_CACHE) != 0;
+
+ if (req->se->conn.proto_minor < 9) {
+ param = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;
+ } else {
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ param = PARAM(arg);
+ }
+
+ if (req->se->op.write)
+ req->se->op.write(req, nodeid, param, arg->size,
+ arg->offset, &fi);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
+ const struct fuse_buf *ibuf)
+{
+ struct fuse_session *se = req->se;
+ struct fuse_bufvec bufv = {
+ .buf[0] = *ibuf,
+ .count = 1,
+ };
+ struct fuse_write_in *arg = (struct fuse_write_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.writepage = arg->write_flags & FUSE_WRITE_CACHE;
+
+ if (se->conn.proto_minor < 9) {
+ bufv.buf[0].mem = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;
+ bufv.buf[0].size -= sizeof(struct fuse_in_header) +
+ FUSE_COMPAT_WRITE_IN_SIZE;
+ assert(!(bufv.buf[0].flags & FUSE_BUF_IS_FD));
+ } else {
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
+ bufv.buf[0].mem = PARAM(arg);
+
+ bufv.buf[0].size -= sizeof(struct fuse_in_header) +
+ sizeof(struct fuse_write_in);
+ }
+ if (bufv.buf[0].size < arg->size) {
+ fuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");
+ fuse_reply_err(req, EIO);
+ goto out;
+ }
+ bufv.buf[0].size = arg->size;
+
+ se->op.write_buf(req, nodeid, &bufv, arg->offset, &fi);
+
+out:
+ /* Need to reset the pipe if ->write_buf() didn't consume all data */
+ if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
+ fuse_ll_clear_pipe(se);
+}
+
+static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_flush_in *arg = (struct fuse_flush_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.flush = 1;
+ if (req->se->conn.proto_minor >= 7)
+ fi.lock_owner = arg->lock_owner;
+
+ if (req->se->op.flush)
+ req->se->op.flush(req, nodeid, &fi);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_release(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_release_in *arg = (struct fuse_release_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
+ fi.fh = arg->fh;
+ if (req->se->conn.proto_minor >= 8) {
+ fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
+ fi.lock_owner = arg->lock_owner;
+ }
+ if (arg->release_flags & FUSE_RELEASE_FLOCK_UNLOCK) {
+ fi.flock_release = 1;
+ fi.lock_owner = arg->lock_owner;
+ }
+
+ if (req->se->op.release)
+ req->se->op.release(req, nodeid, &fi);
+ else
+ fuse_reply_err(req, 0);
+}
+
+static void do_fsync(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;
+ struct fuse_file_info fi;
+ int datasync = arg->fsync_flags & 1;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+
+ if (req->se->op.fsync)
+ req->se->op.fsync(req, nodeid, datasync, &fi);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_opendir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_open_in *arg = (struct fuse_open_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
+
+ if (req->se->op.opendir)
+ req->se->op.opendir(req, nodeid, &fi);
+ else
+ fuse_reply_open(req, &fi);
+}
+
+static void do_readdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+
+ if (req->se->op.readdir)
+ req->se->op.readdir(req, nodeid, arg->size, arg->offset, &fi);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_readdirplus(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+
+ if (req->se->op.readdirplus)
+ req->se->op.readdirplus(req, nodeid, arg->size, arg->offset, &fi);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_releasedir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_release_in *arg = (struct fuse_release_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
+ fi.fh = arg->fh;
+
+ if (req->se->op.releasedir)
+ req->se->op.releasedir(req, nodeid, &fi);
+ else
+ fuse_reply_err(req, 0);
+}
+
+static void do_fsyncdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;
+ struct fuse_file_info fi;
+ int datasync = arg->fsync_flags & 1;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+
+ if (req->se->op.fsyncdir)
+ req->se->op.fsyncdir(req, nodeid, datasync, &fi);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_statfs(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ (void) nodeid;
+ (void) inarg;
+
+ if (req->se->op.statfs)
+ req->se->op.statfs(req, nodeid);
+ else {
+ struct statvfs buf = {
+ .f_namemax = 255,
+ .f_bsize = 512,
+ };
+ fuse_reply_statfs(req, &buf);
+ }
+}
+
+static void do_setxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_setxattr_in *arg = (struct fuse_setxattr_in *) inarg;
+ char *name = PARAM(arg);
+ char *value = name + strlen(name) + 1;
+
+ if (req->se->op.setxattr)
+ req->se->op.setxattr(req, nodeid, name, value, arg->size,
+ arg->flags);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_getxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;
+
+ if (req->se->op.getxattr)
+ req->se->op.getxattr(req, nodeid, PARAM(arg), arg->size);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_listxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;
+
+ if (req->se->op.listxattr)
+ req->se->op.listxattr(req, nodeid, arg->size);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_removexattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ char *name = (char *) inarg;
+
+ if (req->se->op.removexattr)
+ req->se->op.removexattr(req, nodeid, name);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void convert_fuse_file_lock(struct fuse_file_lock *fl,
+ struct flock *flock)
+{
+ memset(flock, 0, sizeof(struct flock));
+ flock->l_type = fl->type;
+ flock->l_whence = SEEK_SET;
+ flock->l_start = fl->start;
+ if (fl->end == OFFSET_MAX)
+ flock->l_len = 0;
+ else
+ flock->l_len = fl->end - fl->start + 1;
+ flock->l_pid = fl->pid;
+}
+
+static void do_getlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;
+ struct fuse_file_info fi;
+ struct flock flock;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.lock_owner = arg->owner;
+
+ convert_fuse_file_lock(&arg->lk, &flock);
+ if (req->se->op.getlk)
+ req->se->op.getlk(req, nodeid, &fi, &flock);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_setlk_common(fuse_req_t req, fuse_ino_t nodeid,
+ const void *inarg, int sleep)
+{
+ struct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;
+ struct fuse_file_info fi;
+ struct flock flock;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.lock_owner = arg->owner;
+
+ if (arg->lk_flags & FUSE_LK_FLOCK) {
+ int op = 0;
+
+ switch (arg->lk.type) {
+ case F_RDLCK:
+ op = LOCK_SH;
+ break;
+ case F_WRLCK:
+ op = LOCK_EX;
+ break;
+ case F_UNLCK:
+ op = LOCK_UN;
+ break;
+ }
+ if (!sleep)
+ op |= LOCK_NB;
+
+ if (req->se->op.flock)
+ req->se->op.flock(req, nodeid, &fi, op);
+ else
+ fuse_reply_err(req, ENOSYS);
+ } else {
+ convert_fuse_file_lock(&arg->lk, &flock);
+ if (req->se->op.setlk)
+ req->se->op.setlk(req, nodeid, &fi, &flock, sleep);
+ else
+ fuse_reply_err(req, ENOSYS);
+ }
+}
+
+static void do_setlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ do_setlk_common(req, nodeid, inarg, 0);
+}
+
+static void do_setlkw(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ do_setlk_common(req, nodeid, inarg, 1);
+}
+
+static int find_interrupted(struct fuse_session *se, struct fuse_req *req)
+{
+ struct fuse_req *curr;
+
+ for (curr = se->list.next; curr != &se->list; curr = curr->next) {
+ if (curr->unique == req->u.i.unique) {
+ fuse_interrupt_func_t func;
+ void *data;
+
+ curr->ctr++;
+ pthread_mutex_unlock(&se->lock);
+
+ /* Ugh, ugly locking */
+ pthread_mutex_lock(&curr->lock);
+ pthread_mutex_lock(&se->lock);
+ curr->interrupted = 1;
+ func = curr->u.ni.func;
+ data = curr->u.ni.data;
+ pthread_mutex_unlock(&se->lock);
+ if (func)
+ func(curr, data);
+ pthread_mutex_unlock(&curr->lock);
+
+ pthread_mutex_lock(&se->lock);
+ curr->ctr--;
+ if (!curr->ctr)
+ destroy_req(curr);
+
+ return 1;
+ }
+ }
+ for (curr = se->interrupts.next; curr != &se->interrupts;
+ curr = curr->next) {
+ if (curr->u.i.unique == req->u.i.unique)
+ return 1;
+ }
+ return 0;
+}
+
+static void do_interrupt(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_interrupt_in *arg = (struct fuse_interrupt_in *) inarg;
+ struct fuse_session *se = req->se;
+
+ (void) nodeid;
+ if (se->debug)
+ fuse_log(FUSE_LOG_DEBUG, "INTERRUPT: %llu\n",
+ (unsigned long long) arg->unique);
+
+ req->u.i.unique = arg->unique;
+
+ pthread_mutex_lock(&se->lock);
+ if (find_interrupted(se, req))
+ destroy_req(req);
+ else
+ list_add_req(req, &se->interrupts);
+ pthread_mutex_unlock(&se->lock);
+}
+
+static struct fuse_req *check_interrupt(struct fuse_session *se,
+ struct fuse_req *req)
+{
+ struct fuse_req *curr;
+
+ for (curr = se->interrupts.next; curr != &se->interrupts;
+ curr = curr->next) {
+ if (curr->u.i.unique == req->unique) {
+ req->interrupted = 1;
+ list_del_req(curr);
+ free(curr);
+ return NULL;
+ }
+ }
+ curr = se->interrupts.next;
+ if (curr != &se->interrupts) {
+ list_del_req(curr);
+ list_init_req(curr);
+ return curr;
+ } else
+ return NULL;
+}
+
+static void do_bmap(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_bmap_in *arg = (struct fuse_bmap_in *) inarg;
+
+ if (req->se->op.bmap)
+ req->se->op.bmap(req, nodeid, arg->blocksize, arg->block);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_ioctl(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_ioctl_in *arg = (struct fuse_ioctl_in *) inarg;
+ unsigned int flags = arg->flags;
+ void *in_buf = arg->in_size ? PARAM(arg) : NULL;
+ struct fuse_file_info fi;
+
+ if (flags & FUSE_IOCTL_DIR &&
+ !(req->se->conn.want & FUSE_CAP_IOCTL_DIR)) {
+ fuse_reply_err(req, ENOTTY);
+ return;
+ }
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+
+ if (sizeof(void *) == 4 && req->se->conn.proto_minor >= 16 &&
+ !(flags & FUSE_IOCTL_32BIT)) {
+ req->ioctl_64bit = 1;
+ }
+
+ if (req->se->op.ioctl)
+ req->se->op.ioctl(req, nodeid, arg->cmd,
+ (void *)(uintptr_t)arg->arg, &fi, flags,
+ in_buf, arg->in_size, arg->out_size);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+void fuse_pollhandle_destroy(struct fuse_pollhandle *ph)
+{
+ free(ph);
+}
+
+static void do_poll(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_poll_in *arg = (struct fuse_poll_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.poll_events = arg->events;
+
+ if (req->se->op.poll) {
+ struct fuse_pollhandle *ph = NULL;
+
+ if (arg->flags & FUSE_POLL_SCHEDULE_NOTIFY) {
+ ph = malloc(sizeof(struct fuse_pollhandle));
+ if (ph == NULL) {
+ fuse_reply_err(req, ENOMEM);
+ return;
+ }
+ ph->kh = arg->kh;
+ ph->se = req->se;
+ }
+
+ req->se->op.poll(req, nodeid, &fi, ph);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
+}
+
+static void do_fallocate(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_fallocate_in *arg = (struct fuse_fallocate_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+
+ if (req->se->op.fallocate)
+ req->se->op.fallocate(req, nodeid, arg->mode, arg->offset, arg->length, &fi);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_copy_file_range(fuse_req_t req, fuse_ino_t nodeid_in, const void *inarg)
+{
+ struct fuse_copy_file_range_in *arg = (struct fuse_copy_file_range_in *) inarg;
+ struct fuse_file_info fi_in, fi_out;
+
+ memset(&fi_in, 0, sizeof(fi_in));
+ fi_in.fh = arg->fh_in;
+
+ memset(&fi_out, 0, sizeof(fi_out));
+ fi_out.fh = arg->fh_out;
+
+
+ if (req->se->op.copy_file_range)
+ req->se->op.copy_file_range(req, nodeid_in, arg->off_in,
+ &fi_in, arg->nodeid_out,
+ arg->off_out, &fi_out, arg->len,
+ arg->flags);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_lseek(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_lseek_in *arg = (struct fuse_lseek_in *) inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+
+ if (req->se->op.lseek)
+ req->se->op.lseek(req, nodeid, arg->offset, arg->whence, &fi);
+ else
+ fuse_reply_err(req, ENOSYS);
+}
+
+static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_init_in *arg = (struct fuse_init_in *) inarg;
+ struct fuse_init_out outarg;
+ struct fuse_session *se = req->se;
+ size_t bufsize = se->bufsize;
+ size_t outargsize = sizeof(outarg);
+
+ (void) nodeid;
+ if (se->debug) {
+ fuse_log(FUSE_LOG_DEBUG, "INIT: %u.%u\n", arg->major, arg->minor);
+ if (arg->major == 7 && arg->minor >= 6) {
+ fuse_log(FUSE_LOG_DEBUG, "flags=0x%08x\n", arg->flags);
+ fuse_log(FUSE_LOG_DEBUG, "max_readahead=0x%08x\n",
+ arg->max_readahead);
+ }
+ }
+ se->conn.proto_major = arg->major;
+ se->conn.proto_minor = arg->minor;
+ se->conn.capable = 0;
+ se->conn.want = 0;
+
+ memset(&outarg, 0, sizeof(outarg));
+ outarg.major = FUSE_KERNEL_VERSION;
+ outarg.minor = FUSE_KERNEL_MINOR_VERSION;
+
+ if (arg->major < 7) {
+ fuse_log(FUSE_LOG_ERR, "fuse: unsupported protocol version: %u.%u\n",
+ arg->major, arg->minor);
+ fuse_reply_err(req, EPROTO);
+ return;
+ }
+
+ if (arg->major > 7) {
+ /* Wait for a second INIT request with a 7.X version */
+ send_reply_ok(req, &outarg, sizeof(outarg));
+ return;
+ }
+
+ if (arg->minor >= 6) {
+ if (arg->max_readahead < se->conn.max_readahead)
+ se->conn.max_readahead = arg->max_readahead;
+ if (arg->flags & FUSE_ASYNC_READ)
+ se->conn.capable |= FUSE_CAP_ASYNC_READ;
+ if (arg->flags & FUSE_POSIX_LOCKS)
+ se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
+ if (arg->flags & FUSE_ATOMIC_O_TRUNC)
+ se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
+ if (arg->flags & FUSE_EXPORT_SUPPORT)
+ se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
+ if (arg->flags & FUSE_DONT_MASK)
+ se->conn.capable |= FUSE_CAP_DONT_MASK;
+ if (arg->flags & FUSE_FLOCK_LOCKS)
+ se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
+ if (arg->flags & FUSE_AUTO_INVAL_DATA)
+ se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
+ if (arg->flags & FUSE_DO_READDIRPLUS)
+ se->conn.capable |= FUSE_CAP_READDIRPLUS;
+ if (arg->flags & FUSE_READDIRPLUS_AUTO)
+ se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
+ if (arg->flags & FUSE_ASYNC_DIO)
+ se->conn.capable |= FUSE_CAP_ASYNC_DIO;
+ if (arg->flags & FUSE_WRITEBACK_CACHE)
+ se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
+ if (arg->flags & FUSE_NO_OPEN_SUPPORT)
+ se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
+ if (arg->flags & FUSE_PARALLEL_DIROPS)
+ se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
+ if (arg->flags & FUSE_POSIX_ACL)
+ se->conn.capable |= FUSE_CAP_POSIX_ACL;
+ if (arg->flags & FUSE_HANDLE_KILLPRIV)
+ se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
+ if (arg->flags & FUSE_NO_OPENDIR_SUPPORT)
+ se->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;
+ if (!(arg->flags & FUSE_MAX_PAGES)) {
+ size_t max_bufsize =
+ FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize()
+ + FUSE_BUFFER_HEADER_SIZE;
+ if (bufsize > max_bufsize) {
+ bufsize = max_bufsize;
+ }
+ }
+ } else {
+ se->conn.max_readahead = 0;
+ }
+
+ if (se->conn.proto_minor >= 14) {
+#ifdef HAVE_SPLICE
+#ifdef HAVE_VMSPLICE
+ se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
+#endif
+ se->conn.capable |= FUSE_CAP_SPLICE_READ;
+#endif
+ }
+ if (se->conn.proto_minor >= 18)
+ se->conn.capable |= FUSE_CAP_IOCTL_DIR;
+
+ /* Default settings for modern filesystems.
+ *
+ * Most of these capabilities were disabled by default in
+ * libfuse2 for backwards compatibility reasons. In libfuse3,
+ * we can finally enable them by default (as long as they're
+ * supported by the kernel).
+ */
+#define LL_SET_DEFAULT(cond, cap) \
+ if ((cond) && (se->conn.capable & (cap))) \
+ se->conn.want |= (cap)
+ LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_READ);
+ LL_SET_DEFAULT(1, FUSE_CAP_PARALLEL_DIROPS);
+ LL_SET_DEFAULT(1, FUSE_CAP_AUTO_INVAL_DATA);
+ LL_SET_DEFAULT(1, FUSE_CAP_HANDLE_KILLPRIV);
+ LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_DIO);
+ LL_SET_DEFAULT(1, FUSE_CAP_IOCTL_DIR);
+ LL_SET_DEFAULT(1, FUSE_CAP_ATOMIC_O_TRUNC);
+ LL_SET_DEFAULT(se->op.write_buf, FUSE_CAP_SPLICE_READ);
+ LL_SET_DEFAULT(se->op.getlk && se->op.setlk,
+ FUSE_CAP_POSIX_LOCKS);
+ LL_SET_DEFAULT(se->op.flock, FUSE_CAP_FLOCK_LOCKS);
+ LL_SET_DEFAULT(se->op.readdirplus, FUSE_CAP_READDIRPLUS);
+ LL_SET_DEFAULT(se->op.readdirplus && se->op.readdir,
+ FUSE_CAP_READDIRPLUS_AUTO);
+ se->conn.time_gran = 1;
+
+ if (bufsize < FUSE_MIN_READ_BUFFER) {
+ fuse_log(FUSE_LOG_ERR, "fuse: warning: buffer size too small: %zu\n",
+ bufsize);
+ bufsize = FUSE_MIN_READ_BUFFER;
+ }
+ se->bufsize = bufsize;
+
+ if (se->conn.max_write > bufsize - FUSE_BUFFER_HEADER_SIZE)
+ se->conn.max_write = bufsize - FUSE_BUFFER_HEADER_SIZE;
+
+ se->got_init = 1;
+ if (se->op.init)
+ se->op.init(se->userdata, &se->conn);
+
+ if (se->conn.want & (~se->conn.capable)) {
+ fuse_log(FUSE_LOG_ERR, "fuse: error: filesystem requested capabilities "
+ "0x%x that are not supported by kernel, aborting.\n",
+ se->conn.want & (~se->conn.capable));
+ fuse_reply_err(req, EPROTO);
+ se->error = -EPROTO;
+ fuse_session_exit(se);
+ return;
+ }
+
+ unsigned max_read_mo = get_max_read(se->mo);
+ if (se->conn.max_read != max_read_mo) {
+ fuse_log(FUSE_LOG_ERR, "fuse: error: init() and fuse_session_new() "
+ "requested different maximum read size (%u vs %u)\n",
+ se->conn.max_read, max_read_mo);
+ fuse_reply_err(req, EPROTO);
+ se->error = -EPROTO;
+ fuse_session_exit(se);
+ return;
+ }
+
+ if (se->conn.max_write < bufsize - FUSE_BUFFER_HEADER_SIZE) {
+ se->bufsize = se->conn.max_write + FUSE_BUFFER_HEADER_SIZE;
+ }
+ if (arg->flags & FUSE_MAX_PAGES) {
+ outarg.flags |= FUSE_MAX_PAGES;
+ outarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;
+ }
+
+ /* Always enable big writes, this is superseded
+ by the max_write option */
+ outarg.flags |= FUSE_BIG_WRITES;
+
+ if (se->conn.want & FUSE_CAP_ASYNC_READ)
+ outarg.flags |= FUSE_ASYNC_READ;
+ if (se->conn.want & FUSE_CAP_POSIX_LOCKS)
+ outarg.flags |= FUSE_POSIX_LOCKS;
+ if (se->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)
+ outarg.flags |= FUSE_ATOMIC_O_TRUNC;
+ if (se->conn.want & FUSE_CAP_EXPORT_SUPPORT)
+ outarg.flags |= FUSE_EXPORT_SUPPORT;
+ if (se->conn.want & FUSE_CAP_DONT_MASK)
+ outarg.flags |= FUSE_DONT_MASK;
+ if (se->conn.want & FUSE_CAP_FLOCK_LOCKS)
+ outarg.flags |= FUSE_FLOCK_LOCKS;
+ if (se->conn.want & FUSE_CAP_AUTO_INVAL_DATA)
+ outarg.flags |= FUSE_AUTO_INVAL_DATA;
+ if (se->conn.want & FUSE_CAP_READDIRPLUS)
+ outarg.flags |= FUSE_DO_READDIRPLUS;
+ if (se->conn.want & FUSE_CAP_READDIRPLUS_AUTO)
+ outarg.flags |= FUSE_READDIRPLUS_AUTO;
+ if (se->conn.want & FUSE_CAP_ASYNC_DIO)
+ outarg.flags |= FUSE_ASYNC_DIO;
+ if (se->conn.want & FUSE_CAP_WRITEBACK_CACHE)
+ outarg.flags |= FUSE_WRITEBACK_CACHE;
+ if (se->conn.want & FUSE_CAP_POSIX_ACL)
+ outarg.flags |= FUSE_POSIX_ACL;
+ outarg.max_readahead = se->conn.max_readahead;
+ outarg.max_write = se->conn.max_write;
+ if (se->conn.proto_minor >= 13) {
+ if (se->conn.max_background >= (1 << 16))
+ se->conn.max_background = (1 << 16) - 1;
+ if (se->conn.congestion_threshold > se->conn.max_background)
+ se->conn.congestion_threshold = se->conn.max_background;
+ if (!se->conn.congestion_threshold) {
+ se->conn.congestion_threshold =
+ se->conn.max_background * 3 / 4;
+ }
+
+ outarg.max_background = se->conn.max_background;
+ outarg.congestion_threshold = se->conn.congestion_threshold;
+ }
+ if (se->conn.proto_minor >= 23)
+ outarg.time_gran = se->conn.time_gran;
+
+ if (se->debug) {
+ fuse_log(FUSE_LOG_DEBUG, " INIT: %u.%u\n", outarg.major, outarg.minor);
+ fuse_log(FUSE_LOG_DEBUG, " flags=0x%08x\n", outarg.flags);
+ fuse_log(FUSE_LOG_DEBUG, " max_readahead=0x%08x\n",
+ outarg.max_readahead);
+ fuse_log(FUSE_LOG_DEBUG, " max_write=0x%08x\n", outarg.max_write);
+ fuse_log(FUSE_LOG_DEBUG, " max_background=%i\n",
+ outarg.max_background);
+ fuse_log(FUSE_LOG_DEBUG, " congestion_threshold=%i\n",
+ outarg.congestion_threshold);
+ fuse_log(FUSE_LOG_DEBUG, " time_gran=%u\n",
+ outarg.time_gran);
+ }
+ if (arg->minor < 5)
+ outargsize = FUSE_COMPAT_INIT_OUT_SIZE;
+ else if (arg->minor < 23)
+ outargsize = FUSE_COMPAT_22_INIT_OUT_SIZE;
+
+ send_reply_ok(req, &outarg, outargsize);
+}
+
+static void do_destroy(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+{
+ struct fuse_session *se = req->se;
+
+ (void) nodeid;
+ (void) inarg;
+
+ se->got_destroy = 1;
+ if (se->op.destroy)
+ se->op.destroy(se->userdata);
+
+ send_reply_ok(req, NULL, 0);
+}
+
+static void list_del_nreq(struct fuse_notify_req *nreq)
+{
+ struct fuse_notify_req *prev = nreq->prev;
+ struct fuse_notify_req *next = nreq->next;
+ prev->next = next;
+ next->prev = prev;
+}
+
+static void list_add_nreq(struct fuse_notify_req *nreq,
+ struct fuse_notify_req *next)
+{
+ struct fuse_notify_req *prev = next->prev;
+ nreq->next = next;
+ nreq->prev = prev;
+ prev->next = nreq;
+ next->prev = nreq;
+}
+
+static void list_init_nreq(struct fuse_notify_req *nreq)
+{
+ nreq->next = nreq;
+ nreq->prev = nreq;
+}
+
+static void do_notify_reply(fuse_req_t req, fuse_ino_t nodeid,
+ const void *inarg, const struct fuse_buf *buf)
+{
+ struct fuse_session *se = req->se;
+ struct fuse_notify_req *nreq;
+ struct fuse_notify_req *head;
+
+ pthread_mutex_lock(&se->lock);
+ head = &se->notify_list;
+ for (nreq = head->next; nreq != head; nreq = nreq->next) {
+ if (nreq->unique == req->unique) {
+ list_del_nreq(nreq);
+ break;
+ }
+ }
+ pthread_mutex_unlock(&se->lock);
+
+ if (nreq != head)
+ nreq->reply(nreq, req, nodeid, inarg, buf);
+}
+
+static int send_notify_iov(struct fuse_session *se, int notify_code,
+ struct iovec *iov, int count)
+{
+ struct fuse_out_header out;
+
+ if (!se->got_init)
+ return -ENOTCONN;
+
+ out.unique = 0;
+ out.error = notify_code;
+ iov[0].iov_base = &out;
+ iov[0].iov_len = sizeof(struct fuse_out_header);
+
+ return fuse_send_msg(se, NULL, iov, count);
+}
+
+int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph)
+{
+ if (ph != NULL) {
+ struct fuse_notify_poll_wakeup_out outarg;
+ struct iovec iov[2];
+
+ outarg.kh = ph->kh;
+
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
+
+ return send_notify_iov(ph->se, FUSE_NOTIFY_POLL, iov, 2);
+ } else {
+ return 0;
+ }
+}
+
+int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
+ off_t off, off_t len)
+{
+ struct fuse_notify_inval_inode_out outarg;
+ struct iovec iov[2];
+
+ if (!se)
+ return -EINVAL;
+
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
+ return -ENOSYS;
+
+ outarg.ino = ino;
+ outarg.off = off;
+ outarg.len = len;
+
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
+
+ return send_notify_iov(se, FUSE_NOTIFY_INVAL_INODE, iov, 2);
+}
+
+int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
+ const char *name, size_t namelen)
+{
+ struct fuse_notify_inval_entry_out outarg;
+ struct iovec iov[3];
+
+ if (!se)
+ return -EINVAL;
+
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
+ return -ENOSYS;
+
+ outarg.parent = parent;
+ outarg.namelen = namelen;
+ outarg.padding = 0;
+
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
+ iov[2].iov_base = (void *)name;
+ iov[2].iov_len = namelen + 1;
+
+ return send_notify_iov(se, FUSE_NOTIFY_INVAL_ENTRY, iov, 3);
+}
+
+int fuse_lowlevel_notify_delete(struct fuse_session *se,
+ fuse_ino_t parent, fuse_ino_t child,
+ const char *name, size_t namelen)
+{
+ struct fuse_notify_delete_out outarg;
+ struct iovec iov[3];
+
+ if (!se)
+ return -EINVAL;
+
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 18)
+ return -ENOSYS;
+
+ outarg.parent = parent;
+ outarg.child = child;
+ outarg.namelen = namelen;
+ outarg.padding = 0;
+
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
+ iov[2].iov_base = (void *)name;
+ iov[2].iov_len = namelen + 1;
+
+ return send_notify_iov(se, FUSE_NOTIFY_DELETE, iov, 3);
+}
+
+int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
+ off_t offset, struct fuse_bufvec *bufv,
+ enum fuse_buf_copy_flags flags)
+{
+ struct fuse_out_header out;
+ struct fuse_notify_store_out outarg;
+ struct iovec iov[3];
+ size_t size = fuse_buf_size(bufv);
+ int res;
+
+ if (!se)
+ return -EINVAL;
+
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 15)
+ return -ENOSYS;
+
+ out.unique = 0;
+ out.error = FUSE_NOTIFY_STORE;
+
+ outarg.nodeid = ino;
+ outarg.offset = offset;
+ outarg.size = size;
+ outarg.padding = 0;
+
+ iov[0].iov_base = &out;
+ iov[0].iov_len = sizeof(out);
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
+
+ res = fuse_send_data_iov(se, NULL, iov, 2, bufv, flags);
+ if (res > 0)
+ res = -res;
+
+ return res;
+}
+
+struct fuse_retrieve_req {
+ struct fuse_notify_req nreq;
+ void *cookie;
+};
+
+static void fuse_ll_retrieve_reply(struct fuse_notify_req *nreq,
+ fuse_req_t req, fuse_ino_t ino,
+ const void *inarg,
+ const struct fuse_buf *ibuf)
+{
+ struct fuse_session *se = req->se;
+ struct fuse_retrieve_req *rreq =
+ container_of(nreq, struct fuse_retrieve_req, nreq);
+ const struct fuse_notify_retrieve_in *arg = inarg;
+ struct fuse_bufvec bufv = {
+ .buf[0] = *ibuf,
+ .count = 1,
+ };
+
+ if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
+ bufv.buf[0].mem = PARAM(arg);
+
+ bufv.buf[0].size -= sizeof(struct fuse_in_header) +
+ sizeof(struct fuse_notify_retrieve_in);
+
+ if (bufv.buf[0].size < arg->size) {
+ fuse_log(FUSE_LOG_ERR, "fuse: retrieve reply: buffer size too small\n");
+ fuse_reply_none(req);
+ goto out;
+ }
+ bufv.buf[0].size = arg->size;
+
+ if (se->op.retrieve_reply) {
+ se->op.retrieve_reply(req, rreq->cookie, ino,
+ arg->offset, &bufv);
+ } else {
+ fuse_reply_none(req);
+ }
+out:
+ free(rreq);
+ if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
+ fuse_ll_clear_pipe(se);
+}
+
+int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
+ size_t size, off_t offset, void *cookie)
+{
+ struct fuse_notify_retrieve_out outarg;
+ struct iovec iov[2];
+ struct fuse_retrieve_req *rreq;
+ int err;
+
+ if (!se)
+ return -EINVAL;
+
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 15)
+ return -ENOSYS;
+
+ rreq = malloc(sizeof(*rreq));
+ if (rreq == NULL)
+ return -ENOMEM;
+
+ pthread_mutex_lock(&se->lock);
+ rreq->cookie = cookie;
+ rreq->nreq.unique = se->notify_ctr++;
+ rreq->nreq.reply = fuse_ll_retrieve_reply;
+ list_add_nreq(&rreq->nreq, &se->notify_list);
+ pthread_mutex_unlock(&se->lock);
+
+ outarg.notify_unique = rreq->nreq.unique;
+ outarg.nodeid = ino;
+ outarg.offset = offset;
+ outarg.size = size;
+ outarg.padding = 0;
+
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
+
+ err = send_notify_iov(se, FUSE_NOTIFY_RETRIEVE, iov, 2);
+ if (err) {
+ pthread_mutex_lock(&se->lock);
+ list_del_nreq(&rreq->nreq);
+ pthread_mutex_unlock(&se->lock);
+ free(rreq);
+ }
+
+ return err;
+}
+
+void *fuse_req_userdata(fuse_req_t req)
+{
+ return req->se->userdata;
+}
+
+const struct fuse_ctx *fuse_req_ctx(fuse_req_t req)
+{
+ return &req->ctx;
+}
+
+void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
+ void *data)
+{
+ pthread_mutex_lock(&req->lock);
+ pthread_mutex_lock(&req->se->lock);
+ req->u.ni.func = func;
+ req->u.ni.data = data;
+ pthread_mutex_unlock(&req->se->lock);
+ if (req->interrupted && func)
+ func(req, data);
+ pthread_mutex_unlock(&req->lock);
+}
+
+int fuse_req_interrupted(fuse_req_t req)
+{
+ int interrupted;
+
+ pthread_mutex_lock(&req->se->lock);
+ interrupted = req->interrupted;
+ pthread_mutex_unlock(&req->se->lock);
+
+ return interrupted;
+}
+
+static struct {
+ void (*func)(fuse_req_t, fuse_ino_t, const void *);
+ const char *name;
+} fuse_ll_ops[] = {
+ [FUSE_LOOKUP] = { do_lookup, "LOOKUP" },
+ [FUSE_FORGET] = { do_forget, "FORGET" },
+ [FUSE_GETATTR] = { do_getattr, "GETATTR" },
+ [FUSE_SETATTR] = { do_setattr, "SETATTR" },
+ [FUSE_READLINK] = { do_readlink, "READLINK" },
+ [FUSE_SYMLINK] = { do_symlink, "SYMLINK" },
+ [FUSE_MKNOD] = { do_mknod, "MKNOD" },
+ [FUSE_MKDIR] = { do_mkdir, "MKDIR" },
+ [FUSE_UNLINK] = { do_unlink, "UNLINK" },
+ [FUSE_RMDIR] = { do_rmdir, "RMDIR" },
+ [FUSE_RENAME] = { do_rename, "RENAME" },
+ [FUSE_LINK] = { do_link, "LINK" },
+ [FUSE_OPEN] = { do_open, "OPEN" },
+ [FUSE_READ] = { do_read, "READ" },
+ [FUSE_WRITE] = { do_write, "WRITE" },
+ [FUSE_STATFS] = { do_statfs, "STATFS" },
+ [FUSE_RELEASE] = { do_release, "RELEASE" },
+ [FUSE_FSYNC] = { do_fsync, "FSYNC" },
+ [FUSE_SETXATTR] = { do_setxattr, "SETXATTR" },
+ [FUSE_GETXATTR] = { do_getxattr, "GETXATTR" },
+ [FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" },
+ [FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" },
+ [FUSE_FLUSH] = { do_flush, "FLUSH" },
+ [FUSE_INIT] = { do_init, "INIT" },
+ [FUSE_OPENDIR] = { do_opendir, "OPENDIR" },
+ [FUSE_READDIR] = { do_readdir, "READDIR" },
+ [FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" },
+ [FUSE_FSYNCDIR] = { do_fsyncdir, "FSYNCDIR" },
+ [FUSE_GETLK] = { do_getlk, "GETLK" },
+ [FUSE_SETLK] = { do_setlk, "SETLK" },
+ [FUSE_SETLKW] = { do_setlkw, "SETLKW" },
+ [FUSE_ACCESS] = { do_access, "ACCESS" },
+ [FUSE_CREATE] = { do_create, "CREATE" },
+ [FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" },
+ [FUSE_BMAP] = { do_bmap, "BMAP" },
+ [FUSE_IOCTL] = { do_ioctl, "IOCTL" },
+ [FUSE_POLL] = { do_poll, "POLL" },
+ [FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" },
+ [FUSE_DESTROY] = { do_destroy, "DESTROY" },
+ [FUSE_NOTIFY_REPLY] = { (void *) 1, "NOTIFY_REPLY" },
+ [FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" },
+ [FUSE_READDIRPLUS] = { do_readdirplus, "READDIRPLUS"},
+ [FUSE_RENAME2] = { do_rename2, "RENAME2" },
+ [FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" },
+ [FUSE_LSEEK] = { do_lseek, "LSEEK" },
+ [CUSE_INIT] = { cuse_lowlevel_init, "CUSE_INIT" },
+};
+
+#define FUSE_MAXOP (sizeof(fuse_ll_ops) / sizeof(fuse_ll_ops[0]))
+
+static const char *opname(enum fuse_opcode opcode)
+{
+ if (opcode >= FUSE_MAXOP || !fuse_ll_ops[opcode].name)
+ return "???";
+ else
+ return fuse_ll_ops[opcode].name;
+}
+
+static int fuse_ll_copy_from_pipe(struct fuse_bufvec *dst,
+ struct fuse_bufvec *src)
+{
+ ssize_t res = fuse_buf_copy(dst, src, 0);
+ if (res < 0) {
+ fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: %s\n", strerror(-res));
+ return res;
+ }
+ if ((size_t)res < fuse_buf_size(dst)) {
+ fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: short read\n");
+ return -1;
+ }
+ return 0;
+}
+
+void fuse_session_process_buf(struct fuse_session *se,
+ const struct fuse_buf *buf)
+{
+ fuse_session_process_buf_int(se, buf, NULL);
+}
+
+void fuse_session_process_buf_int(struct fuse_session *se,
+ const struct fuse_buf *buf, struct fuse_chan *ch)
+{
+ const size_t write_header_size = sizeof(struct fuse_in_header) +
+ sizeof(struct fuse_write_in);
+ struct fuse_bufvec bufv = { .buf[0] = *buf, .count = 1 };
+ struct fuse_bufvec tmpbuf = FUSE_BUFVEC_INIT(write_header_size);
+ struct fuse_in_header *in;
+ const void *inarg;
+ struct fuse_req *req;
+ void *mbuf = NULL;
+ int err;
+ int res;
+
+ if (buf->flags & FUSE_BUF_IS_FD) {
+ if (buf->size < tmpbuf.buf[0].size)
+ tmpbuf.buf[0].size = buf->size;
+
+ mbuf = malloc(tmpbuf.buf[0].size);
+ if (mbuf == NULL) {
+ fuse_log(FUSE_LOG_ERR, "fuse: failed to allocate header\n");
+ goto clear_pipe;
+ }
+ tmpbuf.buf[0].mem = mbuf;
+
+ res = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);
+ if (res < 0)
+ goto clear_pipe;
+
+ in = mbuf;
+ } else {
+ in = buf->mem;
+ }
+
+ if (se->debug) {
+ fuse_log(FUSE_LOG_DEBUG,
+ "unique: %llu, opcode: %s (%i), nodeid: %llu, insize: %zu, pid: %u\n",
+ (unsigned long long) in->unique,
+ opname((enum fuse_opcode) in->opcode), in->opcode,
+ (unsigned long long) in->nodeid, buf->size, in->pid);
+ }
+
+ req = fuse_ll_alloc_req(se);
+ if (req == NULL) {
+ struct fuse_out_header out = {
+ .unique = in->unique,
+ .error = -ENOMEM,
+ };
+ struct iovec iov = {
+ .iov_base = &out,
+ .iov_len = sizeof(struct fuse_out_header),
+ };
+
+ fuse_send_msg(se, ch, &iov, 1);
+ goto clear_pipe;
+ }
+
+ req->unique = in->unique;
+ req->ctx.uid = in->uid;
+ req->ctx.gid = in->gid;
+ req->ctx.pid = in->pid;
+ req->ch = ch ? fuse_chan_get(ch) : NULL;
+
+ err = EIO;
+ if (!se->got_init) {
+ enum fuse_opcode expected;
+
+ expected = se->cuse_data ? CUSE_INIT : FUSE_INIT;
+ if (in->opcode != expected)
+ goto reply_err;
+ } else if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT)
+ goto reply_err;
+
+ err = EACCES;
+ /* Implement -o allow_root */
+ if (se->deny_others && in->uid != se->owner && in->uid != 0 &&
+ in->opcode != FUSE_INIT && in->opcode != FUSE_READ &&
+ in->opcode != FUSE_WRITE && in->opcode != FUSE_FSYNC &&
+ in->opcode != FUSE_RELEASE && in->opcode != FUSE_READDIR &&
+ in->opcode != FUSE_FSYNCDIR && in->opcode != FUSE_RELEASEDIR &&
+ in->opcode != FUSE_NOTIFY_REPLY &&
+ in->opcode != FUSE_READDIRPLUS)
+ goto reply_err;
+
+ err = ENOSYS;
+ if (in->opcode >= FUSE_MAXOP || !fuse_ll_ops[in->opcode].func)
+ goto reply_err;
+ if (in->opcode != FUSE_INTERRUPT) {
+ struct fuse_req *intr;
+ pthread_mutex_lock(&se->lock);
+ intr = check_interrupt(se, req);
+ list_add_req(req, &se->list);
+ pthread_mutex_unlock(&se->lock);
+ if (intr)
+ fuse_reply_err(intr, EAGAIN);
+ }
+
+ if ((buf->flags & FUSE_BUF_IS_FD) && write_header_size < buf->size &&
+ (in->opcode != FUSE_WRITE || !se->op.write_buf) &&
+ in->opcode != FUSE_NOTIFY_REPLY) {
+ void *newmbuf;
+
+ err = ENOMEM;
+ newmbuf = realloc(mbuf, buf->size);
+ if (newmbuf == NULL)
+ goto reply_err;
+ mbuf = newmbuf;
+
+ tmpbuf = FUSE_BUFVEC_INIT(buf->size - write_header_size);
+ tmpbuf.buf[0].mem = (char *)mbuf + write_header_size;
+
+ res = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);
+ err = -res;
+ if (res < 0)
+ goto reply_err;
+
+ in = mbuf;
+ }
+
+ inarg = (void *) &in[1];
+ if (in->opcode == FUSE_WRITE && se->op.write_buf)
+ do_write_buf(req, in->nodeid, inarg, buf);
+ else if (in->opcode == FUSE_NOTIFY_REPLY)
+ do_notify_reply(req, in->nodeid, inarg, buf);
+ else
+ fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
+
+out_free:
+ free(mbuf);
+ return;
+
+reply_err:
+ fuse_reply_err(req, err);
+clear_pipe:
+ if (buf->flags & FUSE_BUF_IS_FD)
+ fuse_ll_clear_pipe(se);
+ goto out_free;
+}
+
+#define LL_OPTION(n,o,v) \
+ { n, offsetof(struct fuse_session, o), v }
+
+static const struct fuse_opt fuse_ll_opts[] = {
+ LL_OPTION("debug", debug, 1),
+ LL_OPTION("-d", debug, 1),
+ LL_OPTION("--debug", debug, 1),
+ LL_OPTION("allow_root", deny_others, 1),
+ FUSE_OPT_END
+};
+
+void fuse_lowlevel_version(void)
+{
+ printf("using FUSE kernel interface version %i.%i\n",
+ FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
+ fuse_mount_version();
+}
+
+void fuse_lowlevel_help(void)
+{
+ /* These are not all options, but the ones that are
+ potentially of interest to an end-user */
+ printf(
+" -o allow_other allow access by all users\n"
+" -o allow_root allow access by root\n"
+" -o auto_unmount auto unmount on process termination\n");
+}
+
+void fuse_session_destroy(struct fuse_session *se)
+{
+ struct fuse_ll_pipe *llp;
+
+ if (se->got_init && !se->got_destroy) {
+ if (se->op.destroy)
+ se->op.destroy(se->userdata);
+ }
+ llp = pthread_getspecific(se->pipe_key);
+ if (llp != NULL)
+ fuse_ll_pipe_free(llp);
+ pthread_key_delete(se->pipe_key);
+ pthread_mutex_destroy(&se->lock);
+ free(se->cuse_data);
+ if (se->fd != -1)
+ close(se->fd);
+ destroy_mount_opts(se->mo);
+ free(se);
+}
+
+
+static void fuse_ll_pipe_destructor(void *data)
+{
+ struct fuse_ll_pipe *llp = data;
+ fuse_ll_pipe_free(llp);
+}
+
+int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf)
+{
+ return fuse_session_receive_buf_int(se, buf, NULL);
+}
+
+int fuse_session_receive_buf_int(struct fuse_session *se, struct fuse_buf *buf,
+ struct fuse_chan *ch)
+{
+ int err;
+ ssize_t res;
+#ifdef HAVE_SPLICE
+ size_t bufsize = se->bufsize;
+ struct fuse_ll_pipe *llp;
+ struct fuse_buf tmpbuf;
+
+ if (se->conn.proto_minor < 14 || !(se->conn.want & FUSE_CAP_SPLICE_READ))
+ goto fallback;
+
+ llp = fuse_ll_get_pipe(se);
+ if (llp == NULL)
+ goto fallback;
+
+ if (llp->size < bufsize) {
+ if (llp->can_grow) {
+ res = fcntl(llp->pipe[0], F_SETPIPE_SZ, bufsize);
+ if (res == -1) {
+ llp->can_grow = 0;
+ res = grow_pipe_to_max(llp->pipe[0]);
+ if (res > 0)
+ llp->size = res;
+ goto fallback;
+ }
+ llp->size = res;
+ }
+ if (llp->size < bufsize)
+ goto fallback;
+ }
+
+ res = splice(ch ? ch->fd : se->fd,
+ NULL, llp->pipe[1], NULL, bufsize, 0);
+ err = errno;
+
+ if (fuse_session_exited(se))
+ return 0;
+
+ if (res == -1) {
+ if (err == ENODEV) {
+ /* Filesystem was unmounted, or connection was aborted
+ via /sys/fs/fuse/connections */
+ fuse_session_exit(se);
+ return 0;
+ }
+ if (err != EINTR && err != EAGAIN)
+ perror("fuse: splice from device");
+ return -err;
+ }
+
+ if (res < sizeof(struct fuse_in_header)) {
+ fuse_log(FUSE_LOG_ERR, "short splice from fuse device\n");
+ return -EIO;
+ }
+
+ tmpbuf = (struct fuse_buf) {
+ .size = res,
+ .flags = FUSE_BUF_IS_FD,
+ .fd = llp->pipe[0],
+ };
+
+ /*
+ * Don't bother with zero copy for small requests.
+ * fuse_loop_mt() needs to check for FORGET so this more than
+ * just an optimization.
+ */
+ if (res < sizeof(struct fuse_in_header) +
+ sizeof(struct fuse_write_in) + pagesize) {
+ struct fuse_bufvec src = { .buf[0] = tmpbuf, .count = 1 };
+ struct fuse_bufvec dst = { .count = 1 };
+
+ if (!buf->mem) {
+ buf->mem = malloc(se->bufsize);
+ if (!buf->mem) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: failed to allocate read buffer\n");
+ return -ENOMEM;
+ }
+ }
+ buf->size = se->bufsize;
+ buf->flags = 0;
+ dst.buf[0] = *buf;
+
+ res = fuse_buf_copy(&dst, &src, 0);
+ if (res < 0) {
+ fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: %s\n",
+ strerror(-res));
+ fuse_ll_clear_pipe(se);
+ return res;
+ }
+ if (res < tmpbuf.size) {
+ fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: short read\n");
+ fuse_ll_clear_pipe(se);
+ return -EIO;
+ }
+ assert(res == tmpbuf.size);
+
+ } else {
+ /* Don't overwrite buf->mem, as that would cause a leak */
+ buf->fd = tmpbuf.fd;
+ buf->flags = tmpbuf.flags;
+ }
+ buf->size = tmpbuf.size;
+
+ return res;
+
+fallback:
+#endif
+ if (!buf->mem) {
+ buf->mem = malloc(se->bufsize);
+ if (!buf->mem) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: failed to allocate read buffer\n");
+ return -ENOMEM;
+ }
+ }
+
+restart:
+ res = read(ch ? ch->fd : se->fd, buf->mem, se->bufsize);
+ err = errno;
+
+ if (fuse_session_exited(se))
+ return 0;
+ if (res == -1) {
+ /* ENOENT means the operation was interrupted, it's safe
+ to restart */
+ if (err == ENOENT)
+ goto restart;
+
+ if (err == ENODEV) {
+ /* Filesystem was unmounted, or connection was aborted
+ via /sys/fs/fuse/connections */
+ fuse_session_exit(se);
+ return 0;
+ }
+ /* Errors occurring during normal operation: EINTR (read
+ interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem
+ umounted) */
+ if (err != EINTR && err != EAGAIN)
+ perror("fuse: reading device");
+ return -err;
+ }
+ if ((size_t) res < sizeof(struct fuse_in_header)) {
+ fuse_log(FUSE_LOG_ERR, "short read on fuse device\n");
+ return -EIO;
+ }
+
+ buf->size = res;
+
+ return res;
+}
+
+struct fuse_session *fuse_session_new(struct fuse_args *args,
+ const struct fuse_lowlevel_ops *op,
+ size_t op_size, void *userdata)
+{
+ int err;
+ struct fuse_session *se;
+ struct mount_opts *mo;
+
+ if (sizeof(struct fuse_lowlevel_ops) < op_size) {
+ fuse_log(FUSE_LOG_ERR, "fuse: warning: library too old, some operations may not work\n");
+ op_size = sizeof(struct fuse_lowlevel_ops);
+ }
+
+ if (args->argc == 0) {
+ fuse_log(FUSE_LOG_ERR, "fuse: empty argv passed to fuse_session_new().\n");
+ return NULL;
+ }
+
+ se = (struct fuse_session *) calloc(1, sizeof(struct fuse_session));
+ if (se == NULL) {
+ fuse_log(FUSE_LOG_ERR, "fuse: failed to allocate fuse object\n");
+ goto out1;
+ }
+ se->fd = -1;
+ se->conn.max_write = UINT_MAX;
+ se->conn.max_readahead = UINT_MAX;
+
+ /* Parse options */
+ if(fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1)
+ goto out2;
+ if(se->deny_others) {
+ /* Allowing access only by root is done by instructing
+ * kernel to allow access by everyone, and then restricting
+ * access to root and mountpoint owner in libfuse.
+ */
+ // We may be adding the option a second time, but
+ // that doesn't hurt.
+ if(fuse_opt_add_arg(args, "-oallow_other") == -1)
+ goto out2;
+ }
+ mo = parse_mount_opts(args);
+ if (mo == NULL)
+ goto out3;
+
+ if(args->argc == 1 &&
+ args->argv[0][0] == '-') {
+ fuse_log(FUSE_LOG_ERR, "fuse: warning: argv[0] looks like an option, but "
+ "will be ignored\n");
+ } else if (args->argc != 1) {
+ int i;
+ fuse_log(FUSE_LOG_ERR, "fuse: unknown option(s): `");
+ for(i = 1; i < args->argc-1; i++)
+ fuse_log(FUSE_LOG_ERR, "%s ", args->argv[i]);
+ fuse_log(FUSE_LOG_ERR, "%s'\n", args->argv[i]);
+ goto out4;
+ }
+
+ if (se->debug)
+ fuse_log(FUSE_LOG_DEBUG, "FUSE library version: %s\n", PACKAGE_VERSION);
+
+ se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() +
+ FUSE_BUFFER_HEADER_SIZE;
+
+ list_init_req(&se->list);
+ list_init_req(&se->interrupts);
+ list_init_nreq(&se->notify_list);
+ se->notify_ctr = 1;
+ fuse_mutex_init(&se->lock);
+
+ err = pthread_key_create(&se->pipe_key, fuse_ll_pipe_destructor);
+ if (err) {
+ fuse_log(FUSE_LOG_ERR, "fuse: failed to create thread specific key: %s\n",
+ strerror(err));
+ goto out5;
+ }
+
+ memcpy(&se->op, op, op_size);
+ se->owner = getuid();
+ se->userdata = userdata;
+
+ se->mo = mo;
+ return se;
+
+out5:
+ pthread_mutex_destroy(&se->lock);
+out4:
+ fuse_opt_free_args(args);
+out3:
+ free(mo);
+out2:
+ free(se);
+out1:
+ return NULL;
+}
+
+int fuse_session_mount(struct fuse_session *se, const char *mountpoint)
+{
+ int fd;
+
+ /*
+ * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
+ * would ensue.
+ */
+ do {
+ fd = open("/dev/null", O_RDWR);
+ if (fd > 2)
+ close(fd);
+ } while (fd >= 0 && fd <= 2);
+
+ /*
+ * To allow FUSE daemons to run without privileges, the caller may open
+ * /dev/fuse before launching the file system and pass on the file
+ * descriptor by specifying /dev/fd/N as the mount point. Note that the
+ * parent process takes care of performing the mount in this case.
+ */
+ fd = fuse_mnt_parse_fuse_fd(mountpoint);
+ if (fd != -1) {
+ if (fcntl(fd, F_GETFD) == -1) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: Invalid file descriptor /dev/fd/%u\n",
+ fd);
+ return -1;
+ }
+ se->fd = fd;
+ return 0;
+ }
+
+ /* Open channel */
+ fd = fuse_kern_mount(mountpoint, se->mo);
+ if (fd == -1)
+ return -1;
+ se->fd = fd;
+
+ /* Save mountpoint */
+ se->mountpoint = strdup(mountpoint);
+ if (se->mountpoint == NULL)
+ goto error_out;
+
+ return 0;
+
+error_out:
+ fuse_kern_unmount(mountpoint, fd);
+ return -1;
+}
+
+int fuse_session_fd(struct fuse_session *se)
+{
+ return se->fd;
+}
+
+void fuse_session_unmount(struct fuse_session *se)
+{
+ if (se->mountpoint != NULL) {
+ fuse_kern_unmount(se->mountpoint, se->fd);
+ free(se->mountpoint);
+ se->mountpoint = NULL;
+ }
+}
+
+#ifdef linux
+int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
+{
+ char *buf;
+ size_t bufsize = 1024;
+ char path[128];
+ int ret;
+ int fd;
+ unsigned long pid = req->ctx.pid;
+ char *s;
+
+ sprintf(path, "/proc/%lu/task/%lu/status", pid, pid);
+
+retry:
+ buf = malloc(bufsize);
+ if (buf == NULL)
+ return -ENOMEM;
+
+ ret = -EIO;
+ fd = open(path, O_RDONLY);
+ if (fd == -1)
+ goto out_free;
+
+ ret = read(fd, buf, bufsize);
+ close(fd);
+ if (ret < 0) {
+ ret = -EIO;
+ goto out_free;
+ }
+
+ if ((size_t)ret == bufsize) {
+ free(buf);
+ bufsize *= 4;
+ goto retry;
+ }
+
+ ret = -EIO;
+ s = strstr(buf, "\nGroups:");
+ if (s == NULL)
+ goto out_free;
+
+ s += 8;
+ ret = 0;
+ while (1) {
+ char *end;
+ unsigned long val = strtoul(s, &end, 0);
+ if (end == s)
+ break;
+
+ s = end;
+ if (ret < size)
+ list[ret] = val;
+ ret++;
+ }
+
+out_free:
+ free(buf);
+ return ret;
+}
+#else /* linux */
+/*
+ * This is currently not implemented on other than Linux...
+ */
+int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
+{
+ (void) req; (void) size; (void) list;
+ return -ENOSYS;
+}
+#endif
+
+void fuse_session_exit(struct fuse_session *se)
+{
+ se->exited = 1;
+}
+
+void fuse_session_reset(struct fuse_session *se)
+{
+ se->exited = 0;
+ se->error = 0;
+}
+
+int fuse_session_exited(struct fuse_session *se)
+{
+ return se->exited;
+}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 005/108] virtiofsd: Add passthrough_ll
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (3 preceding siblings ...)
2020-01-23 16:44 ` [PULL 004/108] virtiofsd: Add fuse_lowlevel.c Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 006/108] virtiofsd: Trim down imported files Dr. David Alan Gilbert (git)
` (104 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
passthrough_ll is one of the examples in the upstream fuse project
and is the main part of our daemon here. It passes through requests
from fuse to the underlying filesystem, using syscalls as directly
as possible.
From libfuse fuse-3.8.0
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Fixed up 'GPL' to 'GPLv2' as per Dan's comments and consistent
with the 'LICENSE' file in libfuse; patch sent to libfuse to fix
it upstream.
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 1338 ++++++++++++++++++++++++++++++
1 file changed, 1338 insertions(+)
create mode 100644 tools/virtiofsd/passthrough_ll.c
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
new file mode 100644
index 0000000000..e1a605691a
--- /dev/null
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -0,0 +1,1338 @@
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU GPLv2.
+ See the file COPYING.
+*/
+
+/** @file
+ *
+ * This file system mirrors the existing file system hierarchy of the
+ * system, starting at the root file system. This is implemented by
+ * just "passing through" all requests to the corresponding user-space
+ * libc functions. In contrast to passthrough.c and passthrough_fh.c,
+ * this implementation uses the low-level API. Its performance should
+ * be the least bad among the three, but many operations are not
+ * implemented. In particular, it is not possible to remove files (or
+ * directories) because the code necessary to defer actual removal
+ * until the file is not opened anymore would make the example much
+ * more complicated.
+ *
+ * When writeback caching is enabled (-o writeback mount option), it
+ * is only possible to write to files for which the mounting user has
+ * read permissions. This is because the writeback cache requires the
+ * kernel to be able to issue read requests for all files (which the
+ * passthrough filesystem cannot satisfy if it can't read the file in
+ * the underlying filesystem).
+ *
+ * Compile with:
+ *
+ * gcc -Wall passthrough_ll.c `pkg-config fuse3 --cflags --libs` -o passthrough_ll
+ *
+ * ## Source code ##
+ * \include passthrough_ll.c
+ */
+
+#define _GNU_SOURCE
+#define FUSE_USE_VERSION 31
+
+#include "config.h"
+
+#include <fuse_lowlevel.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <string.h>
+#include <limits.h>
+#include <dirent.h>
+#include <assert.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include <sys/file.h>
+#include <sys/xattr.h>
+
+#include "passthrough_helpers.h"
+
+/* We are re-using pointers to our `struct lo_inode` and `struct
+ lo_dirp` elements as inodes. This means that we must be able to
+ store uintptr_t values in a fuse_ino_t variable. The following
+ incantation checks this condition at compile time. */
+#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
+_Static_assert(sizeof(fuse_ino_t) >= sizeof(uintptr_t),
+ "fuse_ino_t too small to hold uintptr_t values!");
+#else
+struct _uintptr_to_must_hold_fuse_ino_t_dummy_struct \
+ { unsigned _uintptr_to_must_hold_fuse_ino_t:
+ ((sizeof(fuse_ino_t) >= sizeof(uintptr_t)) ? 1 : -1); };
+#endif
+
+struct lo_inode {
+ struct lo_inode *next; /* protected by lo->mutex */
+ struct lo_inode *prev; /* protected by lo->mutex */
+ int fd;
+ bool is_symlink;
+ ino_t ino;
+ dev_t dev;
+ uint64_t refcount; /* protected by lo->mutex */
+};
+
+enum {
+ CACHE_NEVER,
+ CACHE_NORMAL,
+ CACHE_ALWAYS,
+};
+
+struct lo_data {
+ pthread_mutex_t mutex;
+ int debug;
+ int writeback;
+ int flock;
+ int xattr;
+ const char *source;
+ double timeout;
+ int cache;
+ int timeout_set;
+ struct lo_inode root; /* protected by lo->mutex */
+};
+
+static const struct fuse_opt lo_opts[] = {
+ { "writeback",
+ offsetof(struct lo_data, writeback), 1 },
+ { "no_writeback",
+ offsetof(struct lo_data, writeback), 0 },
+ { "source=%s",
+ offsetof(struct lo_data, source), 0 },
+ { "flock",
+ offsetof(struct lo_data, flock), 1 },
+ { "no_flock",
+ offsetof(struct lo_data, flock), 0 },
+ { "xattr",
+ offsetof(struct lo_data, xattr), 1 },
+ { "no_xattr",
+ offsetof(struct lo_data, xattr), 0 },
+ { "timeout=%lf",
+ offsetof(struct lo_data, timeout), 0 },
+ { "timeout=",
+ offsetof(struct lo_data, timeout_set), 1 },
+ { "cache=never",
+ offsetof(struct lo_data, cache), CACHE_NEVER },
+ { "cache=auto",
+ offsetof(struct lo_data, cache), CACHE_NORMAL },
+ { "cache=always",
+ offsetof(struct lo_data, cache), CACHE_ALWAYS },
+
+ FUSE_OPT_END
+};
+
+static struct lo_data *lo_data(fuse_req_t req)
+{
+ return (struct lo_data *) fuse_req_userdata(req);
+}
+
+static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino)
+{
+ if (ino == FUSE_ROOT_ID)
+ return &lo_data(req)->root;
+ else
+ return (struct lo_inode *) (uintptr_t) ino;
+}
+
+static int lo_fd(fuse_req_t req, fuse_ino_t ino)
+{
+ return lo_inode(req, ino)->fd;
+}
+
+static bool lo_debug(fuse_req_t req)
+{
+ return lo_data(req)->debug != 0;
+}
+
+static void lo_init(void *userdata,
+ struct fuse_conn_info *conn)
+{
+ struct lo_data *lo = (struct lo_data*) userdata;
+
+ if(conn->capable & FUSE_CAP_EXPORT_SUPPORT)
+ conn->want |= FUSE_CAP_EXPORT_SUPPORT;
+
+ if (lo->writeback &&
+ conn->capable & FUSE_CAP_WRITEBACK_CACHE) {
+ if (lo->debug)
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating writeback\n");
+ conn->want |= FUSE_CAP_WRITEBACK_CACHE;
+ }
+ if (lo->flock && conn->capable & FUSE_CAP_FLOCK_LOCKS) {
+ if (lo->debug)
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
+ conn->want |= FUSE_CAP_FLOCK_LOCKS;
+ }
+}
+
+static void lo_getattr(fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi)
+{
+ int res;
+ struct stat buf;
+ struct lo_data *lo = lo_data(req);
+
+ (void) fi;
+
+ res = fstatat(lo_fd(req, ino), "", &buf, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1)
+ return (void) fuse_reply_err(req, errno);
+
+ fuse_reply_attr(req, &buf, lo->timeout);
+}
+
+static int utimensat_empty_nofollow(struct lo_inode *inode,
+ const struct timespec *tv)
+{
+ int res;
+ char procname[64];
+
+ if (inode->is_symlink) {
+ res = utimensat(inode->fd, "", tv,
+ AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1 && errno == EINVAL) {
+ /* Sorry, no race free way to set times on symlink. */
+ errno = EPERM;
+ }
+ return res;
+ }
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ return utimensat(AT_FDCWD, procname, tv, 0);
+}
+
+static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
+ int valid, struct fuse_file_info *fi)
+{
+ int saverr;
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ int ifd = inode->fd;
+ int res;
+
+ if (valid & FUSE_SET_ATTR_MODE) {
+ if (fi) {
+ res = fchmod(fi->fh, attr->st_mode);
+ } else {
+ sprintf(procname, "/proc/self/fd/%i", ifd);
+ res = chmod(procname, attr->st_mode);
+ }
+ if (res == -1)
+ goto out_err;
+ }
+ if (valid & (FUSE_SET_ATTR_UID | FUSE_SET_ATTR_GID)) {
+ uid_t uid = (valid & FUSE_SET_ATTR_UID) ?
+ attr->st_uid : (uid_t) -1;
+ gid_t gid = (valid & FUSE_SET_ATTR_GID) ?
+ attr->st_gid : (gid_t) -1;
+
+ res = fchownat(ifd, "", uid, gid,
+ AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1)
+ goto out_err;
+ }
+ if (valid & FUSE_SET_ATTR_SIZE) {
+ if (fi) {
+ res = ftruncate(fi->fh, attr->st_size);
+ } else {
+ sprintf(procname, "/proc/self/fd/%i", ifd);
+ res = truncate(procname, attr->st_size);
+ }
+ if (res == -1)
+ goto out_err;
+ }
+ if (valid & (FUSE_SET_ATTR_ATIME | FUSE_SET_ATTR_MTIME)) {
+ struct timespec tv[2];
+
+ tv[0].tv_sec = 0;
+ tv[1].tv_sec = 0;
+ tv[0].tv_nsec = UTIME_OMIT;
+ tv[1].tv_nsec = UTIME_OMIT;
+
+ if (valid & FUSE_SET_ATTR_ATIME_NOW)
+ tv[0].tv_nsec = UTIME_NOW;
+ else if (valid & FUSE_SET_ATTR_ATIME)
+ tv[0] = attr->st_atim;
+
+ if (valid & FUSE_SET_ATTR_MTIME_NOW)
+ tv[1].tv_nsec = UTIME_NOW;
+ else if (valid & FUSE_SET_ATTR_MTIME)
+ tv[1] = attr->st_mtim;
+
+ if (fi)
+ res = futimens(fi->fh, tv);
+ else
+ res = utimensat_empty_nofollow(inode, tv);
+ if (res == -1)
+ goto out_err;
+ }
+
+ return lo_getattr(req, ino, fi);
+
+out_err:
+ saverr = errno;
+ fuse_reply_err(req, saverr);
+}
+
+static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st)
+{
+ struct lo_inode *p;
+ struct lo_inode *ret = NULL;
+
+ pthread_mutex_lock(&lo->mutex);
+ for (p = lo->root.next; p != &lo->root; p = p->next) {
+ if (p->ino == st->st_ino && p->dev == st->st_dev) {
+ assert(p->refcount > 0);
+ ret = p;
+ ret->refcount++;
+ break;
+ }
+ }
+ pthread_mutex_unlock(&lo->mutex);
+ return ret;
+}
+
+static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
+ struct fuse_entry_param *e)
+{
+ int newfd;
+ int res;
+ int saverr;
+ struct lo_data *lo = lo_data(req);
+ struct lo_inode *inode;
+
+ memset(e, 0, sizeof(*e));
+ e->attr_timeout = lo->timeout;
+ e->entry_timeout = lo->timeout;
+
+ newfd = openat(lo_fd(req, parent), name, O_PATH | O_NOFOLLOW);
+ if (newfd == -1)
+ goto out_err;
+
+ res = fstatat(newfd, "", &e->attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1)
+ goto out_err;
+
+ inode = lo_find(lo_data(req), &e->attr);
+ if (inode) {
+ close(newfd);
+ newfd = -1;
+ } else {
+ struct lo_inode *prev, *next;
+
+ saverr = ENOMEM;
+ inode = calloc(1, sizeof(struct lo_inode));
+ if (!inode)
+ goto out_err;
+
+ inode->is_symlink = S_ISLNK(e->attr.st_mode);
+ inode->refcount = 1;
+ inode->fd = newfd;
+ inode->ino = e->attr.st_ino;
+ inode->dev = e->attr.st_dev;
+
+ pthread_mutex_lock(&lo->mutex);
+ prev = &lo->root;
+ next = prev->next;
+ next->prev = inode;
+ inode->next = next;
+ inode->prev = prev;
+ prev->next = inode;
+ pthread_mutex_unlock(&lo->mutex);
+ }
+ e->ino = (uintptr_t) inode;
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
+ (unsigned long long) parent, name, (unsigned long long) e->ino);
+
+ return 0;
+
+out_err:
+ saverr = errno;
+ if (newfd != -1)
+ close(newfd);
+ return saverr;
+}
+
+static void lo_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
+{
+ struct fuse_entry_param e;
+ int err;
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, "lo_lookup(parent=%" PRIu64 ", name=%s)\n",
+ parent, name);
+
+ err = lo_do_lookup(req, parent, name, &e);
+ if (err)
+ fuse_reply_err(req, err);
+ else
+ fuse_reply_entry(req, &e);
+}
+
+static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
+ const char *name, mode_t mode, dev_t rdev,
+ const char *link)
+{
+ int res;
+ int saverr;
+ struct lo_inode *dir = lo_inode(req, parent);
+ struct fuse_entry_param e;
+
+ saverr = ENOMEM;
+
+ res = mknod_wrapper(dir->fd, name, link, mode, rdev);
+
+ saverr = errno;
+ if (res == -1)
+ goto out;
+
+ saverr = lo_do_lookup(req, parent, name, &e);
+ if (saverr)
+ goto out;
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
+ (unsigned long long) parent, name, (unsigned long long) e.ino);
+
+ fuse_reply_entry(req, &e);
+ return;
+
+out:
+ fuse_reply_err(req, saverr);
+}
+
+static void lo_mknod(fuse_req_t req, fuse_ino_t parent,
+ const char *name, mode_t mode, dev_t rdev)
+{
+ lo_mknod_symlink(req, parent, name, mode, rdev, NULL);
+}
+
+static void lo_mkdir(fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode)
+{
+ lo_mknod_symlink(req, parent, name, S_IFDIR | mode, 0, NULL);
+}
+
+static void lo_symlink(fuse_req_t req, const char *link,
+ fuse_ino_t parent, const char *name)
+{
+ lo_mknod_symlink(req, parent, name, S_IFLNK, 0, link);
+}
+
+static int linkat_empty_nofollow(struct lo_inode *inode, int dfd,
+ const char *name)
+{
+ int res;
+ char procname[64];
+
+ if (inode->is_symlink) {
+ res = linkat(inode->fd, "", dfd, name, AT_EMPTY_PATH);
+ if (res == -1 && (errno == ENOENT || errno == EINVAL)) {
+ /* Sorry, no race free way to hard-link a symlink. */
+ errno = EPERM;
+ }
+ return res;
+ }
+
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ return linkat(AT_FDCWD, procname, dfd, name, AT_SYMLINK_FOLLOW);
+}
+
+static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
+ const char *name)
+{
+ int res;
+ struct lo_data *lo = lo_data(req);
+ struct lo_inode *inode = lo_inode(req, ino);
+ struct fuse_entry_param e;
+ int saverr;
+
+ memset(&e, 0, sizeof(struct fuse_entry_param));
+ e.attr_timeout = lo->timeout;
+ e.entry_timeout = lo->timeout;
+
+ res = linkat_empty_nofollow(inode, lo_fd(req, parent), name);
+ if (res == -1)
+ goto out_err;
+
+ res = fstatat(inode->fd, "", &e.attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1)
+ goto out_err;
+
+ pthread_mutex_lock(&lo->mutex);
+ inode->refcount++;
+ pthread_mutex_unlock(&lo->mutex);
+ e.ino = (uintptr_t) inode;
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
+ (unsigned long long) parent, name,
+ (unsigned long long) e.ino);
+
+ fuse_reply_entry(req, &e);
+ return;
+
+out_err:
+ saverr = errno;
+ fuse_reply_err(req, saverr);
+}
+
+static void lo_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
+{
+ int res;
+
+ res = unlinkat(lo_fd(req, parent), name, AT_REMOVEDIR);
+
+ fuse_reply_err(req, res == -1 ? errno : 0);
+}
+
+static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
+ fuse_ino_t newparent, const char *newname,
+ unsigned int flags)
+{
+ int res;
+
+ if (flags) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
+ res = renameat(lo_fd(req, parent), name,
+ lo_fd(req, newparent), newname);
+
+ fuse_reply_err(req, res == -1 ? errno : 0);
+}
+
+static void lo_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
+{
+ int res;
+
+ res = unlinkat(lo_fd(req, parent), name, 0);
+
+ fuse_reply_err(req, res == -1 ? errno : 0);
+}
+
+static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n)
+{
+ if (!inode)
+ return;
+
+ pthread_mutex_lock(&lo->mutex);
+ assert(inode->refcount >= n);
+ inode->refcount -= n;
+ if (!inode->refcount) {
+ struct lo_inode *prev, *next;
+
+ prev = inode->prev;
+ next = inode->next;
+ next->prev = prev;
+ prev->next = next;
+
+ pthread_mutex_unlock(&lo->mutex);
+ close(inode->fd);
+ free(inode);
+
+ } else {
+ pthread_mutex_unlock(&lo->mutex);
+ }
+}
+
+static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
+{
+ struct lo_data *lo = lo_data(req);
+ struct lo_inode *inode = lo_inode(req, ino);
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",
+ (unsigned long long) ino,
+ (unsigned long long) inode->refcount,
+ (unsigned long long) nlookup);
+ }
+
+ unref_inode(lo, inode, nlookup);
+}
+
+static void lo_forget(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
+{
+ lo_forget_one(req, ino, nlookup);
+ fuse_reply_none(req);
+}
+
+static void lo_forget_multi(fuse_req_t req, size_t count,
+ struct fuse_forget_data *forgets)
+{
+ int i;
+
+ for (i = 0; i < count; i++)
+ lo_forget_one(req, forgets[i].ino, forgets[i].nlookup);
+ fuse_reply_none(req);
+}
+
+static void lo_readlink(fuse_req_t req, fuse_ino_t ino)
+{
+ char buf[PATH_MAX + 1];
+ int res;
+
+ res = readlinkat(lo_fd(req, ino), "", buf, sizeof(buf));
+ if (res == -1)
+ return (void) fuse_reply_err(req, errno);
+
+ if (res == sizeof(buf))
+ return (void) fuse_reply_err(req, ENAMETOOLONG);
+
+ buf[res] = '\0';
+
+ fuse_reply_readlink(req, buf);
+}
+
+struct lo_dirp {
+ DIR *dp;
+ struct dirent *entry;
+ off_t offset;
+};
+
+static struct lo_dirp *lo_dirp(struct fuse_file_info *fi)
+{
+ return (struct lo_dirp *) (uintptr_t) fi->fh;
+}
+
+static void lo_opendir(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
+{
+ int error = ENOMEM;
+ struct lo_data *lo = lo_data(req);
+ struct lo_dirp *d;
+ int fd;
+
+ d = calloc(1, sizeof(struct lo_dirp));
+ if (d == NULL)
+ goto out_err;
+
+ fd = openat(lo_fd(req, ino), ".", O_RDONLY);
+ if (fd == -1)
+ goto out_errno;
+
+ d->dp = fdopendir(fd);
+ if (d->dp == NULL)
+ goto out_errno;
+
+ d->offset = 0;
+ d->entry = NULL;
+
+ fi->fh = (uintptr_t) d;
+ if (lo->cache == CACHE_ALWAYS)
+ fi->keep_cache = 1;
+ fuse_reply_open(req, fi);
+ return;
+
+out_errno:
+ error = errno;
+out_err:
+ if (d) {
+ if (fd != -1)
+ close(fd);
+ free(d);
+ }
+ fuse_reply_err(req, error);
+}
+
+static int is_dot_or_dotdot(const char *name)
+{
+ return name[0] == '.' && (name[1] == '\0' ||
+ (name[1] == '.' && name[2] == '\0'));
+}
+
+static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
+ off_t offset, struct fuse_file_info *fi, int plus)
+{
+ struct lo_dirp *d = lo_dirp(fi);
+ char *buf;
+ char *p;
+ size_t rem = size;
+ int err;
+
+ (void) ino;
+
+ buf = calloc(1, size);
+ if (!buf) {
+ err = ENOMEM;
+ goto error;
+ }
+ p = buf;
+
+ if (offset != d->offset) {
+ seekdir(d->dp, offset);
+ d->entry = NULL;
+ d->offset = offset;
+ }
+ while (1) {
+ size_t entsize;
+ off_t nextoff;
+ const char *name;
+
+ if (!d->entry) {
+ errno = 0;
+ d->entry = readdir(d->dp);
+ if (!d->entry) {
+ if (errno) { // Error
+ err = errno;
+ goto error;
+ } else { // End of stream
+ break;
+ }
+ }
+ }
+ nextoff = d->entry->d_off;
+ name = d->entry->d_name;
+ fuse_ino_t entry_ino = 0;
+ if (plus) {
+ struct fuse_entry_param e;
+ if (is_dot_or_dotdot(name)) {
+ e = (struct fuse_entry_param) {
+ .attr.st_ino = d->entry->d_ino,
+ .attr.st_mode = d->entry->d_type << 12,
+ };
+ } else {
+ err = lo_do_lookup(req, ino, name, &e);
+ if (err)
+ goto error;
+ entry_ino = e.ino;
+ }
+
+ entsize = fuse_add_direntry_plus(req, p, rem, name,
+ &e, nextoff);
+ } else {
+ struct stat st = {
+ .st_ino = d->entry->d_ino,
+ .st_mode = d->entry->d_type << 12,
+ };
+ entsize = fuse_add_direntry(req, p, rem, name,
+ &st, nextoff);
+ }
+ if (entsize > rem) {
+ if (entry_ino != 0)
+ lo_forget_one(req, entry_ino, 1);
+ break;
+ }
+
+ p += entsize;
+ rem -= entsize;
+
+ d->entry = NULL;
+ d->offset = nextoff;
+ }
+
+ err = 0;
+error:
+ // If there's an error, we can only signal it if we haven't stored
+ // any entries yet - otherwise we'd end up with wrong lookup
+ // counts for the entries that are already in the buffer. So we
+ // return what we've collected until that point.
+ if (err && rem == size)
+ fuse_reply_err(req, err);
+ else
+ fuse_reply_buf(req, buf, size - rem);
+ free(buf);
+}
+
+static void lo_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
+ off_t offset, struct fuse_file_info *fi)
+{
+ lo_do_readdir(req, ino, size, offset, fi, 0);
+}
+
+static void lo_readdirplus(fuse_req_t req, fuse_ino_t ino, size_t size,
+ off_t offset, struct fuse_file_info *fi)
+{
+ lo_do_readdir(req, ino, size, offset, fi, 1);
+}
+
+static void lo_releasedir(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
+{
+ struct lo_dirp *d = lo_dirp(fi);
+ (void) ino;
+ closedir(d->dp);
+ free(d);
+ fuse_reply_err(req, 0);
+}
+
+static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode, struct fuse_file_info *fi)
+{
+ int fd;
+ struct lo_data *lo = lo_data(req);
+ struct fuse_entry_param e;
+ int err;
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, "lo_create(parent=%" PRIu64 ", name=%s)\n",
+ parent, name);
+
+ fd = openat(lo_fd(req, parent), name,
+ (fi->flags | O_CREAT) & ~O_NOFOLLOW, mode);
+ if (fd == -1)
+ return (void) fuse_reply_err(req, errno);
+
+ fi->fh = fd;
+ if (lo->cache == CACHE_NEVER)
+ fi->direct_io = 1;
+ else if (lo->cache == CACHE_ALWAYS)
+ fi->keep_cache = 1;
+
+ err = lo_do_lookup(req, parent, name, &e);
+ if (err)
+ fuse_reply_err(req, err);
+ else
+ fuse_reply_create(req, &e, fi);
+}
+
+static void lo_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync,
+ struct fuse_file_info *fi)
+{
+ int res;
+ int fd = dirfd(lo_dirp(fi)->dp);
+ (void) ino;
+ if (datasync)
+ res = fdatasync(fd);
+ else
+ res = fsync(fd);
+ fuse_reply_err(req, res == -1 ? errno : 0);
+}
+
+static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
+{
+ int fd;
+ char buf[64];
+ struct lo_data *lo = lo_data(req);
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, "lo_open(ino=%" PRIu64 ", flags=%d)\n",
+ ino, fi->flags);
+
+ /* With writeback cache, kernel may send read requests even
+ when userspace opened write-only */
+ if (lo->writeback && (fi->flags & O_ACCMODE) == O_WRONLY) {
+ fi->flags &= ~O_ACCMODE;
+ fi->flags |= O_RDWR;
+ }
+
+ /* With writeback cache, O_APPEND is handled by the kernel.
+ This breaks atomicity (since the file may change in the
+ underlying filesystem, so that the kernel's idea of the
+ end of the file isn't accurate anymore). In this example,
+ we just accept that. A more rigorous filesystem may want
+ to return an error here */
+ if (lo->writeback && (fi->flags & O_APPEND))
+ fi->flags &= ~O_APPEND;
+
+ sprintf(buf, "/proc/self/fd/%i", lo_fd(req, ino));
+ fd = open(buf, fi->flags & ~O_NOFOLLOW);
+ if (fd == -1)
+ return (void) fuse_reply_err(req, errno);
+
+ fi->fh = fd;
+ if (lo->cache == CACHE_NEVER)
+ fi->direct_io = 1;
+ else if (lo->cache == CACHE_ALWAYS)
+ fi->keep_cache = 1;
+ fuse_reply_open(req, fi);
+}
+
+static void lo_release(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
+{
+ (void) ino;
+
+ close(fi->fh);
+ fuse_reply_err(req, 0);
+}
+
+static void lo_flush(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
+{
+ int res;
+ (void) ino;
+ res = close(dup(fi->fh));
+ fuse_reply_err(req, res == -1 ? errno : 0);
+}
+
+static void lo_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
+ struct fuse_file_info *fi)
+{
+ int res;
+ (void) ino;
+ if (datasync)
+ res = fdatasync(fi->fh);
+ else
+ res = fsync(fi->fh);
+ fuse_reply_err(req, res == -1 ? errno : 0);
+}
+
+static void lo_read(fuse_req_t req, fuse_ino_t ino, size_t size,
+ off_t offset, struct fuse_file_info *fi)
+{
+ struct fuse_bufvec buf = FUSE_BUFVEC_INIT(size);
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, "lo_read(ino=%" PRIu64 ", size=%zd, "
+ "off=%lu)\n", ino, size, (unsigned long) offset);
+
+ buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
+ buf.buf[0].fd = fi->fh;
+ buf.buf[0].pos = offset;
+
+ fuse_reply_data(req, &buf, FUSE_BUF_SPLICE_MOVE);
+}
+
+static void lo_write_buf(fuse_req_t req, fuse_ino_t ino,
+ struct fuse_bufvec *in_buf, off_t off,
+ struct fuse_file_info *fi)
+{
+ (void) ino;
+ ssize_t res;
+ struct fuse_bufvec out_buf = FUSE_BUFVEC_INIT(fuse_buf_size(in_buf));
+
+ out_buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
+ out_buf.buf[0].fd = fi->fh;
+ out_buf.buf[0].pos = off;
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, "lo_write(ino=%" PRIu64 ", size=%zd, off=%lu)\n",
+ ino, out_buf.buf[0].size, (unsigned long) off);
+
+ res = fuse_buf_copy(&out_buf, in_buf, 0);
+ if(res < 0)
+ fuse_reply_err(req, -res);
+ else
+ fuse_reply_write(req, (size_t) res);
+}
+
+static void lo_statfs(fuse_req_t req, fuse_ino_t ino)
+{
+ int res;
+ struct statvfs stbuf;
+
+ res = fstatvfs(lo_fd(req, ino), &stbuf);
+ if (res == -1)
+ fuse_reply_err(req, errno);
+ else
+ fuse_reply_statfs(req, &stbuf);
+}
+
+static void lo_fallocate(fuse_req_t req, fuse_ino_t ino, int mode,
+ off_t offset, off_t length, struct fuse_file_info *fi)
+{
+ int err = EOPNOTSUPP;
+ (void) ino;
+
+#ifdef HAVE_FALLOCATE
+ err = fallocate(fi->fh, mode, offset, length);
+ if (err < 0)
+ err = errno;
+
+#elif defined(HAVE_POSIX_FALLOCATE)
+ if (mode) {
+ fuse_reply_err(req, EOPNOTSUPP);
+ return;
+ }
+
+ err = posix_fallocate(fi->fh, offset, length);
+#endif
+
+ fuse_reply_err(req, err);
+}
+
+static void lo_flock(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
+ int op)
+{
+ int res;
+ (void) ino;
+
+ res = flock(fi->fh, op);
+
+ fuse_reply_err(req, res == -1 ? errno : 0);
+}
+
+static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
+ size_t size)
+{
+ char *value = NULL;
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ ssize_t ret;
+ int saverr;
+
+ saverr = ENOSYS;
+ if (!lo_data(req)->xattr)
+ goto out;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_getxattr(ino=%" PRIu64 ", name=%s size=%zd)\n",
+ ino, name, size);
+ }
+
+ if (inode->is_symlink) {
+ /* Sorry, no race free way to getxattr on symlink. */
+ saverr = EPERM;
+ goto out;
+ }
+
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ if (size) {
+ value = malloc(size);
+ if (!value)
+ goto out_err;
+
+ ret = getxattr(procname, name, value, size);
+ if (ret == -1)
+ goto out_err;
+ saverr = 0;
+ if (ret == 0)
+ goto out;
+
+ fuse_reply_buf(req, value, ret);
+ } else {
+ ret = getxattr(procname, name, NULL, 0);
+ if (ret == -1)
+ goto out_err;
+
+ fuse_reply_xattr(req, ret);
+ }
+out_free:
+ free(value);
+ return;
+
+out_err:
+ saverr = errno;
+out:
+ fuse_reply_err(req, saverr);
+ goto out_free;
+}
+
+static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
+{
+ char *value = NULL;
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ ssize_t ret;
+ int saverr;
+
+ saverr = ENOSYS;
+ if (!lo_data(req)->xattr)
+ goto out;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_listxattr(ino=%" PRIu64 ", size=%zd)\n",
+ ino, size);
+ }
+
+ if (inode->is_symlink) {
+ /* Sorry, no race free way to listxattr on symlink. */
+ saverr = EPERM;
+ goto out;
+ }
+
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ if (size) {
+ value = malloc(size);
+ if (!value)
+ goto out_err;
+
+ ret = listxattr(procname, value, size);
+ if (ret == -1)
+ goto out_err;
+ saverr = 0;
+ if (ret == 0)
+ goto out;
+
+ fuse_reply_buf(req, value, ret);
+ } else {
+ ret = listxattr(procname, NULL, 0);
+ if (ret == -1)
+ goto out_err;
+
+ fuse_reply_xattr(req, ret);
+ }
+out_free:
+ free(value);
+ return;
+
+out_err:
+ saverr = errno;
+out:
+ fuse_reply_err(req, saverr);
+ goto out_free;
+}
+
+static void lo_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
+ const char *value, size_t size, int flags)
+{
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ ssize_t ret;
+ int saverr;
+
+ saverr = ENOSYS;
+ if (!lo_data(req)->xattr)
+ goto out;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_setxattr(ino=%" PRIu64 ", name=%s value=%s size=%zd)\n",
+ ino, name, value, size);
+ }
+
+ if (inode->is_symlink) {
+ /* Sorry, no race free way to setxattr on symlink. */
+ saverr = EPERM;
+ goto out;
+ }
+
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ ret = setxattr(procname, name, value, size, flags);
+ saverr = ret == -1 ? errno : 0;
+
+out:
+ fuse_reply_err(req, saverr);
+}
+
+static void lo_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name)
+{
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ ssize_t ret;
+ int saverr;
+
+ saverr = ENOSYS;
+ if (!lo_data(req)->xattr)
+ goto out;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_removexattr(ino=%" PRIu64 ", name=%s)\n",
+ ino, name);
+ }
+
+ if (inode->is_symlink) {
+ /* Sorry, no race free way to setxattr on symlink. */
+ saverr = EPERM;
+ goto out;
+ }
+
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ ret = removexattr(procname, name);
+ saverr = ret == -1 ? errno : 0;
+
+out:
+ fuse_reply_err(req, saverr);
+}
+
+#ifdef HAVE_COPY_FILE_RANGE
+static void lo_copy_file_range(fuse_req_t req, fuse_ino_t ino_in, off_t off_in,
+ struct fuse_file_info *fi_in,
+ fuse_ino_t ino_out, off_t off_out,
+ struct fuse_file_info *fi_out, size_t len,
+ int flags)
+{
+ ssize_t res;
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG, "lo_copy_file_range(ino=%" PRIu64 "/fd=%lu, "
+ "off=%lu, ino=%" PRIu64 "/fd=%lu, "
+ "off=%lu, size=%zd, flags=0x%x)\n",
+ ino_in, fi_in->fh, off_in, ino_out, fi_out->fh, off_out,
+ len, flags);
+
+ res = copy_file_range(fi_in->fh, &off_in, fi_out->fh, &off_out, len,
+ flags);
+ if (res < 0)
+ fuse_reply_err(req, -errno);
+ else
+ fuse_reply_write(req, res);
+}
+#endif
+
+static void lo_lseek(fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
+ struct fuse_file_info *fi)
+{
+ off_t res;
+
+ (void)ino;
+ res = lseek(fi->fh, off, whence);
+ if (res != -1)
+ fuse_reply_lseek(req, res);
+ else
+ fuse_reply_err(req, errno);
+}
+
+static struct fuse_lowlevel_ops lo_oper = {
+ .init = lo_init,
+ .lookup = lo_lookup,
+ .mkdir = lo_mkdir,
+ .mknod = lo_mknod,
+ .symlink = lo_symlink,
+ .link = lo_link,
+ .unlink = lo_unlink,
+ .rmdir = lo_rmdir,
+ .rename = lo_rename,
+ .forget = lo_forget,
+ .forget_multi = lo_forget_multi,
+ .getattr = lo_getattr,
+ .setattr = lo_setattr,
+ .readlink = lo_readlink,
+ .opendir = lo_opendir,
+ .readdir = lo_readdir,
+ .readdirplus = lo_readdirplus,
+ .releasedir = lo_releasedir,
+ .fsyncdir = lo_fsyncdir,
+ .create = lo_create,
+ .open = lo_open,
+ .release = lo_release,
+ .flush = lo_flush,
+ .fsync = lo_fsync,
+ .read = lo_read,
+ .write_buf = lo_write_buf,
+ .statfs = lo_statfs,
+ .fallocate = lo_fallocate,
+ .flock = lo_flock,
+ .getxattr = lo_getxattr,
+ .listxattr = lo_listxattr,
+ .setxattr = lo_setxattr,
+ .removexattr = lo_removexattr,
+#ifdef HAVE_COPY_FILE_RANGE
+ .copy_file_range = lo_copy_file_range,
+#endif
+ .lseek = lo_lseek,
+};
+
+int main(int argc, char *argv[])
+{
+ struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
+ struct fuse_session *se;
+ struct fuse_cmdline_opts opts;
+ struct lo_data lo = { .debug = 0,
+ .writeback = 0 };
+ int ret = -1;
+
+ /* Don't mask creation mode, kernel already did that */
+ umask(0);
+
+ pthread_mutex_init(&lo.mutex, NULL);
+ lo.root.next = lo.root.prev = &lo.root;
+ lo.root.fd = -1;
+ lo.cache = CACHE_NORMAL;
+
+ if (fuse_parse_cmdline(&args, &opts) != 0)
+ return 1;
+ if (opts.show_help) {
+ printf("usage: %s [options] <mountpoint>\n\n", argv[0]);
+ fuse_cmdline_help();
+ fuse_lowlevel_help();
+ ret = 0;
+ goto err_out1;
+ } else if (opts.show_version) {
+ printf("FUSE library version %s\n", fuse_pkgversion());
+ fuse_lowlevel_version();
+ ret = 0;
+ goto err_out1;
+ }
+
+ if(opts.mountpoint == NULL) {
+ printf("usage: %s [options] <mountpoint>\n", argv[0]);
+ printf(" %s --help\n", argv[0]);
+ ret = 1;
+ goto err_out1;
+ }
+
+ if (fuse_opt_parse(&args, &lo, lo_opts, NULL)== -1)
+ return 1;
+
+ lo.debug = opts.debug;
+ lo.root.refcount = 2;
+ if (lo.source) {
+ struct stat stat;
+ int res;
+
+ res = lstat(lo.source, &stat);
+ if (res == -1) {
+ fuse_log(FUSE_LOG_ERR, "failed to stat source (\"%s\"): %m\n",
+ lo.source);
+ exit(1);
+ }
+ if (!S_ISDIR(stat.st_mode)) {
+ fuse_log(FUSE_LOG_ERR, "source is not a directory\n");
+ exit(1);
+ }
+
+ } else {
+ lo.source = "/";
+ }
+ lo.root.is_symlink = false;
+ if (!lo.timeout_set) {
+ switch (lo.cache) {
+ case CACHE_NEVER:
+ lo.timeout = 0.0;
+ break;
+
+ case CACHE_NORMAL:
+ lo.timeout = 1.0;
+ break;
+
+ case CACHE_ALWAYS:
+ lo.timeout = 86400.0;
+ break;
+ }
+ } else if (lo.timeout < 0) {
+ fuse_log(FUSE_LOG_ERR, "timeout is negative (%lf)\n",
+ lo.timeout);
+ exit(1);
+ }
+
+ lo.root.fd = open(lo.source, O_PATH);
+ if (lo.root.fd == -1) {
+ fuse_log(FUSE_LOG_ERR, "open(\"%s\", O_PATH): %m\n",
+ lo.source);
+ exit(1);
+ }
+
+ se = fuse_session_new(&args, &lo_oper, sizeof(lo_oper), &lo);
+ if (se == NULL)
+ goto err_out1;
+
+ if (fuse_set_signal_handlers(se) != 0)
+ goto err_out2;
+
+ if (fuse_session_mount(se, opts.mountpoint) != 0)
+ goto err_out3;
+
+ fuse_daemonize(opts.foreground);
+
+ /* Block until ctrl+c or fusermount -u */
+ if (opts.singlethread)
+ ret = fuse_session_loop(se);
+ else
+ ret = fuse_session_loop_mt(se, opts.clone_fd);
+
+ fuse_session_unmount(se);
+err_out3:
+ fuse_remove_signal_handlers(se);
+err_out2:
+ fuse_session_destroy(se);
+err_out1:
+ free(opts.mountpoint);
+ fuse_opt_free_args(&args);
+
+ if (lo.root.fd >= 0)
+ close(lo.root.fd);
+
+ return ret ? 1 : 0;
+}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 006/108] virtiofsd: Trim down imported files
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (4 preceding siblings ...)
2020-01-23 16:44 ` [PULL 005/108] virtiofsd: Add passthrough_ll Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 007/108] virtiofsd: Format imported files to qemu style Dr. David Alan Gilbert (git)
` (103 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
There's a lot of the original fuse code we don't need; trim them down.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
with additional trimming by:
Signed-off-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Xiao Yang <yangx.jy@cn.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/buffer.c | 71 +--
tools/virtiofsd/fuse.h | 46 --
tools/virtiofsd/fuse_common.h | 32 --
tools/virtiofsd/fuse_i.h | 41 --
tools/virtiofsd/fuse_log.h | 8 -
tools/virtiofsd/fuse_lowlevel.c | 675 +-------------------------
tools/virtiofsd/fuse_lowlevel.h | 28 --
tools/virtiofsd/fuse_opt.h | 8 -
tools/virtiofsd/helper.c | 143 ------
tools/virtiofsd/passthrough_helpers.h | 26 -
tools/virtiofsd/passthrough_ll.c | 1 -
11 files changed, 8 insertions(+), 1071 deletions(-)
diff --git a/tools/virtiofsd/buffer.c b/tools/virtiofsd/buffer.c
index 5ab9b87455..aefb7dbf15 100644
--- a/tools/virtiofsd/buffer.c
+++ b/tools/virtiofsd/buffer.c
@@ -157,73 +157,6 @@ static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,
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)
@@ -247,10 +180,8 @@ static ssize_t fuse_buf_copy_one(const struct fuse_buf *dst, size_t dst_off,
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);
+ return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
}
}
diff --git a/tools/virtiofsd/fuse.h b/tools/virtiofsd/fuse.h
index 883f6e59fb..3202fba6bb 100644
--- a/tools/virtiofsd/fuse.h
+++ b/tools/virtiofsd/fuse.h
@@ -25,10 +25,6 @@
#include <sys/statvfs.h>
#include <sys/uio.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* ----------------------------------------------------------- *
* Basic FUSE API *
* ----------------------------------------------------------- */
@@ -978,44 +974,6 @@ int fuse_loop(struct fuse *f);
*/
void fuse_exit(struct fuse *f);
-/**
- * FUSE event loop with multiple threads
- *
- * Requests from the kernel are processed, and the appropriate
- * operations are called. Request are processed in parallel by
- * distributing them between multiple threads.
- *
- * For a description of the return value and the conditions when the
- * event loop exits, refer to the documentation of
- * fuse_session_loop().
- *
- * Note: using fuse_loop() instead of fuse_loop_mt() means you are running in
- * single-threaded mode, and that you will not have to worry about reentrancy,
- * though you will have to worry about recursive lookups. In single-threaded
- * mode, FUSE will wait for one callback to return before calling another.
- *
- * Enabling multiple threads, by using fuse_loop_mt(), will cause FUSE to make
- * multiple simultaneous calls into the various callback functions given by your
- * fuse_operations record.
- *
- * If you are using multiple threads, you can enjoy all the parallel execution
- * and interactive response benefits of threads, and you get to enjoy all the
- * benefits of race conditions and locking bugs, too. Ensure that any code used
- * in the callback function of fuse_operations is also thread-safe.
- *
- * @param f the FUSE handle
- * @param config loop configuration
- * @return see fuse_session_loop()
- *
- * See also: fuse_loop()
- */
-#if FUSE_USE_VERSION < 32
-int fuse_loop_mt_31(struct fuse *f, int clone_fd);
-#define fuse_loop_mt(f, clone_fd) fuse_loop_mt_31(f, clone_fd)
-#else
-int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config);
-#endif
-
/**
* Get the current context
*
@@ -1268,8 +1226,4 @@ struct fuse_session *fuse_get_session(struct fuse *f);
*/
int fuse_open_channel(const char *mountpoint, const char *options);
-#ifdef __cplusplus
-}
-#endif
-
#endif /* FUSE_H_ */
diff --git a/tools/virtiofsd/fuse_common.h b/tools/virtiofsd/fuse_common.h
index 2d686b2ac4..bf8f8cc865 100644
--- a/tools/virtiofsd/fuse_common.h
+++ b/tools/virtiofsd/fuse_common.h
@@ -28,10 +28,6 @@
#define FUSE_MAKE_VERSION(maj, min) ((maj) * 10 + (min))
#define FUSE_VERSION FUSE_MAKE_VERSION(FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION)
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/**
* Information about an open file.
*
@@ -100,30 +96,6 @@ struct fuse_file_info {
uint32_t poll_events;
};
-/**
- * Configuration parameters passed to fuse_session_loop_mt() and
- * fuse_loop_mt().
- */
-struct fuse_loop_config {
- /**
- * whether to use separate device fds for each thread
- * (may increase performance)
- */
- int clone_fd;
-
- /**
- * The maximum number of available worker threads before they
- * start to get deleted when they become idle. If not
- * specified, the default is 10.
- *
- * Adjusting this has performance implications; a very small number
- * of threads in the pool will cause a lot of thread creation and
- * deletion overhead and performance may suffer. When set to 0, a new
- * thread will be created to service every operation.
- */
- unsigned int max_idle_threads;
-};
-
/**************************************************************************
* Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want' *
**************************************************************************/
@@ -802,10 +774,6 @@ void fuse_remove_signal_handlers(struct fuse_session *se);
# error only API version 30 or greater is supported
#endif
-#ifdef __cplusplus
-}
-#endif
-
/*
* This interface uses 64 bit off_t.
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index d38b630ac5..b39522e3ca 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -9,8 +9,6 @@
#include "fuse.h"
#include "fuse_lowlevel.h"
-struct mount_opts;
-
struct fuse_req {
struct fuse_session *se;
uint64_t unique;
@@ -45,7 +43,6 @@ struct fuse_session {
char *mountpoint;
volatile int exited;
int fd;
- struct mount_opts *mo;
int debug;
int deny_others;
struct fuse_lowlevel_ops op;
@@ -58,7 +55,6 @@ struct fuse_session {
struct fuse_req interrupts;
pthread_mutex_t lock;
int got_destroy;
- pthread_key_t pipe_key;
int broken_splice_nonblock;
uint64_t notify_ctr;
struct fuse_notify_req notify_list;
@@ -87,53 +83,16 @@ struct fuse_module {
int ctr;
};
-/* ----------------------------------------------------------- *
- * Channel interface (when using -o clone_fd) *
- * ----------------------------------------------------------- */
-
-/**
- * Obtain counted reference to the channel
- *
- * @param ch the channel
- * @return the channel
- */
-struct fuse_chan *fuse_chan_get(struct fuse_chan *ch);
-
-/**
- * Drop counted reference to a channel
- *
- * @param ch the channel
- */
-void fuse_chan_put(struct fuse_chan *ch);
-
-struct mount_opts *parse_mount_opts(struct fuse_args *args);
-void destroy_mount_opts(struct mount_opts *mo);
-void fuse_mount_version(void);
-unsigned get_max_read(struct mount_opts *o);
-void fuse_kern_unmount(const char *mountpoint, int fd);
-int fuse_kern_mount(const char *mountpoint, struct mount_opts *mo);
-
int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
int count);
void fuse_free_req(fuse_req_t req);
-void cuse_lowlevel_init(fuse_req_t req, fuse_ino_t nodeide, const void *inarg);
-
-int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg);
-
-int fuse_session_receive_buf_int(struct fuse_session *se, struct fuse_buf *buf,
- struct fuse_chan *ch);
void fuse_session_process_buf_int(struct fuse_session *se,
const struct fuse_buf *buf, struct fuse_chan *ch);
-struct fuse *fuse_new_31(struct fuse_args *args, const struct fuse_operations *op,
- size_t op_size, void *private_data);
-int fuse_loop_mt_32(struct fuse *f, struct fuse_loop_config *config);
-int fuse_session_loop_mt_32(struct fuse_session *se, struct fuse_loop_config *config);
#define FUSE_MAX_MAX_PAGES 256
#define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32
/* room needed in buffer to accommodate header */
#define FUSE_BUFFER_HEADER_SIZE 0x1000
-
diff --git a/tools/virtiofsd/fuse_log.h b/tools/virtiofsd/fuse_log.h
index 5e112e0f53..0af700da6b 100644
--- a/tools/virtiofsd/fuse_log.h
+++ b/tools/virtiofsd/fuse_log.h
@@ -16,10 +16,6 @@
#include <stdarg.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/**
* Log severity level
*
@@ -75,8 +71,4 @@ void fuse_set_log_func(fuse_log_func_t func);
*/
void fuse_log(enum fuse_log_level level, const char *fmt, ...);
-#ifdef __cplusplus
-}
-#endif
-
#endif /* FUSE_LOG_H_ */
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index f2d7038e34..e6fa247924 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -16,7 +16,6 @@
#include "fuse_kernel.h"
#include "fuse_opt.h"
#include "fuse_misc.h"
-#include "mount_util.h"
#include <stdio.h>
#include <stdlib.h>
@@ -28,12 +27,6 @@
#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)))
@@ -137,7 +130,6 @@ void fuse_free_req(fuse_req_t req)
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)
@@ -184,19 +176,7 @@ static int fuse_send_msg(struct fuse_session *se, struct fuse_chan *ch,
}
}
- 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;
- }
-
+ abort(); /* virtio should have taken it before here */
return 0;
}
@@ -480,10 +460,6 @@ static int fuse_send_data_iov_fallback(struct fuse_session *se,
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)) {
@@ -496,350 +472,10 @@ static int fuse_send_data_iov_fallback(struct fuse_session *se,
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;
- }
+ abort(); /* Will have taken vhost path */
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;
-
- if (llp->size < pipesize) {
- if (llp->can_grow) {
- res = fcntl(llp->pipe[0], F_SETPIPE_SZ, pipesize);
- if (res == -1) {
- res = grow_pipe_to_max(llp->pipe[0]);
- if (res > 0)
- llp->size = res;
- llp->can_grow = 0;
- goto fallback;
- }
- llp->size = res;
- }
- if (llp->size < pipesize)
- goto fallback;
- }
-
-
- res = vmsplice(llp->pipe[1], iov, iov_count, SPLICE_F_NONBLOCK);
- if (res == -1)
- goto fallback;
-
- if (res != headerlen) {
- res = -EIO;
- fuse_log(FUSE_LOG_ERR, "fuse: short vmsplice to pipe: %u/%zu\n", res,
- headerlen);
- goto clear_pipe;
- }
-
- pipe_buf.buf[0].flags = FUSE_BUF_IS_FD;
- pipe_buf.buf[0].fd = llp->pipe[1];
-
- res = fuse_buf_copy(&pipe_buf, buf,
- FUSE_BUF_FORCE_SPLICE | FUSE_BUF_SPLICE_NONBLOCK);
- if (res < 0) {
- if (res == -EAGAIN || res == -EINVAL) {
- /*
- * Should only get EAGAIN on kernels with
- * broken SPLICE_F_NONBLOCK support (<=
- * 2.6.35) where this error or a short read is
- * returned even if the pipe itself is not
- * full
- *
- * EINVAL might mean that splice can't handle
- * this combination of input and output.
- */
- if (res == -EAGAIN)
- se->broken_splice_nonblock = 1;
-
- pthread_setspecific(se->pipe_key, NULL);
- fuse_ll_pipe_free(llp);
- goto fallback;
- }
- res = -res;
- goto clear_pipe;
- }
-
- if (res != 0 && res < len) {
- struct fuse_bufvec mem_buf = FUSE_BUFVEC_INIT(len);
- void *mbuf;
- size_t now_len = res;
- /*
- * For regular files a short count is either
- * 1) due to EOF, or
- * 2) because of broken SPLICE_F_NONBLOCK (see above)
- *
- * For other inputs it's possible that we overflowed
- * the pipe because of small buffer fragments.
- */
-
- res = posix_memalign(&mbuf, pagesize, len);
- if (res != 0)
- goto clear_pipe;
-
- mem_buf.buf[0].mem = mbuf;
- mem_buf.off = now_len;
- res = fuse_buf_copy(&mem_buf, buf, 0);
- if (res > 0) {
- char *tmpbuf;
- size_t extra_len = res;
- /*
- * Trickiest case: got more data. Need to get
- * back the data from the pipe and then fall
- * back to regular write.
- */
- tmpbuf = malloc(headerlen);
- if (tmpbuf == NULL) {
- free(mbuf);
- res = ENOMEM;
- goto clear_pipe;
- }
- res = read_back(llp->pipe[0], tmpbuf, headerlen);
- free(tmpbuf);
- if (res != 0) {
- free(mbuf);
- goto clear_pipe;
- }
- res = read_back(llp->pipe[0], mbuf, now_len);
- if (res != 0) {
- free(mbuf);
- goto clear_pipe;
- }
- len = now_len + extra_len;
- 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;
- }
- free(mbuf);
- res = now_len;
- }
- len = res;
- out->len = headerlen + len;
-
- if (se->debug) {
- fuse_log(FUSE_LOG_DEBUG,
- " unique: %llu, success, outsize: %i (splice)\n",
- (unsigned long long) out->unique, out->len);
- }
-
- splice_flags = 0;
- if ((flags & FUSE_BUF_SPLICE_MOVE) &&
- (se->conn.want & FUSE_CAP_SPLICE_MOVE))
- splice_flags |= SPLICE_F_MOVE;
-
- res = splice(llp->pipe[0], NULL, ch ? ch->fd : se->fd,
- NULL, out->len, splice_flags);
- if (res == -1) {
- res = -errno;
- perror("fuse: splice from pipe");
- goto clear_pipe;
- }
- if (res != out->len) {
- res = -EIO;
- fuse_log(FUSE_LOG_ERR, "fuse: short splice from pipe: %u/%u\n",
- res, out->len);
- goto clear_pipe;
- }
- return 0;
-
-clear_pipe:
- fuse_ll_clear_pipe(se);
- return res;
-
-fallback:
- return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
-}
-#else
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)
@@ -849,7 +485,6 @@ static int fuse_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
}
-#endif
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
enum fuse_buf_copy_flags flags)
@@ -1408,16 +1043,11 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
if (bufv.buf[0].size < arg->size) {
fuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");
fuse_reply_err(req, EIO);
- goto out;
+ return;
}
bufv.buf[0].size = arg->size;
se->op.write_buf(req, nodeid, &bufv, arg->offset, &fi);
-
-out:
- /* Need to reset the pipe if ->write_buf() didn't consume all data */
- if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
- fuse_ll_clear_pipe(se);
}
static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
@@ -2038,17 +1668,6 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
return;
}
- unsigned max_read_mo = get_max_read(se->mo);
- if (se->conn.max_read != max_read_mo) {
- fuse_log(FUSE_LOG_ERR, "fuse: error: init() and fuse_session_new() "
- "requested different maximum read size (%u vs %u)\n",
- se->conn.max_read, max_read_mo);
- fuse_reply_err(req, EPROTO);
- se->error = -EPROTO;
- fuse_session_exit(se);
- return;
- }
-
if (se->conn.max_write < bufsize - FUSE_BUFFER_HEADER_SIZE) {
se->bufsize = se->conn.max_write + FUSE_BUFFER_HEADER_SIZE;
}
@@ -2364,8 +1983,6 @@ static void fuse_ll_retrieve_reply(struct fuse_notify_req *nreq,
}
out:
free(rreq);
- if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
- fuse_ll_clear_pipe(se);
}
int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
@@ -2496,7 +2113,6 @@ static struct {
[FUSE_RENAME2] = { do_rename2, "RENAME2" },
[FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" },
[FUSE_LSEEK] = { do_lseek, "LSEEK" },
- [CUSE_INIT] = { cuse_lowlevel_init, "CUSE_INIT" },
};
#define FUSE_MAXOP (sizeof(fuse_ll_ops) / sizeof(fuse_ll_ops[0]))
@@ -2509,21 +2125,6 @@ static const char *opname(enum fuse_opcode opcode)
return fuse_ll_ops[opcode].name;
}
-static int fuse_ll_copy_from_pipe(struct fuse_bufvec *dst,
- struct fuse_bufvec *src)
-{
- ssize_t res = fuse_buf_copy(dst, src, 0);
- if (res < 0) {
- fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: %s\n", strerror(-res));
- return res;
- }
- if ((size_t)res < fuse_buf_size(dst)) {
- fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: short read\n");
- return -1;
- }
- return 0;
-}
-
void fuse_session_process_buf(struct fuse_session *se,
const struct fuse_buf *buf)
{
@@ -2533,36 +2134,12 @@ void fuse_session_process_buf(struct fuse_session *se,
void fuse_session_process_buf_int(struct fuse_session *se,
const struct fuse_buf *buf, struct fuse_chan *ch)
{
- const size_t write_header_size = sizeof(struct fuse_in_header) +
- sizeof(struct fuse_write_in);
- struct fuse_bufvec bufv = { .buf[0] = *buf, .count = 1 };
- struct fuse_bufvec tmpbuf = FUSE_BUFVEC_INIT(write_header_size);
struct fuse_in_header *in;
const void *inarg;
struct fuse_req *req;
- void *mbuf = NULL;
int err;
- int res;
-
- if (buf->flags & FUSE_BUF_IS_FD) {
- if (buf->size < tmpbuf.buf[0].size)
- tmpbuf.buf[0].size = buf->size;
- mbuf = malloc(tmpbuf.buf[0].size);
- if (mbuf == NULL) {
- fuse_log(FUSE_LOG_ERR, "fuse: failed to allocate header\n");
- goto clear_pipe;
- }
- tmpbuf.buf[0].mem = mbuf;
-
- res = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);
- if (res < 0)
- goto clear_pipe;
-
- in = mbuf;
- } else {
- in = buf->mem;
- }
+ in = buf->mem;
if (se->debug) {
fuse_log(FUSE_LOG_DEBUG,
@@ -2584,14 +2161,14 @@ void fuse_session_process_buf_int(struct fuse_session *se,
};
fuse_send_msg(se, ch, &iov, 1);
- goto clear_pipe;
+ return;
}
req->unique = in->unique;
req->ctx.uid = in->uid;
req->ctx.gid = in->gid;
req->ctx.pid = in->pid;
- req->ch = ch ? fuse_chan_get(ch) : NULL;
+ req->ch = ch;
err = EIO;
if (!se->got_init) {
@@ -2627,28 +2204,6 @@ void fuse_session_process_buf_int(struct fuse_session *se,
fuse_reply_err(intr, EAGAIN);
}
- if ((buf->flags & FUSE_BUF_IS_FD) && write_header_size < buf->size &&
- (in->opcode != FUSE_WRITE || !se->op.write_buf) &&
- in->opcode != FUSE_NOTIFY_REPLY) {
- void *newmbuf;
-
- err = ENOMEM;
- newmbuf = realloc(mbuf, buf->size);
- if (newmbuf == NULL)
- goto reply_err;
- mbuf = newmbuf;
-
- tmpbuf = FUSE_BUFVEC_INIT(buf->size - write_header_size);
- tmpbuf.buf[0].mem = (char *)mbuf + write_header_size;
-
- res = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);
- err = -res;
- if (res < 0)
- goto reply_err;
-
- in = mbuf;
- }
-
inarg = (void *) &in[1];
if (in->opcode == FUSE_WRITE && se->op.write_buf)
do_write_buf(req, in->nodeid, inarg, buf);
@@ -2657,16 +2212,10 @@ void fuse_session_process_buf_int(struct fuse_session *se,
else
fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
-out_free:
- free(mbuf);
return;
reply_err:
fuse_reply_err(req, err);
-clear_pipe:
- if (buf->flags & FUSE_BUF_IS_FD)
- fuse_ll_clear_pipe(se);
- goto out_free;
}
#define LL_OPTION(n,o,v) \
@@ -2684,7 +2233,6 @@ void fuse_lowlevel_version(void)
{
printf("using FUSE kernel interface version %i.%i\n",
FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
- fuse_mount_version();
}
void fuse_lowlevel_help(void)
@@ -2692,204 +2240,29 @@ void fuse_lowlevel_help(void)
/* These are not all options, but the ones that are
potentially of interest to an end-user */
printf(
-" -o allow_other allow access by all users\n"
" -o allow_root allow access by root\n"
-" -o auto_unmount auto unmount on process termination\n");
+);
}
void fuse_session_destroy(struct fuse_session *se)
{
- struct fuse_ll_pipe *llp;
-
if (se->got_init && !se->got_destroy) {
if (se->op.destroy)
se->op.destroy(se->userdata);
}
- llp = pthread_getspecific(se->pipe_key);
- if (llp != NULL)
- fuse_ll_pipe_free(llp);
- pthread_key_delete(se->pipe_key);
pthread_mutex_destroy(&se->lock);
free(se->cuse_data);
if (se->fd != -1)
close(se->fd);
- destroy_mount_opts(se->mo);
free(se);
}
-static void fuse_ll_pipe_destructor(void *data)
-{
- struct fuse_ll_pipe *llp = data;
- fuse_ll_pipe_free(llp);
-}
-
-int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf)
-{
- return fuse_session_receive_buf_int(se, buf, NULL);
-}
-
-int fuse_session_receive_buf_int(struct fuse_session *se, struct fuse_buf *buf,
- struct fuse_chan *ch)
-{
- int err;
- ssize_t res;
-#ifdef HAVE_SPLICE
- size_t bufsize = se->bufsize;
- struct fuse_ll_pipe *llp;
- struct fuse_buf tmpbuf;
-
- if (se->conn.proto_minor < 14 || !(se->conn.want & FUSE_CAP_SPLICE_READ))
- goto fallback;
-
- llp = fuse_ll_get_pipe(se);
- if (llp == NULL)
- goto fallback;
-
- if (llp->size < bufsize) {
- if (llp->can_grow) {
- res = fcntl(llp->pipe[0], F_SETPIPE_SZ, bufsize);
- if (res == -1) {
- llp->can_grow = 0;
- res = grow_pipe_to_max(llp->pipe[0]);
- if (res > 0)
- llp->size = res;
- goto fallback;
- }
- llp->size = res;
- }
- if (llp->size < bufsize)
- goto fallback;
- }
-
- res = splice(ch ? ch->fd : se->fd,
- NULL, llp->pipe[1], NULL, bufsize, 0);
- err = errno;
-
- if (fuse_session_exited(se))
- return 0;
-
- if (res == -1) {
- if (err == ENODEV) {
- /* Filesystem was unmounted, or connection was aborted
- via /sys/fs/fuse/connections */
- fuse_session_exit(se);
- return 0;
- }
- if (err != EINTR && err != EAGAIN)
- perror("fuse: splice from device");
- return -err;
- }
-
- if (res < sizeof(struct fuse_in_header)) {
- fuse_log(FUSE_LOG_ERR, "short splice from fuse device\n");
- return -EIO;
- }
-
- tmpbuf = (struct fuse_buf) {
- .size = res,
- .flags = FUSE_BUF_IS_FD,
- .fd = llp->pipe[0],
- };
-
- /*
- * Don't bother with zero copy for small requests.
- * fuse_loop_mt() needs to check for FORGET so this more than
- * just an optimization.
- */
- if (res < sizeof(struct fuse_in_header) +
- sizeof(struct fuse_write_in) + pagesize) {
- struct fuse_bufvec src = { .buf[0] = tmpbuf, .count = 1 };
- struct fuse_bufvec dst = { .count = 1 };
-
- if (!buf->mem) {
- buf->mem = malloc(se->bufsize);
- if (!buf->mem) {
- fuse_log(FUSE_LOG_ERR,
- "fuse: failed to allocate read buffer\n");
- return -ENOMEM;
- }
- }
- buf->size = se->bufsize;
- buf->flags = 0;
- dst.buf[0] = *buf;
-
- res = fuse_buf_copy(&dst, &src, 0);
- if (res < 0) {
- fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: %s\n",
- strerror(-res));
- fuse_ll_clear_pipe(se);
- return res;
- }
- if (res < tmpbuf.size) {
- fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: short read\n");
- fuse_ll_clear_pipe(se);
- return -EIO;
- }
- assert(res == tmpbuf.size);
-
- } else {
- /* Don't overwrite buf->mem, as that would cause a leak */
- buf->fd = tmpbuf.fd;
- buf->flags = tmpbuf.flags;
- }
- buf->size = tmpbuf.size;
-
- return res;
-
-fallback:
-#endif
- if (!buf->mem) {
- buf->mem = malloc(se->bufsize);
- if (!buf->mem) {
- fuse_log(FUSE_LOG_ERR,
- "fuse: failed to allocate read buffer\n");
- return -ENOMEM;
- }
- }
-
-restart:
- res = read(ch ? ch->fd : se->fd, buf->mem, se->bufsize);
- err = errno;
-
- if (fuse_session_exited(se))
- return 0;
- if (res == -1) {
- /* ENOENT means the operation was interrupted, it's safe
- to restart */
- if (err == ENOENT)
- goto restart;
-
- if (err == ENODEV) {
- /* Filesystem was unmounted, or connection was aborted
- via /sys/fs/fuse/connections */
- fuse_session_exit(se);
- return 0;
- }
- /* Errors occurring during normal operation: EINTR (read
- interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem
- umounted) */
- if (err != EINTR && err != EAGAIN)
- perror("fuse: reading device");
- return -err;
- }
- if ((size_t) res < sizeof(struct fuse_in_header)) {
- fuse_log(FUSE_LOG_ERR, "short read on fuse device\n");
- return -EIO;
- }
-
- buf->size = res;
-
- return res;
-}
-
struct fuse_session *fuse_session_new(struct fuse_args *args,
const struct fuse_lowlevel_ops *op,
size_t op_size, void *userdata)
{
- int err;
struct fuse_session *se;
- struct mount_opts *mo;
if (sizeof(struct fuse_lowlevel_ops) < op_size) {
fuse_log(FUSE_LOG_ERR, "fuse: warning: library too old, some operations may not work\n");
@@ -2913,20 +2286,6 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
/* Parse options */
if(fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1)
goto out2;
- if(se->deny_others) {
- /* Allowing access only by root is done by instructing
- * kernel to allow access by everyone, and then restricting
- * access to root and mountpoint owner in libfuse.
- */
- // We may be adding the option a second time, but
- // that doesn't hurt.
- if(fuse_opt_add_arg(args, "-oallow_other") == -1)
- goto out2;
- }
- mo = parse_mount_opts(args);
- if (mo == NULL)
- goto out3;
-
if(args->argc == 1 &&
args->argv[0][0] == '-') {
fuse_log(FUSE_LOG_ERR, "fuse: warning: argv[0] looks like an option, but "
@@ -2940,9 +2299,6 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
goto out4;
}
- if (se->debug)
- fuse_log(FUSE_LOG_DEBUG, "FUSE library version: %s\n", PACKAGE_VERSION);
-
se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() +
FUSE_BUFFER_HEADER_SIZE;
@@ -2952,26 +2308,14 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
se->notify_ctr = 1;
fuse_mutex_init(&se->lock);
- err = pthread_key_create(&se->pipe_key, fuse_ll_pipe_destructor);
- if (err) {
- fuse_log(FUSE_LOG_ERR, "fuse: failed to create thread specific key: %s\n",
- strerror(err));
- goto out5;
- }
-
memcpy(&se->op, op, op_size);
se->owner = getuid();
se->userdata = userdata;
- se->mo = mo;
return se;
-out5:
- pthread_mutex_destroy(&se->lock);
out4:
fuse_opt_free_args(args);
-out3:
- free(mo);
out2:
free(se);
out1:
@@ -3035,11 +2379,6 @@ int fuse_session_fd(struct fuse_session *se)
void fuse_session_unmount(struct fuse_session *se)
{
- if (se->mountpoint != NULL) {
- fuse_kern_unmount(se->mountpoint, se->fd);
- free(se->mountpoint);
- se->mountpoint = NULL;
- }
}
#ifdef linux
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index 18c6363f07..6b1adfcfd1 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -31,10 +31,6 @@
#include <sys/statvfs.h>
#include <sys/uio.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* ----------------------------------------------------------- *
* Miscellaneous definitions *
* ----------------------------------------------------------- */
@@ -1863,14 +1859,12 @@ void fuse_cmdline_help(void);
* ----------------------------------------------------------- */
struct fuse_cmdline_opts {
- int singlethread;
int foreground;
int debug;
int nodefault_subtype;
char *mountpoint;
int show_version;
int show_help;
- int clone_fd;
unsigned int max_idle_threads;
};
@@ -1961,24 +1955,6 @@ int fuse_session_mount(struct fuse_session *se, const char *mountpoint);
*/
int fuse_session_loop(struct fuse_session *se);
-/**
- * Enter a multi-threaded event loop.
- *
- * For a description of the return value and the conditions when the
- * event loop exits, refer to the documentation of
- * fuse_session_loop().
- *
- * @param se the session
- * @param config session loop configuration
- * @return see fuse_session_loop()
- */
-#if FUSE_USE_VERSION < 32
-int fuse_session_loop_mt_31(struct fuse_session *se, int clone_fd);
-#define fuse_session_loop_mt(se, clone_fd) fuse_session_loop_mt_31(se, clone_fd)
-#else
-int fuse_session_loop_mt(struct fuse_session *se, struct fuse_loop_config *config);
-#endif
-
/**
* Flag a session as terminated.
*
@@ -2082,8 +2058,4 @@ void fuse_session_process_buf(struct fuse_session *se,
*/
int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf);
-#ifdef __cplusplus
-}
-#endif
-
#endif /* FUSE_LOWLEVEL_H_ */
diff --git a/tools/virtiofsd/fuse_opt.h b/tools/virtiofsd/fuse_opt.h
index d8573e74fd..69102555be 100644
--- a/tools/virtiofsd/fuse_opt.h
+++ b/tools/virtiofsd/fuse_opt.h
@@ -14,10 +14,6 @@
* This file defines the option parsing interface of FUSE
*/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/**
* Option description
*
@@ -264,8 +260,4 @@ void fuse_opt_free_args(struct fuse_args *args);
*/
int fuse_opt_match(const struct fuse_opt opts[], const char *opt);
-#ifdef __cplusplus
-}
-#endif
-
#endif /* FUSE_OPT_H_ */
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 64ff7ad6d5..5a2e64c6d0 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -41,14 +41,10 @@ static const struct fuse_opt fuse_helper_opts[] = {
FUSE_OPT_KEY("-d", FUSE_OPT_KEY_KEEP),
FUSE_OPT_KEY("debug", FUSE_OPT_KEY_KEEP),
FUSE_HELPER_OPT("-f", foreground),
- FUSE_HELPER_OPT("-s", singlethread),
FUSE_HELPER_OPT("fsname=", nodefault_subtype),
FUSE_OPT_KEY("fsname=", FUSE_OPT_KEY_KEEP),
-#ifndef __FreeBSD__
FUSE_HELPER_OPT("subtype=", nodefault_subtype),
FUSE_OPT_KEY("subtype=", FUSE_OPT_KEY_KEEP),
-#endif
- FUSE_HELPER_OPT("clone_fd", clone_fd),
FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),
FUSE_OPT_END
};
@@ -132,9 +128,6 @@ void fuse_cmdline_help(void)
" -V --version print version\n"
" -d -o debug enable debug output (implies -f)\n"
" -f foreground operation\n"
- " -s disable multi-threaded operation\n"
- " -o clone_fd use separate fuse device fd for each thread\n"
- " (may improve performance)\n"
" -o max_idle_threads the maximum number of idle worker threads\n"
" allowed (default: 10)\n");
}
@@ -171,34 +164,6 @@ static int fuse_helper_opt_proc(void *data, const char *arg, int key,
}
}
-/* Under FreeBSD, there is no subtype option so this
- function actually sets the fsname */
-static int add_default_subtype(const char *progname, struct fuse_args *args)
-{
- int res;
- char *subtype_opt;
-
- const char *basename = strrchr(progname, '/');
- if (basename == NULL)
- basename = progname;
- else if (basename[1] != '\0')
- basename++;
-
- subtype_opt = (char *) malloc(strlen(basename) + 64);
- if (subtype_opt == NULL) {
- fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");
- return -1;
- }
-#ifdef __FreeBSD__
- sprintf(subtype_opt, "-ofsname=%s", basename);
-#else
- sprintf(subtype_opt, "-osubtype=%s", basename);
-#endif
- res = fuse_opt_add_arg(args, subtype_opt);
- free(subtype_opt);
- return res;
-}
-
int fuse_parse_cmdline(struct fuse_args *args,
struct fuse_cmdline_opts *opts)
{
@@ -210,14 +175,6 @@ int fuse_parse_cmdline(struct fuse_args *args,
fuse_helper_opt_proc) == -1)
return -1;
- /* *Linux*: if neither -o subtype nor -o fsname are specified,
- set subtype to program's basename.
- *FreeBSD*: if fsname is not specified, set to program's
- basename. */
- if (!opts->nodefault_subtype)
- if (add_default_subtype(args->argv[0], args) == -1)
- return -1;
-
return 0;
}
@@ -276,88 +233,6 @@ int fuse_daemonize(int foreground)
return 0;
}
-int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
- size_t op_size, void *user_data)
-{
- struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
- struct fuse *fuse;
- struct fuse_cmdline_opts opts;
- int res;
-
- if (fuse_parse_cmdline(&args, &opts) != 0)
- return 1;
-
- if (opts.show_version) {
- printf("FUSE library version %s\n", PACKAGE_VERSION);
- fuse_lowlevel_version();
- res = 0;
- goto out1;
- }
-
- if (opts.show_help) {
- if(args.argv[0][0] != '\0')
- printf("usage: %s [options] <mountpoint>\n\n",
- args.argv[0]);
- printf("FUSE options:\n");
- fuse_cmdline_help();
- fuse_lib_help(&args);
- res = 0;
- goto out1;
- }
-
- if (!opts.show_help &&
- !opts.mountpoint) {
- fuse_log(FUSE_LOG_ERR, "error: no mountpoint specified\n");
- res = 2;
- goto out1;
- }
-
-
- fuse = fuse_new_31(&args, op, op_size, user_data);
- if (fuse == NULL) {
- res = 3;
- goto out1;
- }
-
- if (fuse_mount(fuse,opts.mountpoint) != 0) {
- res = 4;
- goto out2;
- }
-
- if (fuse_daemonize(opts.foreground) != 0) {
- res = 5;
- goto out3;
- }
-
- struct fuse_session *se = fuse_get_session(fuse);
- if (fuse_set_signal_handlers(se) != 0) {
- res = 6;
- goto out3;
- }
-
- if (opts.singlethread)
- res = fuse_loop(fuse);
- else {
- struct fuse_loop_config loop_config;
- loop_config.clone_fd = opts.clone_fd;
- loop_config.max_idle_threads = opts.max_idle_threads;
- res = fuse_loop_mt_32(fuse, &loop_config);
- }
- if (res)
- res = 7;
-
- fuse_remove_signal_handlers(se);
-out3:
- fuse_unmount(fuse);
-out2:
- fuse_destroy(fuse);
-out1:
- free(opts.mountpoint);
- fuse_opt_free_args(&args);
- return res;
-}
-
-
void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts,
struct fuse_conn_info *conn)
{
@@ -420,21 +295,3 @@ struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args)
}
return opts;
}
-
-int fuse_open_channel(const char *mountpoint, const char* options)
-{
- struct mount_opts *opts = NULL;
- int fd = -1;
- const char *argv[] = { "", "-o", options };
- int argc = sizeof(argv) / sizeof(argv[0]);
- struct fuse_args args = FUSE_ARGS_INIT(argc, (char**) argv);
-
- opts = parse_mount_opts(&args);
- if (opts == NULL)
- return -1;
-
- fd = fuse_kern_mount(mountpoint, opts);
- destroy_mount_opts(opts);
-
- return fd;
-}
diff --git a/tools/virtiofsd/passthrough_helpers.h b/tools/virtiofsd/passthrough_helpers.h
index 6b77c33600..7c5f561fbc 100644
--- a/tools/virtiofsd/passthrough_helpers.h
+++ b/tools/virtiofsd/passthrough_helpers.h
@@ -42,32 +42,6 @@ static int mknod_wrapper(int dirfd, const char *path, const char *link,
res = symlinkat(link, dirfd, path);
} else if (S_ISFIFO(mode)) {
res = mkfifoat(dirfd, path, mode);
-#ifdef __FreeBSD__
- } else if (S_ISSOCK(mode)) {
- struct sockaddr_un su;
- int fd;
-
- if (strlen(path) >= sizeof(su.sun_path)) {
- errno = ENAMETOOLONG;
- return -1;
- }
- fd = socket(AF_UNIX, SOCK_STREAM, 0);
- if (fd >= 0) {
- /*
- * We must bind the socket to the underlying file
- * system to create the socket file, even though
- * we'll never listen on this socket.
- */
- su.sun_family = AF_UNIX;
- strncpy(su.sun_path, path, sizeof(su.sun_path));
- res = bindat(dirfd, fd, (struct sockaddr*)&su,
- sizeof(su));
- if (res == 0)
- close(fd);
- } else {
- res = -1;
- }
-#endif
} else {
res = mknodat(dirfd, path, mode, rdev);
}
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index e1a605691a..e5f7115bc1 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1240,7 +1240,6 @@ int main(int argc, char *argv[])
ret = 0;
goto err_out1;
} else if (opts.show_version) {
- printf("FUSE library version %s\n", fuse_pkgversion());
fuse_lowlevel_version();
ret = 0;
goto err_out1;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 007/108] virtiofsd: Format imported files to qemu style
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (5 preceding siblings ...)
2020-01-23 16:44 ` [PULL 006/108] virtiofsd: Trim down imported files Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 008/108] virtiofsd: remove mountpoint dummy argument Dr. David Alan Gilbert (git)
` (102 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Mostly using a set like:
indent -nut -i 4 -nlp -br -cs -ce --no-space-after-function-call-names file
clang-format -style=file -i -- file
clang-tidy -fix-errors -checks=readability-braces-around-statements file
clang-format -style=file -i -- file
With manual cleanups.
The .clang-format used is below.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed by: Aleksandar Markovic <amarkovic@wavecomp.com>
Language: Cpp
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false # although we like it, it creates churn
AlignConsecutiveDeclarations: false
AlignEscapedNewlinesLeft: true
AlignOperands: true
AlignTrailingComments: false # churn
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterReturnType: None # AlwaysBreakAfterDefinitionReturnType is taken into account
AlwaysBreakBeforeMultilineStrings: false
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterControlStatement: false
AfterEnum: false
AfterFunction: true
AfterStruct: false
AfterUnion: false
BeforeElse: false
IndentBraces: false
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
BreakBeforeTernaryOperators: false
BreakStringLiterals: true
ColumnLimit: 80
ContinuationIndentWidth: 4
Cpp11BracedListStyle: false
DerivePointerAlignment: false
DisableFormat: false
ForEachMacros: [
'CPU_FOREACH',
'CPU_FOREACH_REVERSE',
'CPU_FOREACH_SAFE',
'IOMMU_NOTIFIER_FOREACH',
'QLIST_FOREACH',
'QLIST_FOREACH_ENTRY',
'QLIST_FOREACH_RCU',
'QLIST_FOREACH_SAFE',
'QLIST_FOREACH_SAFE_RCU',
'QSIMPLEQ_FOREACH',
'QSIMPLEQ_FOREACH_SAFE',
'QSLIST_FOREACH',
'QSLIST_FOREACH_SAFE',
'QTAILQ_FOREACH',
'QTAILQ_FOREACH_REVERSE',
'QTAILQ_FOREACH_SAFE',
'QTAILQ_RAW_FOREACH',
'RAMBLOCK_FOREACH'
]
IncludeCategories:
- Regex: '^"qemu/osdep.h'
Priority: -3
- Regex: '^"(block|chardev|crypto|disas|exec|fpu|hw|io|libdecnumber|migration|monitor|net|qapi|qemu|qom|standard-headers|sysemu|ui)/'
Priority: -2
- Regex: '^"(elf.h|qemu-common.h|glib-compat.h|qemu-io.h|trace-tcg.h)'
Priority: -1
- Regex: '.*'
Priority: 1
IncludeIsMainRegex: '$'
IndentCaseLabels: false
IndentWidth: 4
IndentWrappedFunctionNames: false
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: '.*_BEGIN$' # only PREC_BEGIN ?
MacroBlockEnd: '.*_END$'
MaxEmptyLinesToKeep: 2
PointerAlignment: Right
ReflowComments: true
SortIncludes: true
SpaceAfterCStyleCast: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInContainerLiterals: true
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Auto
UseTab: Never
...
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/buffer.c | 434 +--
tools/virtiofsd/fuse.h | 1572 +++++------
tools/virtiofsd/fuse_common.h | 730 ++---
tools/virtiofsd/fuse_i.h | 121 +-
tools/virtiofsd/fuse_log.c | 38 +-
tools/virtiofsd/fuse_log.h | 32 +-
tools/virtiofsd/fuse_lowlevel.c | 3638 +++++++++++++------------
tools/virtiofsd/fuse_lowlevel.h | 2392 ++++++++--------
tools/virtiofsd/fuse_misc.h | 30 +-
tools/virtiofsd/fuse_opt.c | 659 ++---
tools/virtiofsd/fuse_opt.h | 79 +-
tools/virtiofsd/fuse_signals.c | 118 +-
tools/virtiofsd/helper.c | 506 ++--
tools/virtiofsd/passthrough_helpers.h | 33 +-
tools/virtiofsd/passthrough_ll.c | 2061 +++++++-------
15 files changed, 6382 insertions(+), 6061 deletions(-)
diff --git a/tools/virtiofsd/buffer.c b/tools/virtiofsd/buffer.c
index aefb7dbf15..5df946c82c 100644
--- a/tools/virtiofsd/buffer.c
+++ b/tools/virtiofsd/buffer.c
@@ -1,252 +1,272 @@
/*
- 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
-*/
+ * 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 <assert.h>
+#include <errno.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;
+ 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;
+ 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)
+ 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;
+ 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)
+ 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;
+ 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)
+ 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;
+ 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;
}
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)
+ 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 {
- return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
- }
+ 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 {
+ return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
+ }
}
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;
+ 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;
+ 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)
+ 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;
+ 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.h b/tools/virtiofsd/fuse.h
index 3202fba6bb..7a4c713559 100644
--- a/tools/virtiofsd/fuse.h
+++ b/tools/virtiofsd/fuse.h
@@ -1,15 +1,15 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB.
-*/
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB.
+ */
#ifndef FUSE_H_
#define FUSE_H_
-/** @file
+/*
*
* This file defines the library interface of FUSE
*
@@ -19,15 +19,15 @@
#include "fuse_common.h"
#include <fcntl.h>
-#include <time.h>
-#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
+#include <sys/types.h>
#include <sys/uio.h>
+#include <time.h>
-/* ----------------------------------------------------------- *
- * Basic FUSE API *
- * ----------------------------------------------------------- */
+/*
+ * Basic FUSE API
+ */
/** Handle for a FUSE filesystem */
struct fuse;
@@ -36,38 +36,39 @@ struct fuse;
* Readdir flags, passed to ->readdir()
*/
enum fuse_readdir_flags {
- /**
- * "Plus" mode.
- *
- * The kernel wants to prefill the inode cache during readdir. The
- * filesystem may honour this by filling in the attributes and setting
- * FUSE_FILL_DIR_FLAGS for the filler function. The filesystem may also
- * just ignore this flag completely.
- */
- FUSE_READDIR_PLUS = (1 << 0),
+ /**
+ * "Plus" mode.
+ *
+ * The kernel wants to prefill the inode cache during readdir. The
+ * filesystem may honour this by filling in the attributes and setting
+ * FUSE_FILL_DIR_FLAGS for the filler function. The filesystem may also
+ * just ignore this flag completely.
+ */
+ FUSE_READDIR_PLUS = (1 << 0),
};
enum fuse_fill_dir_flags {
- /**
- * "Plus" mode: all file attributes are valid
- *
- * The attributes are used by the kernel to prefill the inode cache
- * during a readdir.
- *
- * It is okay to set FUSE_FILL_DIR_PLUS if FUSE_READDIR_PLUS is not set
- * and vice versa.
- */
- FUSE_FILL_DIR_PLUS = (1 << 1),
+ /**
+ * "Plus" mode: all file attributes are valid
+ *
+ * The attributes are used by the kernel to prefill the inode cache
+ * during a readdir.
+ *
+ * It is okay to set FUSE_FILL_DIR_PLUS if FUSE_READDIR_PLUS is not set
+ * and vice versa.
+ */
+ FUSE_FILL_DIR_PLUS = (1 << 1),
};
-/** Function to add an entry in a readdir() operation
+/**
+ * Function to add an entry in a readdir() operation
*
* The *off* parameter can be any non-zero value that enables the
* filesystem to identify the current point in the directory
* stream. It does not need to be the actual physical position. A
* value of zero is reserved to indicate that seeking in directories
* is not supported.
- *
+ *
* @param buf the buffer passed to the readdir() operation
* @param name the file name of the directory entry
* @param stat file attributes, can be NULL
@@ -75,9 +76,9 @@ enum fuse_fill_dir_flags {
* @param flags fill flags
* @return 1 if buffer is full, zero otherwise
*/
-typedef int (*fuse_fill_dir_t) (void *buf, const char *name,
- const struct stat *stbuf, off_t off,
- enum fuse_fill_dir_flags flags);
+typedef int (*fuse_fill_dir_t)(void *buf, const char *name,
+ const struct stat *stbuf, off_t off,
+ enum fuse_fill_dir_flags flags);
/**
* Configuration of the high-level API
*
@@ -87,186 +88,186 @@ typedef int (*fuse_fill_dir_t) (void *buf, const char *name,
* file system implementation.
*/
struct fuse_config {
- /**
- * If `set_gid` is non-zero, the st_gid attribute of each file
- * is overwritten with the value of `gid`.
- */
- int set_gid;
- unsigned int gid;
-
- /**
- * If `set_uid` is non-zero, the st_uid attribute of each file
- * is overwritten with the value of `uid`.
- */
- int set_uid;
- unsigned int uid;
-
- /**
- * If `set_mode` is non-zero, the any permissions bits set in
- * `umask` are unset in the st_mode attribute of each file.
- */
- int set_mode;
- unsigned int umask;
-
- /**
- * The timeout in seconds for which name lookups will be
- * cached.
- */
- double entry_timeout;
-
- /**
- * The timeout in seconds for which a negative lookup will be
- * cached. This means, that if file did not exist (lookup
- * retuned ENOENT), the lookup will only be redone after the
- * timeout, and the file/directory will be assumed to not
- * exist until then. A value of zero means that negative
- * lookups are not cached.
- */
- double negative_timeout;
-
- /**
- * The timeout in seconds for which file/directory attributes
- * (as returned by e.g. the `getattr` handler) are cached.
- */
- double attr_timeout;
-
- /**
- * Allow requests to be interrupted
- */
- int intr;
-
- /**
- * Specify which signal number to send to the filesystem when
- * a request is interrupted. The default is hardcoded to
- * USR1.
- */
- int intr_signal;
-
- /**
- * Normally, FUSE assigns inodes to paths only for as long as
- * the kernel is aware of them. With this option inodes are
- * instead remembered for at least this many seconds. This
- * will require more memory, but may be necessary when using
- * applications that make use of inode numbers.
- *
- * A number of -1 means that inodes will be remembered for the
- * entire life-time of the file-system process.
- */
- int remember;
-
- /**
- * The default behavior is that if an open file is deleted,
- * the file is renamed to a hidden file (.fuse_hiddenXXX), and
- * only removed when the file is finally released. This
- * relieves the filesystem implementation of having to deal
- * with this problem. This option disables the hiding
- * behavior, and files are removed immediately in an unlink
- * operation (or in a rename operation which overwrites an
- * existing file).
- *
- * It is recommended that you not use the hard_remove
- * option. When hard_remove is set, the following libc
- * functions fail on unlinked files (returning errno of
- * ENOENT): read(2), write(2), fsync(2), close(2), f*xattr(2),
- * ftruncate(2), fstat(2), fchmod(2), fchown(2)
- */
- int hard_remove;
-
- /**
- * Honor the st_ino field in the functions getattr() and
- * fill_dir(). This value is used to fill in the st_ino field
- * in the stat(2), lstat(2), fstat(2) functions and the d_ino
- * field in the readdir(2) function. The filesystem does not
- * have to guarantee uniqueness, however some applications
- * rely on this value being unique for the whole filesystem.
- *
- * Note that this does *not* affect the inode that libfuse
- * and the kernel use internally (also called the "nodeid").
- */
- int use_ino;
-
- /**
- * If use_ino option is not given, still try to fill in the
- * d_ino field in readdir(2). If the name was previously
- * looked up, and is still in the cache, the inode number
- * found there will be used. Otherwise it will be set to -1.
- * If use_ino option is given, this option is ignored.
- */
- int readdir_ino;
-
- /**
- * This option disables the use of page cache (file content cache)
- * in the kernel for this filesystem. This has several affects:
- *
- * 1. Each read(2) or write(2) system call will initiate one
- * or more read or write operations, data will not be
- * cached in the kernel.
- *
- * 2. The return value of the read() and write() system calls
- * will correspond to the return values of the read and
- * write operations. This is useful for example if the
- * file size is not known in advance (before reading it).
- *
- * Internally, enabling this option causes fuse to set the
- * `direct_io` field of `struct fuse_file_info` - overwriting
- * any value that was put there by the file system.
- */
- int direct_io;
-
- /**
- * This option disables flushing the cache of the file
- * contents on every open(2). This should only be enabled on
- * filesystems where the file data is never changed
- * externally (not through the mounted FUSE filesystem). Thus
- * it is not suitable for network filesystems and other
- * intermediate filesystems.
- *
- * NOTE: if this option is not specified (and neither
- * direct_io) data is still cached after the open(2), so a
- * read(2) system call will not always initiate a read
- * operation.
- *
- * Internally, enabling this option causes fuse to set the
- * `keep_cache` field of `struct fuse_file_info` - overwriting
- * any value that was put there by the file system.
- */
- int kernel_cache;
-
- /**
- * This option is an alternative to `kernel_cache`. Instead of
- * unconditionally keeping cached data, the cached data is
- * invalidated on open(2) if if the modification time or the
- * size of the file has changed since it was last opened.
- */
- int auto_cache;
-
- /**
- * The timeout in seconds for which file attributes are cached
- * for the purpose of checking if auto_cache should flush the
- * file data on open.
- */
- int ac_attr_timeout_set;
- double ac_attr_timeout;
-
- /**
- * If this option is given the file-system handlers for the
- * following operations will not receive path information:
- * read, write, flush, release, fsync, readdir, releasedir,
- * fsyncdir, lock, ioctl and poll.
- *
- * For the truncate, getattr, chmod, chown and utimens
- * operations the path will be provided only if the struct
- * fuse_file_info argument is NULL.
- */
- int nullpath_ok;
-
- /**
- * The remaining options are used by libfuse internally and
- * should not be touched.
- */
- int show_help;
- char *modules;
- int debug;
+ /**
+ * If `set_gid` is non-zero, the st_gid attribute of each file
+ * is overwritten with the value of `gid`.
+ */
+ int set_gid;
+ unsigned int gid;
+
+ /**
+ * If `set_uid` is non-zero, the st_uid attribute of each file
+ * is overwritten with the value of `uid`.
+ */
+ int set_uid;
+ unsigned int uid;
+
+ /**
+ * If `set_mode` is non-zero, the any permissions bits set in
+ * `umask` are unset in the st_mode attribute of each file.
+ */
+ int set_mode;
+ unsigned int umask;
+
+ /**
+ * The timeout in seconds for which name lookups will be
+ * cached.
+ */
+ double entry_timeout;
+
+ /**
+ * The timeout in seconds for which a negative lookup will be
+ * cached. This means, that if file did not exist (lookup
+ * retuned ENOENT), the lookup will only be redone after the
+ * timeout, and the file/directory will be assumed to not
+ * exist until then. A value of zero means that negative
+ * lookups are not cached.
+ */
+ double negative_timeout;
+
+ /**
+ * The timeout in seconds for which file/directory attributes
+ * (as returned by e.g. the `getattr` handler) are cached.
+ */
+ double attr_timeout;
+
+ /**
+ * Allow requests to be interrupted
+ */
+ int intr;
+
+ /**
+ * Specify which signal number to send to the filesystem when
+ * a request is interrupted. The default is hardcoded to
+ * USR1.
+ */
+ int intr_signal;
+
+ /**
+ * Normally, FUSE assigns inodes to paths only for as long as
+ * the kernel is aware of them. With this option inodes are
+ * instead remembered for at least this many seconds. This
+ * will require more memory, but may be necessary when using
+ * applications that make use of inode numbers.
+ *
+ * A number of -1 means that inodes will be remembered for the
+ * entire life-time of the file-system process.
+ */
+ int remember;
+
+ /**
+ * The default behavior is that if an open file is deleted,
+ * the file is renamed to a hidden file (.fuse_hiddenXXX), and
+ * only removed when the file is finally released. This
+ * relieves the filesystem implementation of having to deal
+ * with this problem. This option disables the hiding
+ * behavior, and files are removed immediately in an unlink
+ * operation (or in a rename operation which overwrites an
+ * existing file).
+ *
+ * It is recommended that you not use the hard_remove
+ * option. When hard_remove is set, the following libc
+ * functions fail on unlinked files (returning errno of
+ * ENOENT): read(2), write(2), fsync(2), close(2), f*xattr(2),
+ * ftruncate(2), fstat(2), fchmod(2), fchown(2)
+ */
+ int hard_remove;
+
+ /**
+ * Honor the st_ino field in the functions getattr() and
+ * fill_dir(). This value is used to fill in the st_ino field
+ * in the stat(2), lstat(2), fstat(2) functions and the d_ino
+ * field in the readdir(2) function. The filesystem does not
+ * have to guarantee uniqueness, however some applications
+ * rely on this value being unique for the whole filesystem.
+ *
+ * Note that this does *not* affect the inode that libfuse
+ * and the kernel use internally (also called the "nodeid").
+ */
+ int use_ino;
+
+ /**
+ * If use_ino option is not given, still try to fill in the
+ * d_ino field in readdir(2). If the name was previously
+ * looked up, and is still in the cache, the inode number
+ * found there will be used. Otherwise it will be set to -1.
+ * If use_ino option is given, this option is ignored.
+ */
+ int readdir_ino;
+
+ /**
+ * This option disables the use of page cache (file content cache)
+ * in the kernel for this filesystem. This has several affects:
+ *
+ * 1. Each read(2) or write(2) system call will initiate one
+ * or more read or write operations, data will not be
+ * cached in the kernel.
+ *
+ * 2. The return value of the read() and write() system calls
+ * will correspond to the return values of the read and
+ * write operations. This is useful for example if the
+ * file size is not known in advance (before reading it).
+ *
+ * Internally, enabling this option causes fuse to set the
+ * `direct_io` field of `struct fuse_file_info` - overwriting
+ * any value that was put there by the file system.
+ */
+ int direct_io;
+
+ /**
+ * This option disables flushing the cache of the file
+ * contents on every open(2). This should only be enabled on
+ * filesystems where the file data is never changed
+ * externally (not through the mounted FUSE filesystem). Thus
+ * it is not suitable for network filesystems and other
+ * intermediate filesystems.
+ *
+ * NOTE: if this option is not specified (and neither
+ * direct_io) data is still cached after the open(2), so a
+ * read(2) system call will not always initiate a read
+ * operation.
+ *
+ * Internally, enabling this option causes fuse to set the
+ * `keep_cache` field of `struct fuse_file_info` - overwriting
+ * any value that was put there by the file system.
+ */
+ int kernel_cache;
+
+ /**
+ * This option is an alternative to `kernel_cache`. Instead of
+ * unconditionally keeping cached data, the cached data is
+ * invalidated on open(2) if if the modification time or the
+ * size of the file has changed since it was last opened.
+ */
+ int auto_cache;
+
+ /**
+ * The timeout in seconds for which file attributes are cached
+ * for the purpose of checking if auto_cache should flush the
+ * file data on open.
+ */
+ int ac_attr_timeout_set;
+ double ac_attr_timeout;
+
+ /**
+ * If this option is given the file-system handlers for the
+ * following operations will not receive path information:
+ * read, write, flush, release, fsync, readdir, releasedir,
+ * fsyncdir, lock, ioctl and poll.
+ *
+ * For the truncate, getattr, chmod, chown and utimens
+ * operations the path will be provided only if the struct
+ * fuse_file_info argument is NULL.
+ */
+ int nullpath_ok;
+
+ /**
+ * The remaining options are used by libfuse internally and
+ * should not be touched.
+ */
+ int show_help;
+ char *modules;
+ int debug;
};
@@ -293,515 +294,535 @@ struct fuse_config {
* Almost all operations take a path which can be of any length.
*/
struct fuse_operations {
- /** Get file attributes.
- *
- * Similar to stat(). The 'st_dev' and 'st_blksize' fields are
- * ignored. The 'st_ino' field is ignored except if the 'use_ino'
- * mount option is given. In that case it is passed to userspace,
- * but libfuse and the kernel will still assign a different
- * inode for internal use (called the "nodeid").
- *
- * `fi` will always be NULL if the file is not currently open, but
- * may also be NULL if the file is open.
- */
- int (*getattr) (const char *, struct stat *, struct fuse_file_info *fi);
-
- /** Read the target of a symbolic link
- *
- * The buffer should be filled with a null terminated string. The
- * buffer size argument includes the space for the terminating
- * null character. If the linkname is too long to fit in the
- * buffer, it should be truncated. The return value should be 0
- * for success.
- */
- int (*readlink) (const char *, char *, size_t);
-
- /** Create a file node
- *
- * This is called for creation of all non-directory, non-symlink
- * nodes. If the filesystem defines a create() method, then for
- * regular files that will be called instead.
- */
- int (*mknod) (const char *, mode_t, dev_t);
-
- /** Create a directory
- *
- * Note that the mode argument may not have the type specification
- * bits set, i.e. S_ISDIR(mode) can be false. To obtain the
- * correct directory type bits use mode|S_IFDIR
- * */
- int (*mkdir) (const char *, mode_t);
-
- /** Remove a file */
- int (*unlink) (const char *);
-
- /** Remove a directory */
- int (*rmdir) (const char *);
-
- /** Create a symbolic link */
- int (*symlink) (const char *, const char *);
-
- /** Rename a file
- *
- * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If
- * RENAME_NOREPLACE is specified, the filesystem must not
- * overwrite *newname* if it exists and return an error
- * instead. If `RENAME_EXCHANGE` is specified, the filesystem
- * must atomically exchange the two files, i.e. both must
- * exist and neither may be deleted.
- */
- int (*rename) (const char *, const char *, unsigned int flags);
-
- /** Create a hard link to a file */
- int (*link) (const char *, const char *);
-
- /** Change the permission bits of a file
- *
- * `fi` will always be NULL if the file is not currenlty open, but
- * may also be NULL if the file is open.
- */
- int (*chmod) (const char *, mode_t, struct fuse_file_info *fi);
-
- /** Change the owner and group of a file
- *
- * `fi` will always be NULL if the file is not currenlty open, but
- * may also be NULL if the file is open.
- *
- * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
- * expected to reset the setuid and setgid bits.
- */
- int (*chown) (const char *, uid_t, gid_t, struct fuse_file_info *fi);
-
- /** Change the size of a file
- *
- * `fi` will always be NULL if the file is not currenlty open, but
- * may also be NULL if the file is open.
- *
- * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
- * expected to reset the setuid and setgid bits.
- */
- int (*truncate) (const char *, off_t, struct fuse_file_info *fi);
-
- /** Open a file
- *
- * Open flags are available in fi->flags. The following rules
- * apply.
- *
- * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be
- * filtered out / handled by the kernel.
- *
- * - Access modes (O_RDONLY, O_WRONLY, O_RDWR, O_EXEC, O_SEARCH)
- * should be used by the filesystem to check if the operation is
- * permitted. If the ``-o default_permissions`` mount option is
- * given, this check is already done by the kernel before calling
- * open() and may thus be omitted by the filesystem.
- *
- * - When writeback caching is enabled, the kernel may send
- * read requests even for files opened with O_WRONLY. The
- * filesystem should be prepared to handle this.
- *
- * - When writeback caching is disabled, the filesystem is
- * expected to properly handle the O_APPEND flag and ensure
- * that each write is appending to the end of the file.
- *
- * - When writeback caching is enabled, the kernel will
- * handle O_APPEND. However, unless all changes to the file
- * come through the kernel this will not work reliably. The
- * filesystem should thus either ignore the O_APPEND flag
- * (and let the kernel handle it), or return an error
- * (indicating that reliably O_APPEND is not available).
- *
- * Filesystem may store an arbitrary file handle (pointer,
- * index, etc) in fi->fh, and use this in other all other file
- * operations (read, write, flush, release, fsync).
- *
- * Filesystem may also implement stateless file I/O and not store
- * anything in fi->fh.
- *
- * There are also some flags (direct_io, keep_cache) which the
- * filesystem may set in fi, to change the way the file is opened.
- * See fuse_file_info structure in <fuse_common.h> for more details.
- *
- * If this request is answered with an error code of ENOSYS
- * and FUSE_CAP_NO_OPEN_SUPPORT is set in
- * `fuse_conn_info.capable`, this is treated as success and
- * future calls to open will also succeed without being send
- * to the filesystem process.
- *
- */
- int (*open) (const char *, struct fuse_file_info *);
-
- /** Read data from an open file
- *
- * Read should return exactly the number of bytes requested except
- * on EOF or error, otherwise the rest of the data will be
- * substituted with zeroes. An exception to this is when the
- * 'direct_io' mount option is specified, in which case the return
- * value of the read system call will reflect the return value of
- * this operation.
- */
- int (*read) (const char *, char *, size_t, off_t,
- struct fuse_file_info *);
-
- /** Write data to an open file
- *
- * Write should return exactly the number of bytes requested
- * except on error. An exception to this is when the 'direct_io'
- * mount option is specified (see read operation).
- *
- * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
- * expected to reset the setuid and setgid bits.
- */
- int (*write) (const char *, const char *, size_t, off_t,
- struct fuse_file_info *);
-
- /** Get file system statistics
- *
- * The 'f_favail', 'f_fsid' and 'f_flag' fields are ignored
- */
- int (*statfs) (const char *, struct statvfs *);
-
- /** Possibly flush cached data
- *
- * BIG NOTE: This is not equivalent to fsync(). It's not a
- * request to sync dirty data.
- *
- * Flush is called on each close() of a file descriptor, as opposed to
- * release which is called on the close of the last file descriptor for
- * a file. Under Linux, errors returned by flush() will be passed to
- * userspace as errors from close(), so flush() is a good place to write
- * back any cached dirty data. However, many applications ignore errors
- * on close(), and on non-Linux systems, close() may succeed even if flush()
- * returns an error. For these reasons, filesystems should not assume
- * that errors returned by flush will ever be noticed or even
- * delivered.
- *
- * NOTE: The flush() method may be called more than once for each
- * open(). This happens if more than one file descriptor refers to an
- * open file handle, e.g. due to dup(), dup2() or fork() calls. It is
- * not possible to determine if a flush is final, so each flush should
- * be treated equally. Multiple write-flush sequences are relatively
- * rare, so this shouldn't be a problem.
- *
- * Filesystems shouldn't assume that flush will be called at any
- * particular point. It may be called more times than expected, or not
- * at all.
- *
- * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
- */
- int (*flush) (const char *, struct fuse_file_info *);
-
- /** Release an open file
- *
- * Release is called when there are no more references to an open
- * file: all file descriptors are closed and all memory mappings
- * are unmapped.
- *
- * For every open() call there will be exactly one release() call
- * with the same flags and file handle. It is possible to
- * have a file opened more than once, in which case only the last
- * release will mean, that no more reads/writes will happen on the
- * file. The return value of release is ignored.
- */
- int (*release) (const char *, struct fuse_file_info *);
-
- /** Synchronize file contents
- *
- * If the datasync parameter is non-zero, then only the user data
- * should be flushed, not the meta data.
- */
- int (*fsync) (const char *, int, struct fuse_file_info *);
-
- /** Set extended attributes */
- int (*setxattr) (const char *, const char *, const char *, size_t, int);
-
- /** Get extended attributes */
- int (*getxattr) (const char *, const char *, char *, size_t);
-
- /** List extended attributes */
- int (*listxattr) (const char *, char *, size_t);
-
- /** Remove extended attributes */
- int (*removexattr) (const char *, const char *);
-
- /** Open directory
- *
- * Unless the 'default_permissions' mount option is given,
- * this method should check if opendir is permitted for this
- * directory. Optionally opendir may also return an arbitrary
- * filehandle in the fuse_file_info structure, which will be
- * passed to readdir, releasedir and fsyncdir.
- */
- int (*opendir) (const char *, struct fuse_file_info *);
-
- /** Read directory
- *
- * The filesystem may choose between two modes of operation:
- *
- * 1) The readdir implementation ignores the offset parameter, and
- * passes zero to the filler function's offset. The filler
- * function will not return '1' (unless an error happens), so the
- * whole directory is read in a single readdir operation.
- *
- * 2) The readdir implementation keeps track of the offsets of the
- * directory entries. It uses the offset parameter and always
- * passes non-zero offset to the filler function. When the buffer
- * is full (or an error happens) the filler function will return
- * '1'.
- */
- int (*readdir) (const char *, void *, fuse_fill_dir_t, off_t,
- struct fuse_file_info *, enum fuse_readdir_flags);
-
- /** Release directory
- */
- int (*releasedir) (const char *, struct fuse_file_info *);
-
- /** Synchronize directory contents
- *
- * If the datasync parameter is non-zero, then only the user data
- * should be flushed, not the meta data
- */
- int (*fsyncdir) (const char *, int, struct fuse_file_info *);
-
- /**
- * Initialize filesystem
- *
- * The return value will passed in the `private_data` field of
- * `struct fuse_context` to all file operations, and as a
- * parameter to the destroy() method. It overrides the initial
- * value provided to fuse_main() / fuse_new().
- */
- void *(*init) (struct fuse_conn_info *conn,
- struct fuse_config *cfg);
-
- /**
- * Clean up filesystem
- *
- * Called on filesystem exit.
- */
- void (*destroy) (void *private_data);
-
- /**
- * Check file access permissions
- *
- * This will be called for the access() system call. If the
- * 'default_permissions' mount option is given, this method is not
- * called.
- *
- * This method is not called under Linux kernel versions 2.4.x
- */
- int (*access) (const char *, int);
-
- /**
- * Create and open a file
- *
- * If the file does not exist, first create it with the specified
- * mode, and then open it.
- *
- * If this method is not implemented or under Linux kernel
- * versions earlier than 2.6.15, the mknod() and open() methods
- * will be called instead.
- */
- int (*create) (const char *, mode_t, struct fuse_file_info *);
-
- /**
- * Perform POSIX file locking operation
- *
- * The cmd argument will be either F_GETLK, F_SETLK or F_SETLKW.
- *
- * For the meaning of fields in 'struct flock' see the man page
- * for fcntl(2). The l_whence field will always be set to
- * SEEK_SET.
- *
- * For checking lock ownership, the 'fuse_file_info->owner'
- * argument must be used.
- *
- * For F_GETLK operation, the library will first check currently
- * held locks, and if a conflicting lock is found it will return
- * information without calling this method. This ensures, that
- * for local locks the l_pid field is correctly filled in. The
- * results may not be accurate in case of race conditions and in
- * the presence of hard links, but it's unlikely that an
- * application would rely on accurate GETLK results in these
- * cases. If a conflicting lock is not found, this method will be
- * called, and the filesystem may fill out l_pid by a meaningful
- * value, or it may leave this field zero.
- *
- * For F_SETLK and F_SETLKW the l_pid field will be set to the pid
- * of the process performing the locking operation.
- *
- * Note: if this method is not implemented, the kernel will still
- * allow file locking to work locally. Hence it is only
- * interesting for network filesystems and similar.
- */
- int (*lock) (const char *, struct fuse_file_info *, int cmd,
- struct flock *);
-
- /**
- * Change the access and modification times of a file with
- * nanosecond resolution
- *
- * This supersedes the old utime() interface. New applications
- * should use this.
- *
- * `fi` will always be NULL if the file is not currenlty open, but
- * may also be NULL if the file is open.
- *
- * See the utimensat(2) man page for details.
- */
- int (*utimens) (const char *, const struct timespec tv[2],
- struct fuse_file_info *fi);
-
- /**
- * Map block index within file to block index within device
- *
- * Note: This makes sense only for block device backed filesystems
- * mounted with the 'blkdev' option
- */
- int (*bmap) (const char *, size_t blocksize, uint64_t *idx);
-
- /**
- * Ioctl
- *
- * flags will have FUSE_IOCTL_COMPAT set for 32bit ioctls in
- * 64bit environment. The size and direction of data is
- * determined by _IOC_*() decoding of cmd. For _IOC_NONE,
- * data will be NULL, for _IOC_WRITE data is out area, for
- * _IOC_READ in area and if both are set in/out area. In all
- * non-NULL cases, the area is of _IOC_SIZE(cmd) bytes.
- *
- * If flags has FUSE_IOCTL_DIR then the fuse_file_info refers to a
- * directory file handle.
- *
- * Note : the unsigned long request submitted by the application
- * is truncated to 32 bits.
- */
- int (*ioctl) (const char *, unsigned int cmd, void *arg,
- struct fuse_file_info *, unsigned int flags, void *data);
-
- /**
- * Poll for IO readiness events
- *
- * Note: If ph is non-NULL, the client should notify
- * when IO readiness events occur by calling
- * fuse_notify_poll() with the specified ph.
- *
- * Regardless of the number of times poll with a non-NULL ph
- * is received, single notification is enough to clear all.
- * Notifying more times incurs overhead but doesn't harm
- * correctness.
- *
- * The callee is responsible for destroying ph with
- * fuse_pollhandle_destroy() when no longer in use.
- */
- int (*poll) (const char *, struct fuse_file_info *,
- struct fuse_pollhandle *ph, unsigned *reventsp);
-
- /** Write contents of buffer to an open file
- *
- * Similar to the write() method, but data is supplied in a
- * generic buffer. Use fuse_buf_copy() to transfer data to
- * the destination.
- *
- * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
- * expected to reset the setuid and setgid bits.
- */
- int (*write_buf) (const char *, struct fuse_bufvec *buf, off_t off,
- struct fuse_file_info *);
-
- /** Store data from an open file in a buffer
- *
- * Similar to the read() method, but data is stored and
- * returned in a generic buffer.
- *
- * No actual copying of data has to take place, the source
- * file descriptor may simply be stored in the buffer for
- * later data transfer.
- *
- * The buffer must be allocated dynamically and stored at the
- * location pointed to by bufp. If the buffer contains memory
- * regions, they too must be allocated using malloc(). The
- * allocated memory will be freed by the caller.
- */
- int (*read_buf) (const char *, struct fuse_bufvec **bufp,
- size_t size, off_t off, struct fuse_file_info *);
- /**
- * Perform BSD file locking operation
- *
- * The op argument will be either LOCK_SH, LOCK_EX or LOCK_UN
- *
- * Nonblocking requests will be indicated by ORing LOCK_NB to
- * the above operations
- *
- * For more information see the flock(2) manual page.
- *
- * Additionally fi->owner will be set to a value unique to
- * this open file. This same value will be supplied to
- * ->release() when the file is released.
- *
- * Note: if this method is not implemented, the kernel will still
- * allow file locking to work locally. Hence it is only
- * interesting for network filesystems and similar.
- */
- int (*flock) (const char *, struct fuse_file_info *, int op);
-
- /**
- * Allocates space for an open file
- *
- * This function ensures that required space is allocated for specified
- * file. If this function returns success then any subsequent write
- * request to specified range is guaranteed not to fail because of lack
- * of space on the file system media.
- */
- int (*fallocate) (const char *, int, off_t, off_t,
- struct fuse_file_info *);
-
- /**
- * Copy a range of data from one file to another
- *
- * Performs an optimized copy between two file descriptors without the
- * additional cost of transferring data through the FUSE kernel module
- * to user space (glibc) and then back into the FUSE filesystem again.
- *
- * In case this method is not implemented, glibc falls back to reading
- * data from the source and writing to the destination. Effectively
- * doing an inefficient copy of the data.
- */
- ssize_t (*copy_file_range) (const char *path_in,
- struct fuse_file_info *fi_in,
- off_t offset_in, const char *path_out,
- struct fuse_file_info *fi_out,
- off_t offset_out, size_t size, int flags);
-
- /**
- * Find next data or hole after the specified offset
- */
- off_t (*lseek) (const char *, off_t off, int whence, struct fuse_file_info *);
+ /**
+ * Get file attributes.
+ *
+ * Similar to stat(). The 'st_dev' and 'st_blksize' fields are
+ * ignored. The 'st_ino' field is ignored except if the 'use_ino'
+ * mount option is given. In that case it is passed to userspace,
+ * but libfuse and the kernel will still assign a different
+ * inode for internal use (called the "nodeid").
+ *
+ * `fi` will always be NULL if the file is not currently open, but
+ * may also be NULL if the file is open.
+ */
+ int (*getattr)(const char *, struct stat *, struct fuse_file_info *fi);
+
+ /**
+ * Read the target of a symbolic link
+ *
+ * The buffer should be filled with a null terminated string. The
+ * buffer size argument includes the space for the terminating
+ * null character. If the linkname is too long to fit in the
+ * buffer, it should be truncated. The return value should be 0
+ * for success.
+ */
+ int (*readlink)(const char *, char *, size_t);
+
+ /**
+ * Create a file node
+ *
+ * This is called for creation of all non-directory, non-symlink
+ * nodes. If the filesystem defines a create() method, then for
+ * regular files that will be called instead.
+ */
+ int (*mknod)(const char *, mode_t, dev_t);
+
+ /**
+ * Create a directory
+ *
+ * Note that the mode argument may not have the type specification
+ * bits set, i.e. S_ISDIR(mode) can be false. To obtain the
+ * correct directory type bits use mode|S_IFDIR
+ */
+ int (*mkdir)(const char *, mode_t);
+
+ /** Remove a file */
+ int (*unlink)(const char *);
+
+ /** Remove a directory */
+ int (*rmdir)(const char *);
+
+ /** Create a symbolic link */
+ int (*symlink)(const char *, const char *);
+
+ /**
+ * Rename a file
+ *
+ * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If
+ * RENAME_NOREPLACE is specified, the filesystem must not
+ * overwrite *newname* if it exists and return an error
+ * instead. If `RENAME_EXCHANGE` is specified, the filesystem
+ * must atomically exchange the two files, i.e. both must
+ * exist and neither may be deleted.
+ */
+ int (*rename)(const char *, const char *, unsigned int flags);
+
+ /** Create a hard link to a file */
+ int (*link)(const char *, const char *);
+
+ /**
+ * Change the permission bits of a file
+ *
+ * `fi` will always be NULL if the file is not currenlty open, but
+ * may also be NULL if the file is open.
+ */
+ int (*chmod)(const char *, mode_t, struct fuse_file_info *fi);
+
+ /**
+ * Change the owner and group of a file
+ *
+ * `fi` will always be NULL if the file is not currenlty open, but
+ * may also be NULL if the file is open.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ */
+ int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *fi);
+
+ /**
+ * Change the size of a file
+ *
+ * `fi` will always be NULL if the file is not currenlty open, but
+ * may also be NULL if the file is open.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ */
+ int (*truncate)(const char *, off_t, struct fuse_file_info *fi);
+
+ /**
+ * Open a file
+ *
+ * Open flags are available in fi->flags. The following rules
+ * apply.
+ *
+ * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be
+ * filtered out / handled by the kernel.
+ *
+ * - Access modes (O_RDONLY, O_WRONLY, O_RDWR, O_EXEC, O_SEARCH)
+ * should be used by the filesystem to check if the operation is
+ * permitted. If the ``-o default_permissions`` mount option is
+ * given, this check is already done by the kernel before calling
+ * open() and may thus be omitted by the filesystem.
+ *
+ * - When writeback caching is enabled, the kernel may send
+ * read requests even for files opened with O_WRONLY. The
+ * filesystem should be prepared to handle this.
+ *
+ * - When writeback caching is disabled, the filesystem is
+ * expected to properly handle the O_APPEND flag and ensure
+ * that each write is appending to the end of the file.
+ *
+ * - When writeback caching is enabled, the kernel will
+ * handle O_APPEND. However, unless all changes to the file
+ * come through the kernel this will not work reliably. The
+ * filesystem should thus either ignore the O_APPEND flag
+ * (and let the kernel handle it), or return an error
+ * (indicating that reliably O_APPEND is not available).
+ *
+ * Filesystem may store an arbitrary file handle (pointer,
+ * index, etc) in fi->fh, and use this in other all other file
+ * operations (read, write, flush, release, fsync).
+ *
+ * Filesystem may also implement stateless file I/O and not store
+ * anything in fi->fh.
+ *
+ * There are also some flags (direct_io, keep_cache) which the
+ * filesystem may set in fi, to change the way the file is opened.
+ * See fuse_file_info structure in <fuse_common.h> for more details.
+ *
+ * If this request is answered with an error code of ENOSYS
+ * and FUSE_CAP_NO_OPEN_SUPPORT is set in
+ * `fuse_conn_info.capable`, this is treated as success and
+ * future calls to open will also succeed without being send
+ * to the filesystem process.
+ *
+ */
+ int (*open)(const char *, struct fuse_file_info *);
+
+ /**
+ * Read data from an open file
+ *
+ * Read should return exactly the number of bytes requested except
+ * on EOF or error, otherwise the rest of the data will be
+ * substituted with zeroes. An exception to this is when the
+ * 'direct_io' mount option is specified, in which case the return
+ * value of the read system call will reflect the return value of
+ * this operation.
+ */
+ int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *);
+
+ /**
+ * Write data to an open file
+ *
+ * Write should return exactly the number of bytes requested
+ * except on error. An exception to this is when the 'direct_io'
+ * mount option is specified (see read operation).
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ */
+ int (*write)(const char *, const char *, size_t, off_t,
+ struct fuse_file_info *);
+
+ /**
+ * Get file system statistics
+ *
+ * The 'f_favail', 'f_fsid' and 'f_flag' fields are ignored
+ */
+ int (*statfs)(const char *, struct statvfs *);
+
+ /**
+ * Possibly flush cached data
+ *
+ * BIG NOTE: This is not equivalent to fsync(). It's not a
+ * request to sync dirty data.
+ *
+ * Flush is called on each close() of a file descriptor, as opposed to
+ * release which is called on the close of the last file descriptor for
+ * a file. Under Linux, errors returned by flush() will be passed to
+ * userspace as errors from close(), so flush() is a good place to write
+ * back any cached dirty data. However, many applications ignore errors
+ * on close(), and on non-Linux systems, close() may succeed even if flush()
+ * returns an error. For these reasons, filesystems should not assume
+ * that errors returned by flush will ever be noticed or even
+ * delivered.
+ *
+ * NOTE: The flush() method may be called more than once for each
+ * open(). This happens if more than one file descriptor refers to an
+ * open file handle, e.g. due to dup(), dup2() or fork() calls. It is
+ * not possible to determine if a flush is final, so each flush should
+ * be treated equally. Multiple write-flush sequences are relatively
+ * rare, so this shouldn't be a problem.
+ *
+ * Filesystems shouldn't assume that flush will be called at any
+ * particular point. It may be called more times than expected, or not
+ * at all.
+ *
+ * [close]:
+ * http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
+ */
+ int (*flush)(const char *, struct fuse_file_info *);
+
+ /**
+ * Release an open file
+ *
+ * Release is called when there are no more references to an open
+ * file: all file descriptors are closed and all memory mappings
+ * are unmapped.
+ *
+ * For every open() call there will be exactly one release() call
+ * with the same flags and file handle. It is possible to
+ * have a file opened more than once, in which case only the last
+ * release will mean, that no more reads/writes will happen on the
+ * file. The return value of release is ignored.
+ */
+ int (*release)(const char *, struct fuse_file_info *);
+
+ /*
+ * Synchronize file contents
+ *
+ * If the datasync parameter is non-zero, then only the user data
+ * should be flushed, not the meta data.
+ */
+ int (*fsync)(const char *, int, struct fuse_file_info *);
+
+ /** Set extended attributes */
+ int (*setxattr)(const char *, const char *, const char *, size_t, int);
+
+ /** Get extended attributes */
+ int (*getxattr)(const char *, const char *, char *, size_t);
+
+ /** List extended attributes */
+ int (*listxattr)(const char *, char *, size_t);
+
+ /** Remove extended attributes */
+ int (*removexattr)(const char *, const char *);
+
+ /*
+ * Open directory
+ *
+ * Unless the 'default_permissions' mount option is given,
+ * this method should check if opendir is permitted for this
+ * directory. Optionally opendir may also return an arbitrary
+ * filehandle in the fuse_file_info structure, which will be
+ * passed to readdir, releasedir and fsyncdir.
+ */
+ int (*opendir)(const char *, struct fuse_file_info *);
+
+ /*
+ * Read directory
+ *
+ * The filesystem may choose between two modes of operation:
+ *
+ * 1) The readdir implementation ignores the offset parameter, and
+ * passes zero to the filler function's offset. The filler
+ * function will not return '1' (unless an error happens), so the
+ * whole directory is read in a single readdir operation.
+ *
+ * 2) The readdir implementation keeps track of the offsets of the
+ * directory entries. It uses the offset parameter and always
+ * passes non-zero offset to the filler function. When the buffer
+ * is full (or an error happens) the filler function will return
+ * '1'.
+ */
+ int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t,
+ struct fuse_file_info *, enum fuse_readdir_flags);
+
+ /**
+ * Release directory
+ */
+ int (*releasedir)(const char *, struct fuse_file_info *);
+
+ /**
+ * Synchronize directory contents
+ *
+ * If the datasync parameter is non-zero, then only the user data
+ * should be flushed, not the meta data
+ */
+ int (*fsyncdir)(const char *, int, struct fuse_file_info *);
+
+ /**
+ * Initialize filesystem
+ *
+ * The return value will passed in the `private_data` field of
+ * `struct fuse_context` to all file operations, and as a
+ * parameter to the destroy() method. It overrides the initial
+ * value provided to fuse_main() / fuse_new().
+ */
+ void *(*init)(struct fuse_conn_info *conn, struct fuse_config *cfg);
+
+ /**
+ * Clean up filesystem
+ *
+ * Called on filesystem exit.
+ */
+ void (*destroy)(void *private_data);
+
+ /**
+ * Check file access permissions
+ *
+ * This will be called for the access() system call. If the
+ * 'default_permissions' mount option is given, this method is not
+ * called.
+ *
+ * This method is not called under Linux kernel versions 2.4.x
+ */
+ int (*access)(const char *, int);
+
+ /**
+ * Create and open a file
+ *
+ * If the file does not exist, first create it with the specified
+ * mode, and then open it.
+ *
+ * If this method is not implemented or under Linux kernel
+ * versions earlier than 2.6.15, the mknod() and open() methods
+ * will be called instead.
+ */
+ int (*create)(const char *, mode_t, struct fuse_file_info *);
+
+ /**
+ * Perform POSIX file locking operation
+ *
+ * The cmd argument will be either F_GETLK, F_SETLK or F_SETLKW.
+ *
+ * For the meaning of fields in 'struct flock' see the man page
+ * for fcntl(2). The l_whence field will always be set to
+ * SEEK_SET.
+ *
+ * For checking lock ownership, the 'fuse_file_info->owner'
+ * argument must be used.
+ *
+ * For F_GETLK operation, the library will first check currently
+ * held locks, and if a conflicting lock is found it will return
+ * information without calling this method. This ensures, that
+ * for local locks the l_pid field is correctly filled in. The
+ * results may not be accurate in case of race conditions and in
+ * the presence of hard links, but it's unlikely that an
+ * application would rely on accurate GETLK results in these
+ * cases. If a conflicting lock is not found, this method will be
+ * called, and the filesystem may fill out l_pid by a meaningful
+ * value, or it may leave this field zero.
+ *
+ * For F_SETLK and F_SETLKW the l_pid field will be set to the pid
+ * of the process performing the locking operation.
+ *
+ * Note: if this method is not implemented, the kernel will still
+ * allow file locking to work locally. Hence it is only
+ * interesting for network filesystems and similar.
+ */
+ int (*lock)(const char *, struct fuse_file_info *, int cmd, struct flock *);
+
+ /**
+ * Change the access and modification times of a file with
+ * nanosecond resolution
+ *
+ * This supersedes the old utime() interface. New applications
+ * should use this.
+ *
+ * `fi` will always be NULL if the file is not currenlty open, but
+ * may also be NULL if the file is open.
+ *
+ * See the utimensat(2) man page for details.
+ */
+ int (*utimens)(const char *, const struct timespec tv[2],
+ struct fuse_file_info *fi);
+
+ /**
+ * Map block index within file to block index within device
+ *
+ * Note: This makes sense only for block device backed filesystems
+ * mounted with the 'blkdev' option
+ */
+ int (*bmap)(const char *, size_t blocksize, uint64_t *idx);
+
+ /**
+ * Ioctl
+ *
+ * flags will have FUSE_IOCTL_COMPAT set for 32bit ioctls in
+ * 64bit environment. The size and direction of data is
+ * determined by _IOC_*() decoding of cmd. For _IOC_NONE,
+ * data will be NULL, for _IOC_WRITE data is out area, for
+ * _IOC_READ in area and if both are set in/out area. In all
+ * non-NULL cases, the area is of _IOC_SIZE(cmd) bytes.
+ *
+ * If flags has FUSE_IOCTL_DIR then the fuse_file_info refers to a
+ * directory file handle.
+ *
+ * Note : the unsigned long request submitted by the application
+ * is truncated to 32 bits.
+ */
+ int (*ioctl)(const char *, unsigned int cmd, void *arg,
+ struct fuse_file_info *, unsigned int flags, void *data);
+
+ /**
+ * Poll for IO readiness events
+ *
+ * Note: If ph is non-NULL, the client should notify
+ * when IO readiness events occur by calling
+ * fuse_notify_poll() with the specified ph.
+ *
+ * Regardless of the number of times poll with a non-NULL ph
+ * is received, single notification is enough to clear all.
+ * Notifying more times incurs overhead but doesn't harm
+ * correctness.
+ *
+ * The callee is responsible for destroying ph with
+ * fuse_pollhandle_destroy() when no longer in use.
+ */
+ int (*poll)(const char *, struct fuse_file_info *,
+ struct fuse_pollhandle *ph, unsigned *reventsp);
+
+ /*
+ * Write contents of buffer to an open file
+ *
+ * Similar to the write() method, but data is supplied in a
+ * generic buffer. Use fuse_buf_copy() to transfer data to
+ * the destination.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ */
+ int (*write_buf)(const char *, struct fuse_bufvec *buf, off_t off,
+ struct fuse_file_info *);
+
+ /*
+ * Store data from an open file in a buffer
+ *
+ * Similar to the read() method, but data is stored and
+ * returned in a generic buffer.
+ *
+ * No actual copying of data has to take place, the source
+ * file descriptor may simply be stored in the buffer for
+ * later data transfer.
+ *
+ * The buffer must be allocated dynamically and stored at the
+ * location pointed to by bufp. If the buffer contains memory
+ * regions, they too must be allocated using malloc(). The
+ * allocated memory will be freed by the caller.
+ */
+ int (*read_buf)(const char *, struct fuse_bufvec **bufp, size_t size,
+ off_t off, struct fuse_file_info *);
+ /**
+ * Perform BSD file locking operation
+ *
+ * The op argument will be either LOCK_SH, LOCK_EX or LOCK_UN
+ *
+ * Nonblocking requests will be indicated by ORing LOCK_NB to
+ * the above operations
+ *
+ * For more information see the flock(2) manual page.
+ *
+ * Additionally fi->owner will be set to a value unique to
+ * this open file. This same value will be supplied to
+ * ->release() when the file is released.
+ *
+ * Note: if this method is not implemented, the kernel will still
+ * allow file locking to work locally. Hence it is only
+ * interesting for network filesystems and similar.
+ */
+ int (*flock)(const char *, struct fuse_file_info *, int op);
+
+ /**
+ * Allocates space for an open file
+ *
+ * This function ensures that required space is allocated for specified
+ * file. If this function returns success then any subsequent write
+ * request to specified range is guaranteed not to fail because of lack
+ * of space on the file system media.
+ */
+ int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *);
+
+ /**
+ * Copy a range of data from one file to another
+ *
+ * Performs an optimized copy between two file descriptors without the
+ * additional cost of transferring data through the FUSE kernel module
+ * to user space (glibc) and then back into the FUSE filesystem again.
+ *
+ * In case this method is not implemented, glibc falls back to reading
+ * data from the source and writing to the destination. Effectively
+ * doing an inefficient copy of the data.
+ */
+ ssize_t (*copy_file_range)(const char *path_in,
+ struct fuse_file_info *fi_in, off_t offset_in,
+ const char *path_out,
+ struct fuse_file_info *fi_out, off_t offset_out,
+ size_t size, int flags);
+
+ /**
+ * Find next data or hole after the specified offset
+ */
+ off_t (*lseek)(const char *, off_t off, int whence,
+ struct fuse_file_info *);
};
-/** Extra context that may be needed by some filesystems
+/*
+ * Extra context that may be needed by some filesystems
*
* The uid, gid and pid fields are not filled in case of a writepage
* operation.
*/
struct fuse_context {
- /** Pointer to the fuse object */
- struct fuse *fuse;
+ /** Pointer to the fuse object */
+ struct fuse *fuse;
- /** User ID of the calling process */
- uid_t uid;
+ /** User ID of the calling process */
+ uid_t uid;
- /** Group ID of the calling process */
- gid_t gid;
+ /** Group ID of the calling process */
+ gid_t gid;
- /** Process ID of the calling thread */
- pid_t pid;
+ /** Process ID of the calling thread */
+ pid_t pid;
- /** Private filesystem data */
- void *private_data;
+ /** Private filesystem data */
+ void *private_data;
- /** Umask of the calling process */
- mode_t umask;
+ /** Umask of the calling process */
+ mode_t umask;
};
/**
@@ -859,15 +880,15 @@ struct fuse_context {
* Example usage, see hello.c
*/
/*
- int fuse_main(int argc, char *argv[], const struct fuse_operations *op,
- void *private_data);
-*/
-#define fuse_main(argc, argv, op, private_data) \
- fuse_main_real(argc, argv, op, sizeof(*(op)), private_data)
+ * int fuse_main(int argc, char *argv[], const struct fuse_operations *op,
+ * void *private_data);
+ */
+#define fuse_main(argc, argv, op, private_data) \
+ fuse_main_real(argc, argv, op, sizeof(*(op)), private_data)
-/* ----------------------------------------------------------- *
- * More detailed API *
- * ----------------------------------------------------------- */
+/*
+ * More detailed API
+ */
/**
* Print available options (high- and low-level) to stdout. This is
@@ -910,12 +931,13 @@ void fuse_lib_help(struct fuse_args *args);
* @return the created FUSE handle
*/
#if FUSE_USE_VERSION == 30
-struct fuse *fuse_new_30(struct fuse_args *args, const struct fuse_operations *op,
- size_t op_size, void *private_data);
+struct fuse *fuse_new_30(struct fuse_args *args,
+ const struct fuse_operations *op, size_t op_size,
+ void *private_data);
#define fuse_new(args, op, size, data) fuse_new_30(args, op, size, data)
#else
struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op,
- size_t op_size, void *private_data);
+ size_t op_size, void *private_data);
#endif
/**
@@ -940,7 +962,7 @@ void fuse_unmount(struct fuse *f);
/**
* Destroy the FUSE handle.
*
- * NOTE: This function does not unmount the filesystem. If this is
+ * NOTE: This function does not unmount the filesystem. If this is
* needed, call fuse_unmount() before calling this function.
*
* @param f the FUSE handle
@@ -1030,7 +1052,7 @@ int fuse_invalidate_path(struct fuse *f, const char *path);
* Do not call this directly, use fuse_main()
*/
int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
- size_t op_size, void *private_data);
+ size_t op_size, void *private_data);
/**
* Start the cleanup thread when using option "remember".
@@ -1081,89 +1103,87 @@ struct fuse_fs;
*/
int fuse_fs_getattr(struct fuse_fs *fs, const char *path, struct stat *buf,
- struct fuse_file_info *fi);
-int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath,
- const char *newpath, unsigned int flags);
+ struct fuse_file_info *fi);
+int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath, const char *newpath,
+ unsigned int flags);
int fuse_fs_unlink(struct fuse_fs *fs, const char *path);
int fuse_fs_rmdir(struct fuse_fs *fs, const char *path);
-int fuse_fs_symlink(struct fuse_fs *fs, const char *linkname,
- const char *path);
+int fuse_fs_symlink(struct fuse_fs *fs, const char *linkname, const char *path);
int fuse_fs_link(struct fuse_fs *fs, const char *oldpath, const char *newpath);
-int fuse_fs_release(struct fuse_fs *fs, const char *path,
- struct fuse_file_info *fi);
+int fuse_fs_release(struct fuse_fs *fs, const char *path,
+ struct fuse_file_info *fi);
int fuse_fs_open(struct fuse_fs *fs, const char *path,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_read(struct fuse_fs *fs, const char *path, char *buf, size_t size,
- off_t off, struct fuse_file_info *fi);
+ off_t off, struct fuse_file_info *fi);
int fuse_fs_read_buf(struct fuse_fs *fs, const char *path,
- struct fuse_bufvec **bufp, size_t size, off_t off,
- struct fuse_file_info *fi);
+ struct fuse_bufvec **bufp, size_t size, off_t off,
+ struct fuse_file_info *fi);
int fuse_fs_write(struct fuse_fs *fs, const char *path, const char *buf,
- size_t size, off_t off, struct fuse_file_info *fi);
+ size_t size, off_t off, struct fuse_file_info *fi);
int fuse_fs_write_buf(struct fuse_fs *fs, const char *path,
- struct fuse_bufvec *buf, off_t off,
- struct fuse_file_info *fi);
+ struct fuse_bufvec *buf, off_t off,
+ struct fuse_file_info *fi);
int fuse_fs_fsync(struct fuse_fs *fs, const char *path, int datasync,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_flush(struct fuse_fs *fs, const char *path,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_statfs(struct fuse_fs *fs, const char *path, struct statvfs *buf);
int fuse_fs_opendir(struct fuse_fs *fs, const char *path,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_readdir(struct fuse_fs *fs, const char *path, void *buf,
- fuse_fill_dir_t filler, off_t off,
- struct fuse_file_info *fi, enum fuse_readdir_flags flags);
+ fuse_fill_dir_t filler, off_t off,
+ struct fuse_file_info *fi, enum fuse_readdir_flags flags);
int fuse_fs_fsyncdir(struct fuse_fs *fs, const char *path, int datasync,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_releasedir(struct fuse_fs *fs, const char *path,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_create(struct fuse_fs *fs, const char *path, mode_t mode,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_lock(struct fuse_fs *fs, const char *path,
- struct fuse_file_info *fi, int cmd, struct flock *lock);
+ struct fuse_file_info *fi, int cmd, struct flock *lock);
int fuse_fs_flock(struct fuse_fs *fs, const char *path,
- struct fuse_file_info *fi, int op);
+ struct fuse_file_info *fi, int op);
int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
- const struct timespec tv[2], struct fuse_file_info *fi);
+ const struct timespec tv[2], struct fuse_file_info *fi);
int fuse_fs_access(struct fuse_fs *fs, const char *path, int mask);
int fuse_fs_readlink(struct fuse_fs *fs, const char *path, char *buf,
- size_t len);
+ size_t len);
int fuse_fs_mknod(struct fuse_fs *fs, const char *path, mode_t mode,
- dev_t rdev);
+ dev_t rdev);
int fuse_fs_mkdir(struct fuse_fs *fs, const char *path, mode_t mode);
int fuse_fs_setxattr(struct fuse_fs *fs, const char *path, const char *name,
- const char *value, size_t size, int flags);
+ const char *value, size_t size, int flags);
int fuse_fs_getxattr(struct fuse_fs *fs, const char *path, const char *name,
- char *value, size_t size);
+ char *value, size_t size);
int fuse_fs_listxattr(struct fuse_fs *fs, const char *path, char *list,
- size_t size);
-int fuse_fs_removexattr(struct fuse_fs *fs, const char *path,
- const char *name);
+ size_t size);
+int fuse_fs_removexattr(struct fuse_fs *fs, const char *path, const char *name);
int fuse_fs_bmap(struct fuse_fs *fs, const char *path, size_t blocksize,
- uint64_t *idx);
+ uint64_t *idx);
int fuse_fs_ioctl(struct fuse_fs *fs, const char *path, unsigned int cmd,
- void *arg, struct fuse_file_info *fi, unsigned int flags,
- void *data);
+ void *arg, struct fuse_file_info *fi, unsigned int flags,
+ void *data);
int fuse_fs_poll(struct fuse_fs *fs, const char *path,
- struct fuse_file_info *fi, struct fuse_pollhandle *ph,
- unsigned *reventsp);
+ struct fuse_file_info *fi, struct fuse_pollhandle *ph,
+ unsigned *reventsp);
int fuse_fs_fallocate(struct fuse_fs *fs, const char *path, int mode,
- off_t offset, off_t length, struct fuse_file_info *fi);
+ off_t offset, off_t length, struct fuse_file_info *fi);
ssize_t fuse_fs_copy_file_range(struct fuse_fs *fs, const char *path_in,
- struct fuse_file_info *fi_in, off_t off_in,
- const char *path_out,
- struct fuse_file_info *fi_out, off_t off_out,
- size_t len, int flags);
+ struct fuse_file_info *fi_in, off_t off_in,
+ const char *path_out,
+ struct fuse_file_info *fi_out, off_t off_out,
+ size_t len, int flags);
off_t fuse_fs_lseek(struct fuse_fs *fs, const char *path, off_t off, int whence,
- struct fuse_file_info *fi);
+ struct fuse_file_info *fi);
void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn,
- struct fuse_config *cfg);
+ struct fuse_config *cfg);
void fuse_fs_destroy(struct fuse_fs *fs);
int fuse_notify_poll(struct fuse_pollhandle *ph);
@@ -1182,7 +1202,7 @@ int fuse_notify_poll(struct fuse_pollhandle *ph);
* @return a new filesystem object
*/
struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size,
- void *private_data);
+ void *private_data);
/**
* Factory for creating filesystem objects
@@ -1199,7 +1219,7 @@ struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size,
* @return the new filesystem object
*/
typedef struct fuse_fs *(*fuse_module_factory_t)(struct fuse_args *args,
- struct fuse_fs *fs[]);
+ struct fuse_fs *fs[]);
/**
* Register filesystem module
*
@@ -1211,7 +1231,7 @@ typedef struct fuse_fs *(*fuse_module_factory_t)(struct fuse_args *args,
* @param factory_ the factory function for this filesystem module
*/
#define FUSE_REGISTER_MODULE(name_, factory_) \
- fuse_module_factory_t fuse_module_ ## name_ ## _factory = factory_
+ fuse_module_factory_t fuse_module_##name_##_factory = factory_
/** Get session from fuse object */
struct fuse_session *fuse_get_session(struct fuse *f);
diff --git a/tools/virtiofsd/fuse_common.h b/tools/virtiofsd/fuse_common.h
index bf8f8cc865..bd9bf861f0 100644
--- a/tools/virtiofsd/fuse_common.h
+++ b/tools/virtiofsd/fuse_common.h
@@ -1,21 +1,23 @@
-/* FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB.
-*/
+/*
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB.
+ */
/** @file */
#if !defined(FUSE_H_) && !defined(FUSE_LOWLEVEL_H_)
-#error "Never include <fuse_common.h> directly; use <fuse.h> or <fuse_lowlevel.h> instead."
+#error \
+ "Never include <fuse_common.h> directly; use <fuse.h> or <fuse_lowlevel.h> instead."
#endif
#ifndef FUSE_COMMON_H_
#define FUSE_COMMON_H_
-#include "fuse_opt.h"
#include "fuse_log.h"
+#include "fuse_opt.h"
#include <stdint.h>
#include <sys/types.h>
@@ -25,7 +27,7 @@
/** Minor version of FUSE library interface */
#define FUSE_MINOR_VERSION 2
-#define FUSE_MAKE_VERSION(maj, min) ((maj) * 10 + (min))
+#define FUSE_MAKE_VERSION(maj, min) ((maj) * 10 + (min))
#define FUSE_VERSION FUSE_MAKE_VERSION(FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION)
/**
@@ -38,67 +40,83 @@
* descriptors can share a single file handle.
*/
struct fuse_file_info {
- /** Open flags. Available in open() and release() */
- int flags;
-
- /** In case of a write operation indicates if this was caused
- by a delayed write from the page cache. If so, then the
- context's pid, uid, and gid fields will not be valid, and
- the *fh* value may not match the *fh* value that would
- have been sent with the corresponding individual write
- requests if write caching had been disabled. */
- unsigned int writepage : 1;
-
- /** Can be filled in by open, to use direct I/O on this file. */
- unsigned int direct_io : 1;
-
- /** Can be filled in by open. It signals the kernel that any
- currently cached file data (ie., data that the filesystem
- provided the last time the file was open) need not be
- invalidated. Has no effect when set in other contexts (in
- particular it does nothing when set by opendir()). */
- unsigned int keep_cache : 1;
-
- /** Indicates a flush operation. Set in flush operation, also
- maybe set in highlevel lock operation and lowlevel release
- operation. */
- unsigned int flush : 1;
-
- /** Can be filled in by open, to indicate that the file is not
- seekable. */
- unsigned int nonseekable : 1;
-
- /* Indicates that flock locks for this file should be
- released. If set, lock_owner shall contain a valid value.
- May only be set in ->release(). */
- unsigned int flock_release : 1;
-
- /** Can be filled in by opendir. It signals the kernel to
- enable caching of entries returned by readdir(). Has no
- effect when set in other contexts (in particular it does
- nothing when set by open()). */
- unsigned int cache_readdir : 1;
-
- /** Padding. Reserved for future use*/
- unsigned int padding : 25;
- unsigned int padding2 : 32;
-
- /** File handle id. May be filled in by filesystem in create,
- * open, and opendir(). Available in most other file operations on the
- * same file handle. */
- uint64_t fh;
-
- /** Lock owner id. Available in locking operations and flush */
- uint64_t lock_owner;
-
- /** Requested poll events. Available in ->poll. Only set on kernels
- which support it. If unsupported, this field is set to zero. */
- uint32_t poll_events;
+ /** Open flags. Available in open() and release() */
+ int flags;
+
+ /*
+ * In case of a write operation indicates if this was caused
+ * by a delayed write from the page cache. If so, then the
+ * context's pid, uid, and gid fields will not be valid, and
+ * the *fh* value may not match the *fh* value that would
+ * have been sent with the corresponding individual write
+ * requests if write caching had been disabled.
+ */
+ unsigned int writepage:1;
+
+ /** Can be filled in by open, to use direct I/O on this file. */
+ unsigned int direct_io:1;
+
+ /*
+ * Can be filled in by open. It signals the kernel that any
+ * currently cached file data (ie., data that the filesystem
+ * provided the last time the file was open) need not be
+ * invalidated. Has no effect when set in other contexts (in
+ * particular it does nothing when set by opendir()).
+ */
+ unsigned int keep_cache:1;
+
+ /*
+ * Indicates a flush operation. Set in flush operation, also
+ * maybe set in highlevel lock operation and lowlevel release
+ * operation.
+ */
+ unsigned int flush:1;
+
+ /*
+ * Can be filled in by open, to indicate that the file is not
+ * seekable.
+ */
+ unsigned int nonseekable:1;
+
+ /*
+ * Indicates that flock locks for this file should be
+ * released. If set, lock_owner shall contain a valid value.
+ * May only be set in ->release().
+ */
+ unsigned int flock_release:1;
+
+ /*
+ * Can be filled in by opendir. It signals the kernel to
+ * enable caching of entries returned by readdir(). Has no
+ * effect when set in other contexts (in particular it does
+ * nothing when set by open()).
+ */
+ unsigned int cache_readdir:1;
+
+ /** Padding. Reserved for future use*/
+ unsigned int padding:25;
+ unsigned int padding2:32;
+
+ /*
+ * File handle id. May be filled in by filesystem in create,
+ * open, and opendir(). Available in most other file operations on the
+ * same file handle.
+ */
+ uint64_t fh;
+
+ /** Lock owner id. Available in locking operations and flush */
+ uint64_t lock_owner;
+
+ /*
+ * Requested poll events. Available in ->poll. Only set on kernels
+ * which support it. If unsupported, this field is set to zero.
+ */
+ uint32_t poll_events;
};
-/**************************************************************************
- * Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want' *
- **************************************************************************/
+/*
+ * Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want'
+ */
/**
* Indicates that the filesystem supports asynchronous read requests.
@@ -110,7 +128,7 @@ struct fuse_file_info {
*
* This feature is enabled by default when supported by the kernel.
*/
-#define FUSE_CAP_ASYNC_READ (1 << 0)
+#define FUSE_CAP_ASYNC_READ (1 << 0)
/**
* Indicates that the filesystem supports "remote" locking.
@@ -118,7 +136,7 @@ struct fuse_file_info {
* This feature is enabled by default when supported by the kernel,
* and if getlk() and setlk() handlers are implemented.
*/
-#define FUSE_CAP_POSIX_LOCKS (1 << 1)
+#define FUSE_CAP_POSIX_LOCKS (1 << 1)
/**
* Indicates that the filesystem supports the O_TRUNC open flag. If
@@ -127,14 +145,14 @@ struct fuse_file_info {
*
* This feature is enabled by default when supported by the kernel.
*/
-#define FUSE_CAP_ATOMIC_O_TRUNC (1 << 3)
+#define FUSE_CAP_ATOMIC_O_TRUNC (1 << 3)
/**
* Indicates that the filesystem supports lookups of "." and "..".
*
* This feature is disabled by default.
*/
-#define FUSE_CAP_EXPORT_SUPPORT (1 << 4)
+#define FUSE_CAP_EXPORT_SUPPORT (1 << 4)
/**
* Indicates that the kernel should not apply the umask to the
@@ -142,7 +160,7 @@ struct fuse_file_info {
*
* This feature is disabled by default.
*/
-#define FUSE_CAP_DONT_MASK (1 << 6)
+#define FUSE_CAP_DONT_MASK (1 << 6)
/**
* Indicates that libfuse should try to use splice() when writing to
@@ -150,7 +168,7 @@ struct fuse_file_info {
*
* This feature is disabled by default.
*/
-#define FUSE_CAP_SPLICE_WRITE (1 << 7)
+#define FUSE_CAP_SPLICE_WRITE (1 << 7)
/**
* Indicates that libfuse should try to move pages instead of copying when
@@ -158,7 +176,7 @@ struct fuse_file_info {
*
* This feature is disabled by default.
*/
-#define FUSE_CAP_SPLICE_MOVE (1 << 8)
+#define FUSE_CAP_SPLICE_MOVE (1 << 8)
/**
* Indicates that libfuse should try to use splice() when reading from
@@ -167,7 +185,7 @@ struct fuse_file_info {
* This feature is enabled by default when supported by the kernel and
* if the filesystem implements a write_buf() handler.
*/
-#define FUSE_CAP_SPLICE_READ (1 << 9)
+#define FUSE_CAP_SPLICE_READ (1 << 9)
/**
* If set, the calls to flock(2) will be emulated using POSIX locks and must
@@ -180,14 +198,14 @@ struct fuse_file_info {
* This feature is enabled by default when supported by the kernel and
* if the filesystem implements a flock() handler.
*/
-#define FUSE_CAP_FLOCK_LOCKS (1 << 10)
+#define FUSE_CAP_FLOCK_LOCKS (1 << 10)
/**
* Indicates that the filesystem supports ioctl's on directories.
*
* This feature is enabled by default when supported by the kernel.
*/
-#define FUSE_CAP_IOCTL_DIR (1 << 11)
+#define FUSE_CAP_IOCTL_DIR (1 << 11)
/**
* Traditionally, while a file is open the FUSE kernel module only
@@ -209,7 +227,7 @@ struct fuse_file_info {
*
* This feature is enabled by default when supported by the kernel.
*/
-#define FUSE_CAP_AUTO_INVAL_DATA (1 << 12)
+#define FUSE_CAP_AUTO_INVAL_DATA (1 << 12)
/**
* Indicates that the filesystem supports readdirplus.
@@ -217,7 +235,7 @@ struct fuse_file_info {
* This feature is enabled by default when supported by the kernel and if the
* filesystem implements a readdirplus() handler.
*/
-#define FUSE_CAP_READDIRPLUS (1 << 13)
+#define FUSE_CAP_READDIRPLUS (1 << 13)
/**
* Indicates that the filesystem supports adaptive readdirplus.
@@ -245,7 +263,7 @@ struct fuse_file_info {
* if the filesystem implements both a readdirplus() and a readdir()
* handler.
*/
-#define FUSE_CAP_READDIRPLUS_AUTO (1 << 14)
+#define FUSE_CAP_READDIRPLUS_AUTO (1 << 14)
/**
* Indicates that the filesystem supports asynchronous direct I/O submission.
@@ -256,7 +274,7 @@ struct fuse_file_info {
*
* This feature is enabled by default when supported by the kernel.
*/
-#define FUSE_CAP_ASYNC_DIO (1 << 15)
+#define FUSE_CAP_ASYNC_DIO (1 << 15)
/**
* Indicates that writeback caching should be enabled. This means that
@@ -265,7 +283,7 @@ struct fuse_file_info {
*
* This feature is disabled by default.
*/
-#define FUSE_CAP_WRITEBACK_CACHE (1 << 16)
+#define FUSE_CAP_WRITEBACK_CACHE (1 << 16)
/**
* Indicates support for zero-message opens. If this flag is set in
@@ -278,7 +296,7 @@ struct fuse_file_info {
* Setting (or unsetting) this flag in the `want` field has *no
* effect*.
*/
-#define FUSE_CAP_NO_OPEN_SUPPORT (1 << 17)
+#define FUSE_CAP_NO_OPEN_SUPPORT (1 << 17)
/**
* Indicates support for parallel directory operations. If this flag
@@ -288,7 +306,7 @@ struct fuse_file_info {
*
* This feature is enabled by default when supported by the kernel.
*/
-#define FUSE_CAP_PARALLEL_DIROPS (1 << 18)
+#define FUSE_CAP_PARALLEL_DIROPS (1 << 18)
/**
* Indicates support for POSIX ACLs.
@@ -307,7 +325,7 @@ struct fuse_file_info {
*
* This feature is disabled by default.
*/
-#define FUSE_CAP_POSIX_ACL (1 << 19)
+#define FUSE_CAP_POSIX_ACL (1 << 19)
/**
* Indicates that the filesystem is responsible for unsetting
@@ -316,7 +334,7 @@ struct fuse_file_info {
*
* This feature is enabled by default when supported by the kernel.
*/
-#define FUSE_CAP_HANDLE_KILLPRIV (1 << 20)
+#define FUSE_CAP_HANDLE_KILLPRIV (1 << 20)
/**
* Indicates support for zero-message opendirs. If this flag is set in
@@ -328,7 +346,7 @@ struct fuse_file_info {
*
* Setting (or unsetting) this flag in the `want` field has *no effect*.
*/
-#define FUSE_CAP_NO_OPENDIR_SUPPORT (1 << 24)
+#define FUSE_CAP_NO_OPENDIR_SUPPORT (1 << 24)
/**
* Ioctl flags
@@ -340,12 +358,12 @@ struct fuse_file_info {
*
* FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
*/
-#define FUSE_IOCTL_COMPAT (1 << 0)
-#define FUSE_IOCTL_UNRESTRICTED (1 << 1)
-#define FUSE_IOCTL_RETRY (1 << 2)
-#define FUSE_IOCTL_DIR (1 << 4)
+#define FUSE_IOCTL_COMPAT (1 << 0)
+#define FUSE_IOCTL_UNRESTRICTED (1 << 1)
+#define FUSE_IOCTL_RETRY (1 << 2)
+#define FUSE_IOCTL_DIR (1 << 4)
-#define FUSE_IOCTL_MAX_IOV 256
+#define FUSE_IOCTL_MAX_IOV 256
/**
* Connection information, passed to the ->init() method
@@ -355,114 +373,114 @@ struct fuse_file_info {
* value must usually be smaller than the indicated value.
*/
struct fuse_conn_info {
- /**
- * Major version of the protocol (read-only)
- */
- unsigned proto_major;
-
- /**
- * Minor version of the protocol (read-only)
- */
- unsigned proto_minor;
-
- /**
- * Maximum size of the write buffer
- */
- unsigned max_write;
-
- /**
- * Maximum size of read requests. A value of zero indicates no
- * limit. However, even if the filesystem does not specify a
- * limit, the maximum size of read requests will still be
- * limited by the kernel.
- *
- * NOTE: For the time being, the maximum size of read requests
- * must be set both here *and* passed to fuse_session_new()
- * using the ``-o max_read=<n>`` mount option. At some point
- * in the future, specifying the mount option will no longer
- * be necessary.
- */
- unsigned max_read;
-
- /**
- * Maximum readahead
- */
- unsigned max_readahead;
-
- /**
- * Capability flags that the kernel supports (read-only)
- */
- unsigned capable;
-
- /**
- * Capability flags that the filesystem wants to enable.
- *
- * libfuse attempts to initialize this field with
- * reasonable default values before calling the init() handler.
- */
- unsigned want;
-
- /**
- * Maximum number of pending "background" requests. A
- * background request is any type of request for which the
- * total number is not limited by other means. As of kernel
- * 4.8, only two types of requests fall into this category:
- *
- * 1. Read-ahead requests
- * 2. Asynchronous direct I/O requests
- *
- * Read-ahead requests are generated (if max_readahead is
- * non-zero) by the kernel to preemptively fill its caches
- * when it anticipates that userspace will soon read more
- * data.
- *
- * Asynchronous direct I/O requests are generated if
- * FUSE_CAP_ASYNC_DIO is enabled and userspace submits a large
- * direct I/O request. In this case the kernel will internally
- * split it up into multiple smaller requests and submit them
- * to the filesystem concurrently.
- *
- * Note that the following requests are *not* background
- * requests: writeback requests (limited by the kernel's
- * flusher algorithm), regular (i.e., synchronous and
- * buffered) userspace read/write requests (limited to one per
- * thread), asynchronous read requests (Linux's io_submit(2)
- * call actually blocks, so these are also limited to one per
- * thread).
- */
- unsigned max_background;
-
- /**
- * Kernel congestion threshold parameter. If the number of pending
- * background requests exceeds this number, the FUSE kernel module will
- * mark the filesystem as "congested". This instructs the kernel to
- * expect that queued requests will take some time to complete, and to
- * adjust its algorithms accordingly (e.g. by putting a waiting thread
- * to sleep instead of using a busy-loop).
- */
- unsigned congestion_threshold;
-
- /**
- * When FUSE_CAP_WRITEBACK_CACHE is enabled, the kernel is responsible
- * for updating mtime and ctime when write requests are received. The
- * updated values are passed to the filesystem with setattr() requests.
- * However, if the filesystem does not support the full resolution of
- * the kernel timestamps (nanoseconds), the mtime and ctime values used
- * by kernel and filesystem will differ (and result in an apparent
- * change of times after a cache flush).
- *
- * To prevent this problem, this variable can be used to inform the
- * kernel about the timestamp granularity supported by the file-system.
- * The value should be power of 10. The default is 1, i.e. full
- * nano-second resolution. Filesystems supporting only second resolution
- * should set this to 1000000000.
- */
- unsigned time_gran;
-
- /**
- * For future use.
- */
- unsigned reserved[22];
+ /**
+ * Major version of the protocol (read-only)
+ */
+ unsigned proto_major;
+
+ /**
+ * Minor version of the protocol (read-only)
+ */
+ unsigned proto_minor;
+
+ /**
+ * Maximum size of the write buffer
+ */
+ unsigned max_write;
+
+ /**
+ * Maximum size of read requests. A value of zero indicates no
+ * limit. However, even if the filesystem does not specify a
+ * limit, the maximum size of read requests will still be
+ * limited by the kernel.
+ *
+ * NOTE: For the time being, the maximum size of read requests
+ * must be set both here *and* passed to fuse_session_new()
+ * using the ``-o max_read=<n>`` mount option. At some point
+ * in the future, specifying the mount option will no longer
+ * be necessary.
+ */
+ unsigned max_read;
+
+ /**
+ * Maximum readahead
+ */
+ unsigned max_readahead;
+
+ /**
+ * Capability flags that the kernel supports (read-only)
+ */
+ unsigned capable;
+
+ /**
+ * Capability flags that the filesystem wants to enable.
+ *
+ * libfuse attempts to initialize this field with
+ * reasonable default values before calling the init() handler.
+ */
+ unsigned want;
+
+ /**
+ * Maximum number of pending "background" requests. A
+ * background request is any type of request for which the
+ * total number is not limited by other means. As of kernel
+ * 4.8, only two types of requests fall into this category:
+ *
+ * 1. Read-ahead requests
+ * 2. Asynchronous direct I/O requests
+ *
+ * Read-ahead requests are generated (if max_readahead is
+ * non-zero) by the kernel to preemptively fill its caches
+ * when it anticipates that userspace will soon read more
+ * data.
+ *
+ * Asynchronous direct I/O requests are generated if
+ * FUSE_CAP_ASYNC_DIO is enabled and userspace submits a large
+ * direct I/O request. In this case the kernel will internally
+ * split it up into multiple smaller requests and submit them
+ * to the filesystem concurrently.
+ *
+ * Note that the following requests are *not* background
+ * requests: writeback requests (limited by the kernel's
+ * flusher algorithm), regular (i.e., synchronous and
+ * buffered) userspace read/write requests (limited to one per
+ * thread), asynchronous read requests (Linux's io_submit(2)
+ * call actually blocks, so these are also limited to one per
+ * thread).
+ */
+ unsigned max_background;
+
+ /**
+ * Kernel congestion threshold parameter. If the number of pending
+ * background requests exceeds this number, the FUSE kernel module will
+ * mark the filesystem as "congested". This instructs the kernel to
+ * expect that queued requests will take some time to complete, and to
+ * adjust its algorithms accordingly (e.g. by putting a waiting thread
+ * to sleep instead of using a busy-loop).
+ */
+ unsigned congestion_threshold;
+
+ /**
+ * When FUSE_CAP_WRITEBACK_CACHE is enabled, the kernel is responsible
+ * for updating mtime and ctime when write requests are received. The
+ * updated values are passed to the filesystem with setattr() requests.
+ * However, if the filesystem does not support the full resolution of
+ * the kernel timestamps (nanoseconds), the mtime and ctime values used
+ * by kernel and filesystem will differ (and result in an apparent
+ * change of times after a cache flush).
+ *
+ * To prevent this problem, this variable can be used to inform the
+ * kernel about the timestamp granularity supported by the file-system.
+ * The value should be power of 10. The default is 1, i.e. full
+ * nano-second resolution. Filesystems supporting only second resolution
+ * should set this to 1000000000.
+ */
+ unsigned time_gran;
+
+ /**
+ * For future use.
+ */
+ unsigned reserved[22];
};
struct fuse_session;
@@ -489,21 +507,20 @@ struct fuse_conn_info_opts;
* -o async_read sets FUSE_CAP_ASYNC_READ in conn->want
* -o sync_read unsets FUSE_CAP_ASYNC_READ in conn->want
* -o atomic_o_trunc sets FUSE_CAP_ATOMIC_O_TRUNC in conn->want
- * -o no_remote_lock Equivalent to -o no_remote_flock,no_remote_posix_lock
- * -o no_remote_flock Unsets FUSE_CAP_FLOCK_LOCKS in conn->want
- * -o no_remote_posix_lock Unsets FUSE_CAP_POSIX_LOCKS in conn->want
- * -o [no_]splice_write (un-)sets FUSE_CAP_SPLICE_WRITE in conn->want
- * -o [no_]splice_move (un-)sets FUSE_CAP_SPLICE_MOVE in conn->want
- * -o [no_]splice_read (un-)sets FUSE_CAP_SPLICE_READ in conn->want
- * -o [no_]auto_inval_data (un-)sets FUSE_CAP_AUTO_INVAL_DATA in conn->want
- * -o readdirplus=no unsets FUSE_CAP_READDIRPLUS in conn->want
- * -o readdirplus=yes sets FUSE_CAP_READDIRPLUS and unsets
- * FUSE_CAP_READDIRPLUS_AUTO in conn->want
- * -o readdirplus=auto sets FUSE_CAP_READDIRPLUS and
- * FUSE_CAP_READDIRPLUS_AUTO in conn->want
- * -o [no_]async_dio (un-)sets FUSE_CAP_ASYNC_DIO in conn->want
- * -o [no_]writeback_cache (un-)sets FUSE_CAP_WRITEBACK_CACHE in conn->want
- * -o time_gran=N sets conn->time_gran
+ * -o no_remote_lock Equivalent to -o
+ *no_remote_flock,no_remote_posix_lock -o no_remote_flock Unsets
+ *FUSE_CAP_FLOCK_LOCKS in conn->want -o no_remote_posix_lock Unsets
+ *FUSE_CAP_POSIX_LOCKS in conn->want -o [no_]splice_write (un-)sets
+ *FUSE_CAP_SPLICE_WRITE in conn->want -o [no_]splice_move (un-)sets
+ *FUSE_CAP_SPLICE_MOVE in conn->want -o [no_]splice_read (un-)sets
+ *FUSE_CAP_SPLICE_READ in conn->want -o [no_]auto_inval_data (un-)sets
+ *FUSE_CAP_AUTO_INVAL_DATA in conn->want -o readdirplus=no unsets
+ *FUSE_CAP_READDIRPLUS in conn->want -o readdirplus=yes sets
+ *FUSE_CAP_READDIRPLUS and unsets FUSE_CAP_READDIRPLUS_AUTO in conn->want -o
+ *readdirplus=auto sets FUSE_CAP_READDIRPLUS and FUSE_CAP_READDIRPLUS_AUTO
+ *in conn->want -o [no_]async_dio (un-)sets FUSE_CAP_ASYNC_DIO in
+ *conn->want -o [no_]writeback_cache (un-)sets FUSE_CAP_WRITEBACK_CACHE in
+ *conn->want -o time_gran=N sets conn->time_gran
*
* Known options will be removed from *args*, unknown options will be
* passed through unchanged.
@@ -511,7 +528,7 @@ struct fuse_conn_info_opts;
* @param args argument vector (input+output)
* @return parsed options
**/
-struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args);
+struct fuse_conn_info_opts *fuse_parse_conn_info_opts(struct fuse_args *args);
/**
* This function applies the (parsed) parameters in *opts* to the
@@ -521,7 +538,7 @@ struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args);
* option has been explicitly set.
*/
void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts,
- struct fuse_conn_info *conn);
+ struct fuse_conn_info *conn);
/**
* Go into the background
@@ -552,81 +569,81 @@ const char *fuse_pkgversion(void);
*/
void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);
-/* ----------------------------------------------------------- *
- * Data buffer *
- * ----------------------------------------------------------- */
+/*
+ * Data buffer
+ */
/**
* Buffer flags
*/
enum fuse_buf_flags {
- /**
- * Buffer contains a file descriptor
- *
- * If this flag is set, the .fd field is valid, otherwise the
- * .mem fields is valid.
- */
- FUSE_BUF_IS_FD = (1 << 1),
-
- /**
- * Seek on the file descriptor
- *
- * If this flag is set then the .pos field is valid and is
- * used to seek to the given offset before performing
- * operation on file descriptor.
- */
- FUSE_BUF_FD_SEEK = (1 << 2),
-
- /**
- * Retry operation on file descriptor
- *
- * If this flag is set then retry operation on file descriptor
- * until .size bytes have been copied or an error or EOF is
- * detected.
- */
- FUSE_BUF_FD_RETRY = (1 << 3),
+ /**
+ * Buffer contains a file descriptor
+ *
+ * If this flag is set, the .fd field is valid, otherwise the
+ * .mem fields is valid.
+ */
+ FUSE_BUF_IS_FD = (1 << 1),
+
+ /**
+ * Seek on the file descriptor
+ *
+ * If this flag is set then the .pos field is valid and is
+ * used to seek to the given offset before performing
+ * operation on file descriptor.
+ */
+ FUSE_BUF_FD_SEEK = (1 << 2),
+
+ /**
+ * Retry operation on file descriptor
+ *
+ * If this flag is set then retry operation on file descriptor
+ * until .size bytes have been copied or an error or EOF is
+ * detected.
+ */
+ FUSE_BUF_FD_RETRY = (1 << 3),
};
/**
* Buffer copy flags
*/
enum fuse_buf_copy_flags {
- /**
- * Don't use splice(2)
- *
- * Always fall back to using read and write instead of
- * splice(2) to copy data from one file descriptor to another.
- *
- * If this flag is not set, then only fall back if splice is
- * unavailable.
- */
- FUSE_BUF_NO_SPLICE = (1 << 1),
-
- /**
- * Force splice
- *
- * Always use splice(2) to copy data from one file descriptor
- * to another. If splice is not available, return -EINVAL.
- */
- FUSE_BUF_FORCE_SPLICE = (1 << 2),
-
- /**
- * Try to move data with splice.
- *
- * If splice is used, try to move pages from the source to the
- * destination instead of copying. See documentation of
- * SPLICE_F_MOVE in splice(2) man page.
- */
- FUSE_BUF_SPLICE_MOVE = (1 << 3),
-
- /**
- * Don't block on the pipe when copying data with splice
- *
- * Makes the operations on the pipe non-blocking (if the pipe
- * is full or empty). See SPLICE_F_NONBLOCK in the splice(2)
- * man page.
- */
- FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
+ /**
+ * Don't use splice(2)
+ *
+ * Always fall back to using read and write instead of
+ * splice(2) to copy data from one file descriptor to another.
+ *
+ * If this flag is not set, then only fall back if splice is
+ * unavailable.
+ */
+ FUSE_BUF_NO_SPLICE = (1 << 1),
+
+ /**
+ * Force splice
+ *
+ * Always use splice(2) to copy data from one file descriptor
+ * to another. If splice is not available, return -EINVAL.
+ */
+ FUSE_BUF_FORCE_SPLICE = (1 << 2),
+
+ /**
+ * Try to move data with splice.
+ *
+ * If splice is used, try to move pages from the source to the
+ * destination instead of copying. See documentation of
+ * SPLICE_F_MOVE in splice(2) man page.
+ */
+ FUSE_BUF_SPLICE_MOVE = (1 << 3),
+
+ /**
+ * Don't block on the pipe when copying data with splice
+ *
+ * Makes the operations on the pipe non-blocking (if the pipe
+ * is full or empty). See SPLICE_F_NONBLOCK in the splice(2)
+ * man page.
+ */
+ FUSE_BUF_SPLICE_NONBLOCK = (1 << 4),
};
/**
@@ -636,36 +653,36 @@ enum fuse_buf_copy_flags {
* be supplied as a memory pointer or as a file descriptor
*/
struct fuse_buf {
- /**
- * Size of data in bytes
- */
- size_t size;
-
- /**
- * Buffer flags
- */
- enum fuse_buf_flags flags;
-
- /**
- * Memory pointer
- *
- * Used unless FUSE_BUF_IS_FD flag is set.
- */
- void *mem;
-
- /**
- * File descriptor
- *
- * Used if FUSE_BUF_IS_FD flag is set.
- */
- int fd;
-
- /**
- * File position
- *
- * Used if FUSE_BUF_FD_SEEK flag is set.
- */
- off_t pos;
+ /**
+ * Size of data in bytes
+ */
+ size_t size;
+
+ /**
+ * Buffer flags
+ */
+ enum fuse_buf_flags flags;
+
+ /**
+ * Memory pointer
+ *
+ * Used unless FUSE_BUF_IS_FD flag is set.
+ */
+ void *mem;
+
+ /**
+ * File descriptor
+ *
+ * Used if FUSE_BUF_IS_FD flag is set.
+ */
+ int fd;
+
+ /**
+ * File position
+ *
+ * Used if FUSE_BUF_FD_SEEK flag is set.
+ */
+ off_t pos;
};
/**
@@ -677,41 +694,39 @@ struct fuse_buf {
* Allocate dynamically to add more than one buffer.
*/
struct fuse_bufvec {
- /**
- * Number of buffers in the array
- */
- size_t count;
-
- /**
- * Index of current buffer within the array
- */
- size_t idx;
-
- /**
- * Current offset within the current buffer
- */
- size_t off;
-
- /**
- * Array of buffers
- */
- struct fuse_buf buf[1];
+ /**
+ * Number of buffers in the array
+ */
+ size_t count;
+
+ /**
+ * Index of current buffer within the array
+ */
+ size_t idx;
+
+ /**
+ * Current offset within the current buffer
+ */
+ size_t off;
+
+ /**
+ * Array of buffers
+ */
+ struct fuse_buf buf[1];
};
/* Initialize bufvec with a single buffer of given size */
-#define FUSE_BUFVEC_INIT(size__) \
- ((struct fuse_bufvec) { \
- /* .count= */ 1, \
- /* .idx = */ 0, \
- /* .off = */ 0, \
- /* .buf = */ { /* [0] = */ { \
- /* .size = */ (size__), \
- /* .flags = */ (enum fuse_buf_flags) 0, \
- /* .mem = */ NULL, \
- /* .fd = */ -1, \
- /* .pos = */ 0, \
- } } \
- } )
+#define FUSE_BUFVEC_INIT(size__) \
+ ((struct fuse_bufvec){ /* .count= */ 1, \
+ /* .idx = */ 0, \
+ /* .off = */ 0, /* .buf = */ \
+ { /* [0] = */ { \
+ /* .size = */ (size__), \
+ /* .flags = */ (enum fuse_buf_flags)0, \
+ /* .mem = */ NULL, \
+ /* .fd = */ -1, \
+ /* .pos = */ 0, \
+ } } })
/**
* Get total size of data in a fuse buffer vector
@@ -730,16 +745,16 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv);
* @return actual number of bytes copied or -errno on error
*/
ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
- enum fuse_buf_copy_flags flags);
+ enum fuse_buf_copy_flags flags);
-/* ----------------------------------------------------------- *
- * Signal handling *
- * ----------------------------------------------------------- */
+/*
+ * Signal handling
+ */
/**
* Exit session on HUP, TERM and INT signals and ignore PIPE signal
*
- * Stores session in a global variable. May only be called once per
+ * Stores session in a global variable. May only be called once per
* process until fuse_remove_signal_handlers() is called.
*
* Once either of the POSIX signals arrives, the signal handler calls
@@ -766,12 +781,12 @@ int fuse_set_signal_handlers(struct fuse_session *se);
*/
void fuse_remove_signal_handlers(struct fuse_session *se);
-/* ----------------------------------------------------------- *
- * Compatibility stuff *
- * ----------------------------------------------------------- */
+/*
+ * Compatibility stuff
+ */
#if !defined(FUSE_USE_VERSION) || FUSE_USE_VERSION < 30
-# error only API version 30 or greater is supported
+#error only API version 30 or greater is supported
#endif
@@ -781,11 +796,14 @@ void fuse_remove_signal_handlers(struct fuse_session *se);
* On 32bit systems please add -D_FILE_OFFSET_BITS=64 to your compile flags!
*/
-#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
+#if defined(__GNUC__) && \
+ (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && \
+ !defined __cplusplus
_Static_assert(sizeof(off_t) == 8, "fuse: off_t must be 64bit");
#else
-struct _fuse_off_t_must_be_64bit_dummy_struct \
- { unsigned _fuse_off_t_must_be_64bit:((sizeof(off_t) == 8) ? 1 : -1); };
+struct _fuse_off_t_must_be_64bit_dummy_struct {
+ unsigned _fuse_off_t_must_be_64bit:((sizeof(off_t) == 8) ? 1 : -1);
+};
#endif
#endif /* FUSE_COMMON_H_ */
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index b39522e3ca..e63cb58388 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -1,71 +1,71 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB
-*/
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB
+ */
#include "fuse.h"
#include "fuse_lowlevel.h"
struct fuse_req {
- struct fuse_session *se;
- uint64_t unique;
- int ctr;
- pthread_mutex_t lock;
- struct fuse_ctx ctx;
- struct fuse_chan *ch;
- int interrupted;
- unsigned int ioctl_64bit : 1;
- union {
- struct {
- uint64_t unique;
- } i;
- struct {
- fuse_interrupt_func_t func;
- void *data;
- } ni;
- } u;
- struct fuse_req *next;
- struct fuse_req *prev;
+ struct fuse_session *se;
+ uint64_t unique;
+ int ctr;
+ pthread_mutex_t lock;
+ struct fuse_ctx ctx;
+ struct fuse_chan *ch;
+ int interrupted;
+ unsigned int ioctl_64bit:1;
+ union {
+ struct {
+ uint64_t unique;
+ } i;
+ struct {
+ fuse_interrupt_func_t func;
+ void *data;
+ } ni;
+ } u;
+ struct fuse_req *next;
+ struct fuse_req *prev;
};
struct fuse_notify_req {
- uint64_t unique;
- void (*reply)(struct fuse_notify_req *, fuse_req_t, fuse_ino_t,
- const void *, const struct fuse_buf *);
- struct fuse_notify_req *next;
- struct fuse_notify_req *prev;
+ uint64_t unique;
+ void (*reply)(struct fuse_notify_req *, fuse_req_t, fuse_ino_t,
+ const void *, const struct fuse_buf *);
+ struct fuse_notify_req *next;
+ struct fuse_notify_req *prev;
};
struct fuse_session {
- char *mountpoint;
- volatile int exited;
- int fd;
- int debug;
- int deny_others;
- struct fuse_lowlevel_ops op;
- int got_init;
- struct cuse_data *cuse_data;
- void *userdata;
- uid_t owner;
- struct fuse_conn_info conn;
- struct fuse_req list;
- struct fuse_req interrupts;
- pthread_mutex_t lock;
- int got_destroy;
- int broken_splice_nonblock;
- uint64_t notify_ctr;
- struct fuse_notify_req notify_list;
- size_t bufsize;
- int error;
+ char *mountpoint;
+ volatile int exited;
+ int fd;
+ int debug;
+ int deny_others;
+ struct fuse_lowlevel_ops op;
+ int got_init;
+ struct cuse_data *cuse_data;
+ void *userdata;
+ uid_t owner;
+ struct fuse_conn_info conn;
+ struct fuse_req list;
+ struct fuse_req interrupts;
+ pthread_mutex_t lock;
+ int got_destroy;
+ int broken_splice_nonblock;
+ uint64_t notify_ctr;
+ struct fuse_notify_req notify_list;
+ size_t bufsize;
+ int error;
};
struct fuse_chan {
- pthread_mutex_t lock;
- int ctr;
- int fd;
+ pthread_mutex_t lock;
+ int ctr;
+ int fd;
};
/**
@@ -76,19 +76,20 @@ struct fuse_chan {
*
*/
struct fuse_module {
- char *name;
- fuse_module_factory_t factory;
- struct fuse_module *next;
- struct fusemod_so *so;
- int ctr;
+ char *name;
+ fuse_module_factory_t factory;
+ struct fuse_module *next;
+ struct fusemod_so *so;
+ int ctr;
};
int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
- int count);
+ int count);
void fuse_free_req(fuse_req_t req);
void fuse_session_process_buf_int(struct fuse_session *se,
- const struct fuse_buf *buf, struct fuse_chan *ch);
+ const struct fuse_buf *buf,
+ struct fuse_chan *ch);
#define FUSE_MAX_MAX_PAGES 256
diff --git a/tools/virtiofsd/fuse_log.c b/tools/virtiofsd/fuse_log.c
index 0d268ab014..11345f9ec8 100644
--- a/tools/virtiofsd/fuse_log.c
+++ b/tools/virtiofsd/fuse_log.c
@@ -1,40 +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
-*/
+ * 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)
+static void default_log_func(__attribute__((unused)) enum fuse_log_level level,
+ const char *fmt, va_list ap)
{
- vfprintf(stderr, fmt, 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;
+ if (!func) {
+ func = default_log_func;
+ }
- log_func = func;
+ log_func = func;
}
void fuse_log(enum fuse_log_level level, const char *fmt, ...)
{
- va_list ap;
+ va_list ap;
- va_start(ap, fmt);
- log_func(level, fmt, ap);
- va_end(ap);
+ va_start(ap, fmt);
+ log_func(level, fmt, ap);
+ va_end(ap);
}
diff --git a/tools/virtiofsd/fuse_log.h b/tools/virtiofsd/fuse_log.h
index 0af700da6b..bf6c11ff11 100644
--- a/tools/virtiofsd/fuse_log.h
+++ b/tools/virtiofsd/fuse_log.h
@@ -1,10 +1,10 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2019 Red Hat, Inc.
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB.
-*/
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB.
+ */
#ifndef FUSE_LOG_H_
#define FUSE_LOG_H_
@@ -22,14 +22,14 @@
* These levels correspond to syslog(2) log levels since they are widely used.
*/
enum fuse_log_level {
- FUSE_LOG_EMERG,
- FUSE_LOG_ALERT,
- FUSE_LOG_CRIT,
- FUSE_LOG_ERR,
- FUSE_LOG_WARNING,
- FUSE_LOG_NOTICE,
- FUSE_LOG_INFO,
- FUSE_LOG_DEBUG
+ FUSE_LOG_EMERG,
+ FUSE_LOG_ALERT,
+ FUSE_LOG_CRIT,
+ FUSE_LOG_ERR,
+ FUSE_LOG_WARNING,
+ FUSE_LOG_NOTICE,
+ FUSE_LOG_INFO,
+ FUSE_LOG_DEBUG
};
/**
@@ -45,8 +45,8 @@ enum fuse_log_level {
* @param fmt sprintf-style format string including newline
* @param ap format string arguments
*/
-typedef void (*fuse_log_func_t)(enum fuse_log_level level,
- const char *fmt, va_list ap);
+typedef void (*fuse_log_func_t)(enum fuse_log_level level, const char *fmt,
+ va_list ap);
/**
* Install a custom log handler function.
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index e6fa247924..5c9cb52f2a 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -1,2380 +1,2515 @@
/*
- 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
-*/
+ * 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 "fuse_opt.h"
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stddef.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>
-
+#include <unistd.h>
#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) );})
+#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;
+ uint64_t kh;
+ struct fuse_session *se;
};
static size_t pagesize;
static __attribute__((constructor)) void fuse_ll_init_pagesize(void)
{
- pagesize = getpagesize();
+ 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);
+ 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);
+ 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)
+static size_t iov_length(const struct iovec *iov, size_t count)
{
- size_t seg;
- size_t ret = 0;
+ size_t seg;
+ size_t ret = 0;
- for (seg = 0; seg < count; seg++)
- ret += iov[seg].iov_len;
- return ret;
+ 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;
+ 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;
+ 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;
+ 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);
+ pthread_mutex_destroy(&req->lock);
+ free(req);
}
void fuse_free_req(fuse_req_t req)
{
- int ctr;
- struct fuse_session *se = req->se;
+ 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;
- req->ch = NULL;
- pthread_mutex_unlock(&se->lock);
- if (!ctr)
- destroy_req(req);
+ pthread_mutex_lock(&se->lock);
+ req->u.ni.func = NULL;
+ req->u.ni.data = NULL;
+ list_del_req(req);
+ ctr = --req->ctr;
+ 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;
+ 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);
- }
+ 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;
+ 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 iovec *iov, int count)
{
- struct fuse_out_header *out = iov[0].iov_base;
+ 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);
- }
- }
+ 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);
+ }
+ }
- abort(); /* virtio should have taken it before here */
- return 0;
+ abort(); /* virtio should have taken it before here */
+ return 0;
}
int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
- int count)
+ int count)
{
- struct fuse_out_header out;
+ struct fuse_out_header out;
- if (error <= -1000 || error > 0) {
- fuse_log(FUSE_LOG_ERR, "fuse: bad error value: %i\n", error);
- error = -ERANGE;
- }
+ 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;
+ out.unique = req->unique;
+ out.error = error;
- iov[0].iov_base = &out;
- iov[0].iov_len = sizeof(struct fuse_out_header);
+ iov[0].iov_base = &out;
+ iov[0].iov_len = sizeof(struct fuse_out_header);
- return fuse_send_msg(req->se, req->ch, iov, count);
+ 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 count)
{
- int res;
+ int res;
- res = fuse_send_reply_iov_nofree(req, error, iov, count);
- fuse_free_req(req);
- return 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)
+ 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);
+ 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;
+ int res;
+ struct iovec *padded_iov;
- padded_iov = malloc((count + 1) * sizeof(struct iovec));
- if (padded_iov == NULL)
- return fuse_reply_err(req, ENOMEM);
+ 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++;
+ memcpy(padded_iov + 1, iov, count * sizeof(struct iovec));
+ count++;
- res = send_reply_iov(req, 0, padded_iov, count);
- free(padded_iov);
+ res = send_reply_iov(req, 0, padded_iov, count);
+ free(padded_iov);
- return res;
+ return res;
}
-/* `buf` is allowed to be empty so that the proper size may be
- allocated by the caller */
+/*
+ * '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)
+ 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;
+ (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);
+ namelen = strlen(name);
+ entlen = FUSE_NAME_OFFSET + namelen;
+ entlen_padded = FUSE_DIRENT_ALIGN(entlen);
- if ((buf == NULL) || (entlen_padded > bufsize))
- return entlen_padded;
+ 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);
+ 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;
+ return entlen_padded;
}
static void convert_statfs(const struct statvfs *stbuf,
- struct fuse_kstatfs *kstatfs)
+ 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;
+ 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);
+ return send_reply(req, 0, arg, argsize);
}
int fuse_reply_err(fuse_req_t req, int err)
{
- return send_reply(req, -err, NULL, 0);
+ return send_reply(req, -err, NULL, 0);
}
void fuse_reply_none(fuse_req_t req)
{
- fuse_free_req(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;
+ 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);
+ 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)
+ 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);
+ 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 */
+/*
+ * `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;
+ 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);
+ 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);
+ /*
+ * 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);
+ 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)
+ 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);
+ 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));
+ 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)
+ double attr_timeout)
{
- struct fuse_attr_out arg;
- size_t size = req->se->conn.proto_minor < 9 ?
- FUSE_COMPAT_ATTR_OUT_SIZE : sizeof(arg);
+ 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);
+ 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);
+ 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));
+ 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;
+ struct fuse_open_out arg;
- memset(&arg, 0, sizeof(arg));
- fill_open(&arg, f);
- return send_reply_ok(req, &arg, sizeof(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;
+ struct fuse_write_out arg;
- memset(&arg, 0, sizeof(arg));
- arg.size = count;
+ memset(&arg, 0, sizeof(arg));
+ arg.size = count;
- return send_reply_ok(req, &arg, sizeof(arg));
+ 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);
+ 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_chan *ch, struct iovec *iov,
+ int iov_count, struct fuse_bufvec *buf,
+ size_t len)
{
- /* 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 */
+ /* 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);
- }
+ 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);
+ }
- abort(); /* Will have taken vhost path */
- return 0;
+ abort(); /* Will have taken vhost path */
+ return 0;
}
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)
+ struct iovec *iov, int iov_count,
+ struct fuse_bufvec *buf, unsigned int flags)
{
- size_t len = fuse_buf_size(buf);
- (void) flags;
+ size_t len = fuse_buf_size(buf);
+ (void)flags;
- return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
+ return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
}
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
- enum fuse_buf_copy_flags flags)
+ enum fuse_buf_copy_flags flags)
{
- struct iovec iov[2];
- struct fuse_out_header out;
- int res;
+ struct iovec iov[2];
+ struct fuse_out_header out;
+ int res;
- iov[0].iov_base = &out;
- iov[0].iov_len = sizeof(struct fuse_out_header);
+ iov[0].iov_base = &out;
+ iov[0].iov_len = sizeof(struct fuse_out_header);
- out.unique = req->unique;
- out.error = 0;
+ out.unique = req->unique;
+ out.error = 0;
- res = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv, flags);
- if (res <= 0) {
- fuse_free_req(req);
- return res;
- } else {
- return fuse_reply_err(req, res);
- }
+ res = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv, flags);
+ if (res <= 0) {
+ fuse_free_req(req);
+ return res;
+ } else {
+ return fuse_reply_err(req, res);
+ }
}
int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
{
- struct fuse_statfs_out arg;
- size_t size = req->se->conn.proto_minor < 4 ?
- FUSE_COMPAT_STATFS_SIZE : sizeof(arg);
+ struct fuse_statfs_out arg;
+ size_t size =
+ req->se->conn.proto_minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(arg);
- memset(&arg, 0, sizeof(arg));
- convert_statfs(stbuf, &arg.st);
+ memset(&arg, 0, sizeof(arg));
+ convert_statfs(stbuf, &arg.st);
- return send_reply_ok(req, &arg, size);
+ return send_reply_ok(req, &arg, size);
}
int fuse_reply_xattr(fuse_req_t req, size_t count)
{
- struct fuse_getxattr_out arg;
+ struct fuse_getxattr_out arg;
- memset(&arg, 0, sizeof(arg));
- arg.size = count;
+ memset(&arg, 0, sizeof(arg));
+ arg.size = count;
- return send_reply_ok(req, &arg, sizeof(arg));
+ return send_reply_ok(req, &arg, sizeof(arg));
}
int fuse_reply_lock(fuse_req_t req, const struct flock *lock)
{
- struct fuse_lk_out arg;
+ struct fuse_lk_out arg;
- memset(&arg, 0, sizeof(arg));
- arg.lk.type = lock->l_type;
- if (lock->l_type != F_UNLCK) {
- arg.lk.start = lock->l_start;
- if (lock->l_len == 0)
- arg.lk.end = OFFSET_MAX;
- else
- arg.lk.end = lock->l_start + lock->l_len - 1;
- }
- arg.lk.pid = lock->l_pid;
- return send_reply_ok(req, &arg, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
+ arg.lk.type = lock->l_type;
+ if (lock->l_type != F_UNLCK) {
+ arg.lk.start = lock->l_start;
+ if (lock->l_len == 0) {
+ arg.lk.end = OFFSET_MAX;
+ } else {
+ arg.lk.end = lock->l_start + lock->l_len - 1;
+ }
+ }
+ arg.lk.pid = lock->l_pid;
+ return send_reply_ok(req, &arg, sizeof(arg));
}
int fuse_reply_bmap(fuse_req_t req, uint64_t idx)
{
- struct fuse_bmap_out arg;
+ struct fuse_bmap_out arg;
- memset(&arg, 0, sizeof(arg));
- arg.block = idx;
+ memset(&arg, 0, sizeof(arg));
+ arg.block = idx;
- return send_reply_ok(req, &arg, sizeof(arg));
+ return send_reply_ok(req, &arg, sizeof(arg));
}
static struct fuse_ioctl_iovec *fuse_ioctl_iovec_copy(const struct iovec *iov,
- size_t count)
-{
- struct fuse_ioctl_iovec *fiov;
- size_t i;
-
- fiov = malloc(sizeof(fiov[0]) * count);
- if (!fiov)
- return NULL;
-
- for (i = 0; i < count; i++) {
- fiov[i].base = (uintptr_t) iov[i].iov_base;
- fiov[i].len = iov[i].iov_len;
- }
-
- return fiov;
-}
-
-int fuse_reply_ioctl_retry(fuse_req_t req,
- const struct iovec *in_iov, size_t in_count,
- const struct iovec *out_iov, size_t out_count)
-{
- struct fuse_ioctl_out arg;
- struct fuse_ioctl_iovec *in_fiov = NULL;
- struct fuse_ioctl_iovec *out_fiov = NULL;
- struct iovec iov[4];
- size_t count = 1;
- int res;
-
- memset(&arg, 0, sizeof(arg));
- arg.flags |= FUSE_IOCTL_RETRY;
- arg.in_iovs = in_count;
- arg.out_iovs = out_count;
- iov[count].iov_base = &arg;
- iov[count].iov_len = sizeof(arg);
- count++;
-
- if (req->se->conn.proto_minor < 16) {
- if (in_count) {
- iov[count].iov_base = (void *)in_iov;
- iov[count].iov_len = sizeof(in_iov[0]) * in_count;
- count++;
- }
-
- if (out_count) {
- iov[count].iov_base = (void *)out_iov;
- iov[count].iov_len = sizeof(out_iov[0]) * out_count;
- count++;
- }
- } else {
- /* Can't handle non-compat 64bit ioctls on 32bit */
- if (sizeof(void *) == 4 && req->ioctl_64bit) {
- res = fuse_reply_err(req, EINVAL);
- goto out;
- }
-
- if (in_count) {
- in_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);
- if (!in_fiov)
- goto enomem;
-
- iov[count].iov_base = (void *)in_fiov;
- iov[count].iov_len = sizeof(in_fiov[0]) * in_count;
- count++;
- }
- if (out_count) {
- out_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);
- if (!out_fiov)
- goto enomem;
-
- iov[count].iov_base = (void *)out_fiov;
- iov[count].iov_len = sizeof(out_fiov[0]) * out_count;
- count++;
- }
- }
-
- res = send_reply_iov(req, 0, iov, count);
+ size_t count)
+{
+ struct fuse_ioctl_iovec *fiov;
+ size_t i;
+
+ fiov = malloc(sizeof(fiov[0]) * count);
+ if (!fiov) {
+ return NULL;
+ }
+
+ for (i = 0; i < count; i++) {
+ fiov[i].base = (uintptr_t)iov[i].iov_base;
+ fiov[i].len = iov[i].iov_len;
+ }
+
+ return fiov;
+}
+
+int fuse_reply_ioctl_retry(fuse_req_t req, const struct iovec *in_iov,
+ size_t in_count, const struct iovec *out_iov,
+ size_t out_count)
+{
+ struct fuse_ioctl_out arg;
+ struct fuse_ioctl_iovec *in_fiov = NULL;
+ struct fuse_ioctl_iovec *out_fiov = NULL;
+ struct iovec iov[4];
+ size_t count = 1;
+ int res;
+
+ memset(&arg, 0, sizeof(arg));
+ arg.flags |= FUSE_IOCTL_RETRY;
+ arg.in_iovs = in_count;
+ arg.out_iovs = out_count;
+ iov[count].iov_base = &arg;
+ iov[count].iov_len = sizeof(arg);
+ count++;
+
+ if (req->se->conn.proto_minor < 16) {
+ if (in_count) {
+ iov[count].iov_base = (void *)in_iov;
+ iov[count].iov_len = sizeof(in_iov[0]) * in_count;
+ count++;
+ }
+
+ if (out_count) {
+ iov[count].iov_base = (void *)out_iov;
+ iov[count].iov_len = sizeof(out_iov[0]) * out_count;
+ count++;
+ }
+ } else {
+ /* Can't handle non-compat 64bit ioctls on 32bit */
+ if (sizeof(void *) == 4 && req->ioctl_64bit) {
+ res = fuse_reply_err(req, EINVAL);
+ goto out;
+ }
+
+ if (in_count) {
+ in_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);
+ if (!in_fiov) {
+ goto enomem;
+ }
+
+ iov[count].iov_base = (void *)in_fiov;
+ iov[count].iov_len = sizeof(in_fiov[0]) * in_count;
+ count++;
+ }
+ if (out_count) {
+ out_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);
+ if (!out_fiov) {
+ goto enomem;
+ }
+
+ iov[count].iov_base = (void *)out_fiov;
+ iov[count].iov_len = sizeof(out_fiov[0]) * out_count;
+ count++;
+ }
+ }
+
+ res = send_reply_iov(req, 0, iov, count);
out:
- free(in_fiov);
- free(out_fiov);
+ free(in_fiov);
+ free(out_fiov);
- return res;
+ return res;
enomem:
- res = fuse_reply_err(req, ENOMEM);
- goto out;
+ res = fuse_reply_err(req, ENOMEM);
+ goto out;
}
int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size)
{
- struct fuse_ioctl_out arg;
- struct iovec iov[3];
- size_t count = 1;
+ struct fuse_ioctl_out arg;
+ struct iovec iov[3];
+ size_t count = 1;
- memset(&arg, 0, sizeof(arg));
- arg.result = result;
- iov[count].iov_base = &arg;
- iov[count].iov_len = sizeof(arg);
- count++;
+ memset(&arg, 0, sizeof(arg));
+ arg.result = result;
+ iov[count].iov_base = &arg;
+ iov[count].iov_len = sizeof(arg);
+ count++;
- if (size) {
- iov[count].iov_base = (char *) buf;
- iov[count].iov_len = size;
- count++;
- }
+ if (size) {
+ iov[count].iov_base = (char *)buf;
+ iov[count].iov_len = size;
+ count++;
+ }
- return send_reply_iov(req, 0, iov, count);
+ return send_reply_iov(req, 0, iov, count);
}
int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
- int count)
+ int count)
{
- struct iovec *padded_iov;
- struct fuse_ioctl_out arg;
- int res;
+ struct iovec *padded_iov;
+ struct fuse_ioctl_out arg;
+ int res;
- padded_iov = malloc((count + 2) * sizeof(struct iovec));
- if (padded_iov == NULL)
- return fuse_reply_err(req, ENOMEM);
+ padded_iov = malloc((count + 2) * sizeof(struct iovec));
+ if (padded_iov == NULL) {
+ return fuse_reply_err(req, ENOMEM);
+ }
- memset(&arg, 0, sizeof(arg));
- arg.result = result;
- padded_iov[1].iov_base = &arg;
- padded_iov[1].iov_len = sizeof(arg);
+ memset(&arg, 0, sizeof(arg));
+ arg.result = result;
+ padded_iov[1].iov_base = &arg;
+ padded_iov[1].iov_len = sizeof(arg);
- memcpy(&padded_iov[2], iov, count * sizeof(struct iovec));
+ memcpy(&padded_iov[2], iov, count * sizeof(struct iovec));
- res = send_reply_iov(req, 0, padded_iov, count + 2);
- free(padded_iov);
+ res = send_reply_iov(req, 0, padded_iov, count + 2);
+ free(padded_iov);
- return res;
+ return res;
}
int fuse_reply_poll(fuse_req_t req, unsigned revents)
{
- struct fuse_poll_out arg;
+ struct fuse_poll_out arg;
- memset(&arg, 0, sizeof(arg));
- arg.revents = revents;
+ memset(&arg, 0, sizeof(arg));
+ arg.revents = revents;
- return send_reply_ok(req, &arg, sizeof(arg));
+ return send_reply_ok(req, &arg, sizeof(arg));
}
int fuse_reply_lseek(fuse_req_t req, off_t off)
{
- struct fuse_lseek_out arg;
+ struct fuse_lseek_out arg;
- memset(&arg, 0, sizeof(arg));
- arg.offset = off;
+ memset(&arg, 0, sizeof(arg));
+ arg.offset = off;
- return send_reply_ok(req, &arg, sizeof(arg));
+ return send_reply_ok(req, &arg, sizeof(arg));
}
static void do_lookup(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- char *name = (char *) inarg;
+ char *name = (char *)inarg;
- if (req->se->op.lookup)
- req->se->op.lookup(req, nodeid, name);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.lookup) {
+ req->se->op.lookup(req, nodeid, name);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_forget(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_forget_in *arg = (struct fuse_forget_in *) inarg;
+ struct fuse_forget_in *arg = (struct fuse_forget_in *)inarg;
- if (req->se->op.forget)
- req->se->op.forget(req, nodeid, arg->nlookup);
- else
- fuse_reply_none(req);
+ if (req->se->op.forget) {
+ req->se->op.forget(req, nodeid, arg->nlookup);
+ } else {
+ fuse_reply_none(req);
+ }
}
static void do_batch_forget(fuse_req_t req, fuse_ino_t nodeid,
- const void *inarg)
+ const void *inarg)
{
- struct fuse_batch_forget_in *arg = (void *) inarg;
- struct fuse_forget_one *param = (void *) PARAM(arg);
- unsigned int i;
+ struct fuse_batch_forget_in *arg = (void *)inarg;
+ struct fuse_forget_one *param = (void *)PARAM(arg);
+ unsigned int i;
- (void) nodeid;
+ (void)nodeid;
- if (req->se->op.forget_multi) {
- req->se->op.forget_multi(req, arg->count,
- (struct fuse_forget_data *) param);
- } else if (req->se->op.forget) {
- for (i = 0; i < arg->count; i++) {
- struct fuse_forget_one *forget = ¶m[i];
- struct fuse_req *dummy_req;
+ if (req->se->op.forget_multi) {
+ req->se->op.forget_multi(req, arg->count,
+ (struct fuse_forget_data *)param);
+ } else if (req->se->op.forget) {
+ for (i = 0; i < arg->count; i++) {
+ struct fuse_forget_one *forget = ¶m[i];
+ struct fuse_req *dummy_req;
- dummy_req = fuse_ll_alloc_req(req->se);
- if (dummy_req == NULL)
- break;
+ dummy_req = fuse_ll_alloc_req(req->se);
+ if (dummy_req == NULL) {
+ break;
+ }
- dummy_req->unique = req->unique;
- dummy_req->ctx = req->ctx;
- dummy_req->ch = NULL;
+ dummy_req->unique = req->unique;
+ dummy_req->ctx = req->ctx;
+ dummy_req->ch = NULL;
- req->se->op.forget(dummy_req, forget->nodeid,
- forget->nlookup);
- }
- fuse_reply_none(req);
- } else {
- fuse_reply_none(req);
- }
+ req->se->op.forget(dummy_req, forget->nodeid, forget->nlookup);
+ }
+ fuse_reply_none(req);
+ } else {
+ fuse_reply_none(req);
+ }
}
static void do_getattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_file_info *fip = NULL;
- struct fuse_file_info fi;
+ struct fuse_file_info *fip = NULL;
+ struct fuse_file_info fi;
- if (req->se->conn.proto_minor >= 9) {
- struct fuse_getattr_in *arg = (struct fuse_getattr_in *) inarg;
+ if (req->se->conn.proto_minor >= 9) {
+ struct fuse_getattr_in *arg = (struct fuse_getattr_in *)inarg;
- if (arg->getattr_flags & FUSE_GETATTR_FH) {
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- fip = &fi;
- }
- }
+ if (arg->getattr_flags & FUSE_GETATTR_FH) {
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fip = &fi;
+ }
+ }
- if (req->se->op.getattr)
- req->se->op.getattr(req, nodeid, fip);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.getattr) {
+ req->se->op.getattr(req, nodeid, fip);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_setattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_setattr_in *arg = (struct fuse_setattr_in *) inarg;
-
- if (req->se->op.setattr) {
- struct fuse_file_info *fi = NULL;
- struct fuse_file_info fi_store;
- struct stat stbuf;
- memset(&stbuf, 0, sizeof(stbuf));
- convert_attr(arg, &stbuf);
- if (arg->valid & FATTR_FH) {
- arg->valid &= ~FATTR_FH;
- memset(&fi_store, 0, sizeof(fi_store));
- fi = &fi_store;
- fi->fh = arg->fh;
- }
- arg->valid &=
- FUSE_SET_ATTR_MODE |
- FUSE_SET_ATTR_UID |
- FUSE_SET_ATTR_GID |
- FUSE_SET_ATTR_SIZE |
- FUSE_SET_ATTR_ATIME |
- FUSE_SET_ATTR_MTIME |
- FUSE_SET_ATTR_ATIME_NOW |
- FUSE_SET_ATTR_MTIME_NOW |
- FUSE_SET_ATTR_CTIME;
-
- req->se->op.setattr(req, nodeid, &stbuf, arg->valid, fi);
- } else
- fuse_reply_err(req, ENOSYS);
+ struct fuse_setattr_in *arg = (struct fuse_setattr_in *)inarg;
+
+ if (req->se->op.setattr) {
+ struct fuse_file_info *fi = NULL;
+ struct fuse_file_info fi_store;
+ struct stat stbuf;
+ memset(&stbuf, 0, sizeof(stbuf));
+ convert_attr(arg, &stbuf);
+ if (arg->valid & FATTR_FH) {
+ arg->valid &= ~FATTR_FH;
+ memset(&fi_store, 0, sizeof(fi_store));
+ fi = &fi_store;
+ fi->fh = arg->fh;
+ }
+ arg->valid &= FUSE_SET_ATTR_MODE | FUSE_SET_ATTR_UID |
+ FUSE_SET_ATTR_GID | FUSE_SET_ATTR_SIZE |
+ FUSE_SET_ATTR_ATIME | FUSE_SET_ATTR_MTIME |
+ FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW |
+ FUSE_SET_ATTR_CTIME;
+
+ req->se->op.setattr(req, nodeid, &stbuf, arg->valid, fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_access(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_access_in *arg = (struct fuse_access_in *) inarg;
+ struct fuse_access_in *arg = (struct fuse_access_in *)inarg;
- if (req->se->op.access)
- req->se->op.access(req, nodeid, arg->mask);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.access) {
+ req->se->op.access(req, nodeid, arg->mask);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_readlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- (void) inarg;
+ (void)inarg;
- if (req->se->op.readlink)
- req->se->op.readlink(req, nodeid);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.readlink) {
+ req->se->op.readlink(req, nodeid);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_mknod(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_mknod_in *arg = (struct fuse_mknod_in *) inarg;
- char *name = PARAM(arg);
+ struct fuse_mknod_in *arg = (struct fuse_mknod_in *)inarg;
+ char *name = PARAM(arg);
- if (req->se->conn.proto_minor >= 12)
- req->ctx.umask = arg->umask;
- else
- name = (char *) inarg + FUSE_COMPAT_MKNOD_IN_SIZE;
+ if (req->se->conn.proto_minor >= 12) {
+ req->ctx.umask = arg->umask;
+ } else {
+ name = (char *)inarg + FUSE_COMPAT_MKNOD_IN_SIZE;
+ }
- if (req->se->op.mknod)
- req->se->op.mknod(req, nodeid, name, arg->mode, arg->rdev);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.mknod) {
+ req->se->op.mknod(req, nodeid, name, arg->mode, arg->rdev);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_mkdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *) inarg;
+ struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *)inarg;
- if (req->se->conn.proto_minor >= 12)
- req->ctx.umask = arg->umask;
+ if (req->se->conn.proto_minor >= 12) {
+ req->ctx.umask = arg->umask;
+ }
- if (req->se->op.mkdir)
- req->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.mkdir) {
+ req->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_unlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- char *name = (char *) inarg;
+ char *name = (char *)inarg;
- if (req->se->op.unlink)
- req->se->op.unlink(req, nodeid, name);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.unlink) {
+ req->se->op.unlink(req, nodeid, name);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_rmdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- char *name = (char *) inarg;
+ char *name = (char *)inarg;
- if (req->se->op.rmdir)
- req->se->op.rmdir(req, nodeid, name);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.rmdir) {
+ req->se->op.rmdir(req, nodeid, name);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_symlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- char *name = (char *) inarg;
- char *linkname = ((char *) inarg) + strlen((char *) inarg) + 1;
+ char *name = (char *)inarg;
+ char *linkname = ((char *)inarg) + strlen((char *)inarg) + 1;
- if (req->se->op.symlink)
- req->se->op.symlink(req, linkname, nodeid, name);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.symlink) {
+ req->se->op.symlink(req, linkname, nodeid, name);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_rename(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_rename_in *arg = (struct fuse_rename_in *) inarg;
- char *oldname = PARAM(arg);
- char *newname = oldname + strlen(oldname) + 1;
+ struct fuse_rename_in *arg = (struct fuse_rename_in *)inarg;
+ char *oldname = PARAM(arg);
+ char *newname = oldname + strlen(oldname) + 1;
- if (req->se->op.rename)
- req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
- 0);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.rename) {
+ req->se->op.rename(req, nodeid, oldname, arg->newdir, newname, 0);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_rename2(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_rename2_in *arg = (struct fuse_rename2_in *) inarg;
- char *oldname = PARAM(arg);
- char *newname = oldname + strlen(oldname) + 1;
+ struct fuse_rename2_in *arg = (struct fuse_rename2_in *)inarg;
+ char *oldname = PARAM(arg);
+ char *newname = oldname + strlen(oldname) + 1;
- if (req->se->op.rename)
- req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
- arg->flags);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.rename) {
+ req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
+ arg->flags);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_link(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_link_in *arg = (struct fuse_link_in *) inarg;
+ struct fuse_link_in *arg = (struct fuse_link_in *)inarg;
- if (req->se->op.link)
- req->se->op.link(req, arg->oldnodeid, nodeid, PARAM(arg));
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.link) {
+ req->se->op.link(req, arg->oldnodeid, nodeid, PARAM(arg));
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_create(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_create_in *arg = (struct fuse_create_in *) inarg;
+ struct fuse_create_in *arg = (struct fuse_create_in *)inarg;
- if (req->se->op.create) {
- struct fuse_file_info fi;
- char *name = PARAM(arg);
+ if (req->se->op.create) {
+ struct fuse_file_info fi;
+ char *name = PARAM(arg);
- memset(&fi, 0, sizeof(fi));
- fi.flags = arg->flags;
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
- if (req->se->conn.proto_minor >= 12)
- req->ctx.umask = arg->umask;
- else
- name = (char *) inarg + sizeof(struct fuse_open_in);
+ if (req->se->conn.proto_minor >= 12) {
+ req->ctx.umask = arg->umask;
+ } else {
+ name = (char *)inarg + sizeof(struct fuse_open_in);
+ }
- req->se->op.create(req, nodeid, name, arg->mode, &fi);
- } else
- fuse_reply_err(req, ENOSYS);
+ req->se->op.create(req, nodeid, name, arg->mode, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_open(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_open_in *arg = (struct fuse_open_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_open_in *arg = (struct fuse_open_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.flags = arg->flags;
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
- if (req->se->op.open)
- req->se->op.open(req, nodeid, &fi);
- else
- fuse_reply_open(req, &fi);
+ if (req->se->op.open) {
+ req->se->op.open(req, nodeid, &fi);
+ } else {
+ fuse_reply_open(req, &fi);
+ }
}
static void do_read(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
+ struct fuse_read_in *arg = (struct fuse_read_in *)inarg;
- if (req->se->op.read) {
- struct fuse_file_info fi;
+ if (req->se->op.read) {
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- if (req->se->conn.proto_minor >= 9) {
- fi.lock_owner = arg->lock_owner;
- fi.flags = arg->flags;
- }
- req->se->op.read(req, nodeid, arg->size, arg->offset, &fi);
- } else
- fuse_reply_err(req, ENOSYS);
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ if (req->se->conn.proto_minor >= 9) {
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ }
+ req->se->op.read(req, nodeid, arg->size, arg->offset, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_write_in *arg = (struct fuse_write_in *) inarg;
- struct fuse_file_info fi;
- char *param;
+ struct fuse_write_in *arg = (struct fuse_write_in *)inarg;
+ struct fuse_file_info fi;
+ char *param;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- fi.writepage = (arg->write_flags & FUSE_WRITE_CACHE) != 0;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.writepage = (arg->write_flags & FUSE_WRITE_CACHE) != 0;
- if (req->se->conn.proto_minor < 9) {
- param = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;
- } else {
- fi.lock_owner = arg->lock_owner;
- fi.flags = arg->flags;
- param = PARAM(arg);
- }
+ if (req->se->conn.proto_minor < 9) {
+ param = ((char *)arg) + FUSE_COMPAT_WRITE_IN_SIZE;
+ } else {
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ param = PARAM(arg);
+ }
- if (req->se->op.write)
- req->se->op.write(req, nodeid, param, arg->size,
- arg->offset, &fi);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.write) {
+ req->se->op.write(req, nodeid, param, arg->size, arg->offset, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
- const struct fuse_buf *ibuf)
-{
- struct fuse_session *se = req->se;
- struct fuse_bufvec bufv = {
- .buf[0] = *ibuf,
- .count = 1,
- };
- struct fuse_write_in *arg = (struct fuse_write_in *) inarg;
- struct fuse_file_info fi;
-
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- fi.writepage = arg->write_flags & FUSE_WRITE_CACHE;
-
- if (se->conn.proto_minor < 9) {
- bufv.buf[0].mem = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;
- bufv.buf[0].size -= sizeof(struct fuse_in_header) +
- FUSE_COMPAT_WRITE_IN_SIZE;
- assert(!(bufv.buf[0].flags & FUSE_BUF_IS_FD));
- } else {
- fi.lock_owner = arg->lock_owner;
- fi.flags = arg->flags;
- if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
- bufv.buf[0].mem = PARAM(arg);
-
- bufv.buf[0].size -= sizeof(struct fuse_in_header) +
- sizeof(struct fuse_write_in);
- }
- if (bufv.buf[0].size < arg->size) {
- fuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");
- fuse_reply_err(req, EIO);
- return;
- }
- bufv.buf[0].size = arg->size;
-
- se->op.write_buf(req, nodeid, &bufv, arg->offset, &fi);
+ const struct fuse_buf *ibuf)
+{
+ struct fuse_session *se = req->se;
+ struct fuse_bufvec bufv = {
+ .buf[0] = *ibuf,
+ .count = 1,
+ };
+ struct fuse_write_in *arg = (struct fuse_write_in *)inarg;
+ struct fuse_file_info fi;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.writepage = arg->write_flags & FUSE_WRITE_CACHE;
+
+ if (se->conn.proto_minor < 9) {
+ bufv.buf[0].mem = ((char *)arg) + FUSE_COMPAT_WRITE_IN_SIZE;
+ bufv.buf[0].size -=
+ sizeof(struct fuse_in_header) + FUSE_COMPAT_WRITE_IN_SIZE;
+ assert(!(bufv.buf[0].flags & FUSE_BUF_IS_FD));
+ } else {
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD)) {
+ bufv.buf[0].mem = PARAM(arg);
+ }
+
+ bufv.buf[0].size -=
+ sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in);
+ }
+ if (bufv.buf[0].size < arg->size) {
+ fuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");
+ fuse_reply_err(req, EIO);
+ return;
+ }
+ bufv.buf[0].size = arg->size;
+
+ se->op.write_buf(req, nodeid, &bufv, arg->offset, &fi);
}
static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_flush_in *arg = (struct fuse_flush_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_flush_in *arg = (struct fuse_flush_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- fi.flush = 1;
- if (req->se->conn.proto_minor >= 7)
- fi.lock_owner = arg->lock_owner;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.flush = 1;
+ if (req->se->conn.proto_minor >= 7) {
+ fi.lock_owner = arg->lock_owner;
+ }
- if (req->se->op.flush)
- req->se->op.flush(req, nodeid, &fi);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.flush) {
+ req->se->op.flush(req, nodeid, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_release(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_release_in *arg = (struct fuse_release_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_release_in *arg = (struct fuse_release_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.flags = arg->flags;
- fi.fh = arg->fh;
- if (req->se->conn.proto_minor >= 8) {
- fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
- fi.lock_owner = arg->lock_owner;
- }
- if (arg->release_flags & FUSE_RELEASE_FLOCK_UNLOCK) {
- fi.flock_release = 1;
- fi.lock_owner = arg->lock_owner;
- }
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
+ fi.fh = arg->fh;
+ if (req->se->conn.proto_minor >= 8) {
+ fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
+ fi.lock_owner = arg->lock_owner;
+ }
+ if (arg->release_flags & FUSE_RELEASE_FLOCK_UNLOCK) {
+ fi.flock_release = 1;
+ fi.lock_owner = arg->lock_owner;
+ }
- if (req->se->op.release)
- req->se->op.release(req, nodeid, &fi);
- else
- fuse_reply_err(req, 0);
+ if (req->se->op.release) {
+ req->se->op.release(req, nodeid, &fi);
+ } else {
+ fuse_reply_err(req, 0);
+ }
}
static void do_fsync(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;
- struct fuse_file_info fi;
- int datasync = arg->fsync_flags & 1;
+ struct fuse_fsync_in *arg = (struct fuse_fsync_in *)inarg;
+ struct fuse_file_info fi;
+ int datasync = arg->fsync_flags & 1;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
- if (req->se->op.fsync)
- req->se->op.fsync(req, nodeid, datasync, &fi);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.fsync) {
+ req->se->op.fsync(req, nodeid, datasync, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_opendir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_open_in *arg = (struct fuse_open_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_open_in *arg = (struct fuse_open_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.flags = arg->flags;
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
- if (req->se->op.opendir)
- req->se->op.opendir(req, nodeid, &fi);
- else
- fuse_reply_open(req, &fi);
+ if (req->se->op.opendir) {
+ req->se->op.opendir(req, nodeid, &fi);
+ } else {
+ fuse_reply_open(req, &fi);
+ }
}
static void do_readdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_read_in *arg = (struct fuse_read_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
- if (req->se->op.readdir)
- req->se->op.readdir(req, nodeid, arg->size, arg->offset, &fi);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.readdir) {
+ req->se->op.readdir(req, nodeid, arg->size, arg->offset, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_readdirplus(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_read_in *arg = (struct fuse_read_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
- if (req->se->op.readdirplus)
- req->se->op.readdirplus(req, nodeid, arg->size, arg->offset, &fi);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.readdirplus) {
+ req->se->op.readdirplus(req, nodeid, arg->size, arg->offset, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_releasedir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_release_in *arg = (struct fuse_release_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_release_in *arg = (struct fuse_release_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.flags = arg->flags;
- fi.fh = arg->fh;
+ memset(&fi, 0, sizeof(fi));
+ fi.flags = arg->flags;
+ fi.fh = arg->fh;
- if (req->se->op.releasedir)
- req->se->op.releasedir(req, nodeid, &fi);
- else
- fuse_reply_err(req, 0);
+ if (req->se->op.releasedir) {
+ req->se->op.releasedir(req, nodeid, &fi);
+ } else {
+ fuse_reply_err(req, 0);
+ }
}
static void do_fsyncdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;
- struct fuse_file_info fi;
- int datasync = arg->fsync_flags & 1;
+ struct fuse_fsync_in *arg = (struct fuse_fsync_in *)inarg;
+ struct fuse_file_info fi;
+ int datasync = arg->fsync_flags & 1;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
- if (req->se->op.fsyncdir)
- req->se->op.fsyncdir(req, nodeid, datasync, &fi);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.fsyncdir) {
+ req->se->op.fsyncdir(req, nodeid, datasync, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_statfs(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- (void) nodeid;
- (void) inarg;
+ (void)nodeid;
+ (void)inarg;
- if (req->se->op.statfs)
- req->se->op.statfs(req, nodeid);
- else {
- struct statvfs buf = {
- .f_namemax = 255,
- .f_bsize = 512,
- };
- fuse_reply_statfs(req, &buf);
- }
+ if (req->se->op.statfs) {
+ req->se->op.statfs(req, nodeid);
+ } else {
+ struct statvfs buf = {
+ .f_namemax = 255,
+ .f_bsize = 512,
+ };
+ fuse_reply_statfs(req, &buf);
+ }
}
static void do_setxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_setxattr_in *arg = (struct fuse_setxattr_in *) inarg;
- char *name = PARAM(arg);
- char *value = name + strlen(name) + 1;
+ struct fuse_setxattr_in *arg = (struct fuse_setxattr_in *)inarg;
+ char *name = PARAM(arg);
+ char *value = name + strlen(name) + 1;
- if (req->se->op.setxattr)
- req->se->op.setxattr(req, nodeid, name, value, arg->size,
- arg->flags);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.setxattr) {
+ req->se->op.setxattr(req, nodeid, name, value, arg->size, arg->flags);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_getxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;
+ struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *)inarg;
- if (req->se->op.getxattr)
- req->se->op.getxattr(req, nodeid, PARAM(arg), arg->size);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.getxattr) {
+ req->se->op.getxattr(req, nodeid, PARAM(arg), arg->size);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_listxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;
+ struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *)inarg;
- if (req->se->op.listxattr)
- req->se->op.listxattr(req, nodeid, arg->size);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.listxattr) {
+ req->se->op.listxattr(req, nodeid, arg->size);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_removexattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- char *name = (char *) inarg;
+ char *name = (char *)inarg;
- if (req->se->op.removexattr)
- req->se->op.removexattr(req, nodeid, name);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.removexattr) {
+ req->se->op.removexattr(req, nodeid, name);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void convert_fuse_file_lock(struct fuse_file_lock *fl,
- struct flock *flock)
+ struct flock *flock)
{
- memset(flock, 0, sizeof(struct flock));
- flock->l_type = fl->type;
- flock->l_whence = SEEK_SET;
- flock->l_start = fl->start;
- if (fl->end == OFFSET_MAX)
- flock->l_len = 0;
- else
- flock->l_len = fl->end - fl->start + 1;
- flock->l_pid = fl->pid;
+ memset(flock, 0, sizeof(struct flock));
+ flock->l_type = fl->type;
+ flock->l_whence = SEEK_SET;
+ flock->l_start = fl->start;
+ if (fl->end == OFFSET_MAX) {
+ flock->l_len = 0;
+ } else {
+ flock->l_len = fl->end - fl->start + 1;
+ }
+ flock->l_pid = fl->pid;
}
static void do_getlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;
- struct fuse_file_info fi;
- struct flock flock;
+ struct fuse_lk_in *arg = (struct fuse_lk_in *)inarg;
+ struct fuse_file_info fi;
+ struct flock flock;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- fi.lock_owner = arg->owner;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.lock_owner = arg->owner;
- convert_fuse_file_lock(&arg->lk, &flock);
- if (req->se->op.getlk)
- req->se->op.getlk(req, nodeid, &fi, &flock);
- else
- fuse_reply_err(req, ENOSYS);
+ convert_fuse_file_lock(&arg->lk, &flock);
+ if (req->se->op.getlk) {
+ req->se->op.getlk(req, nodeid, &fi, &flock);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_setlk_common(fuse_req_t req, fuse_ino_t nodeid,
- const void *inarg, int sleep)
-{
- struct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;
- struct fuse_file_info fi;
- struct flock flock;
-
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- fi.lock_owner = arg->owner;
-
- if (arg->lk_flags & FUSE_LK_FLOCK) {
- int op = 0;
-
- switch (arg->lk.type) {
- case F_RDLCK:
- op = LOCK_SH;
- break;
- case F_WRLCK:
- op = LOCK_EX;
- break;
- case F_UNLCK:
- op = LOCK_UN;
- break;
- }
- if (!sleep)
- op |= LOCK_NB;
-
- if (req->se->op.flock)
- req->se->op.flock(req, nodeid, &fi, op);
- else
- fuse_reply_err(req, ENOSYS);
- } else {
- convert_fuse_file_lock(&arg->lk, &flock);
- if (req->se->op.setlk)
- req->se->op.setlk(req, nodeid, &fi, &flock, sleep);
- else
- fuse_reply_err(req, ENOSYS);
- }
+ const void *inarg, int sleep)
+{
+ struct fuse_lk_in *arg = (struct fuse_lk_in *)inarg;
+ struct fuse_file_info fi;
+ struct flock flock;
+
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.lock_owner = arg->owner;
+
+ if (arg->lk_flags & FUSE_LK_FLOCK) {
+ int op = 0;
+
+ switch (arg->lk.type) {
+ case F_RDLCK:
+ op = LOCK_SH;
+ break;
+ case F_WRLCK:
+ op = LOCK_EX;
+ break;
+ case F_UNLCK:
+ op = LOCK_UN;
+ break;
+ }
+ if (!sleep) {
+ op |= LOCK_NB;
+ }
+
+ if (req->se->op.flock) {
+ req->se->op.flock(req, nodeid, &fi, op);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
+ } else {
+ convert_fuse_file_lock(&arg->lk, &flock);
+ if (req->se->op.setlk) {
+ req->se->op.setlk(req, nodeid, &fi, &flock, sleep);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
+ }
}
static void do_setlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- do_setlk_common(req, nodeid, inarg, 0);
+ do_setlk_common(req, nodeid, inarg, 0);
}
static void do_setlkw(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- do_setlk_common(req, nodeid, inarg, 1);
+ do_setlk_common(req, nodeid, inarg, 1);
}
static int find_interrupted(struct fuse_session *se, struct fuse_req *req)
{
- struct fuse_req *curr;
-
- for (curr = se->list.next; curr != &se->list; curr = curr->next) {
- if (curr->unique == req->u.i.unique) {
- fuse_interrupt_func_t func;
- void *data;
-
- curr->ctr++;
- pthread_mutex_unlock(&se->lock);
-
- /* Ugh, ugly locking */
- pthread_mutex_lock(&curr->lock);
- pthread_mutex_lock(&se->lock);
- curr->interrupted = 1;
- func = curr->u.ni.func;
- data = curr->u.ni.data;
- pthread_mutex_unlock(&se->lock);
- if (func)
- func(curr, data);
- pthread_mutex_unlock(&curr->lock);
-
- pthread_mutex_lock(&se->lock);
- curr->ctr--;
- if (!curr->ctr)
- destroy_req(curr);
-
- return 1;
- }
- }
- for (curr = se->interrupts.next; curr != &se->interrupts;
- curr = curr->next) {
- if (curr->u.i.unique == req->u.i.unique)
- return 1;
- }
- return 0;
+ struct fuse_req *curr;
+
+ for (curr = se->list.next; curr != &se->list; curr = curr->next) {
+ if (curr->unique == req->u.i.unique) {
+ fuse_interrupt_func_t func;
+ void *data;
+
+ curr->ctr++;
+ pthread_mutex_unlock(&se->lock);
+
+ /* Ugh, ugly locking */
+ pthread_mutex_lock(&curr->lock);
+ pthread_mutex_lock(&se->lock);
+ curr->interrupted = 1;
+ func = curr->u.ni.func;
+ data = curr->u.ni.data;
+ pthread_mutex_unlock(&se->lock);
+ if (func) {
+ func(curr, data);
+ }
+ pthread_mutex_unlock(&curr->lock);
+
+ pthread_mutex_lock(&se->lock);
+ curr->ctr--;
+ if (!curr->ctr) {
+ destroy_req(curr);
+ }
+
+ return 1;
+ }
+ }
+ for (curr = se->interrupts.next; curr != &se->interrupts;
+ curr = curr->next) {
+ if (curr->u.i.unique == req->u.i.unique) {
+ return 1;
+ }
+ }
+ return 0;
}
static void do_interrupt(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_interrupt_in *arg = (struct fuse_interrupt_in *) inarg;
- struct fuse_session *se = req->se;
+ struct fuse_interrupt_in *arg = (struct fuse_interrupt_in *)inarg;
+ struct fuse_session *se = req->se;
- (void) nodeid;
- if (se->debug)
- fuse_log(FUSE_LOG_DEBUG, "INTERRUPT: %llu\n",
- (unsigned long long) arg->unique);
+ (void)nodeid;
+ if (se->debug) {
+ fuse_log(FUSE_LOG_DEBUG, "INTERRUPT: %llu\n",
+ (unsigned long long)arg->unique);
+ }
- req->u.i.unique = arg->unique;
+ req->u.i.unique = arg->unique;
- pthread_mutex_lock(&se->lock);
- if (find_interrupted(se, req))
- destroy_req(req);
- else
- list_add_req(req, &se->interrupts);
- pthread_mutex_unlock(&se->lock);
+ pthread_mutex_lock(&se->lock);
+ if (find_interrupted(se, req)) {
+ destroy_req(req);
+ } else {
+ list_add_req(req, &se->interrupts);
+ }
+ pthread_mutex_unlock(&se->lock);
}
static struct fuse_req *check_interrupt(struct fuse_session *se,
- struct fuse_req *req)
-{
- struct fuse_req *curr;
-
- for (curr = se->interrupts.next; curr != &se->interrupts;
- curr = curr->next) {
- if (curr->u.i.unique == req->unique) {
- req->interrupted = 1;
- list_del_req(curr);
- free(curr);
- return NULL;
- }
- }
- curr = se->interrupts.next;
- if (curr != &se->interrupts) {
- list_del_req(curr);
- list_init_req(curr);
- return curr;
- } else
- return NULL;
+ struct fuse_req *req)
+{
+ struct fuse_req *curr;
+
+ for (curr = se->interrupts.next; curr != &se->interrupts;
+ curr = curr->next) {
+ if (curr->u.i.unique == req->unique) {
+ req->interrupted = 1;
+ list_del_req(curr);
+ free(curr);
+ return NULL;
+ }
+ }
+ curr = se->interrupts.next;
+ if (curr != &se->interrupts) {
+ list_del_req(curr);
+ list_init_req(curr);
+ return curr;
+ } else {
+ return NULL;
+ }
}
static void do_bmap(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_bmap_in *arg = (struct fuse_bmap_in *) inarg;
+ struct fuse_bmap_in *arg = (struct fuse_bmap_in *)inarg;
- if (req->se->op.bmap)
- req->se->op.bmap(req, nodeid, arg->blocksize, arg->block);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.bmap) {
+ req->se->op.bmap(req, nodeid, arg->blocksize, arg->block);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_ioctl(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_ioctl_in *arg = (struct fuse_ioctl_in *) inarg;
- unsigned int flags = arg->flags;
- void *in_buf = arg->in_size ? PARAM(arg) : NULL;
- struct fuse_file_info fi;
+ struct fuse_ioctl_in *arg = (struct fuse_ioctl_in *)inarg;
+ unsigned int flags = arg->flags;
+ void *in_buf = arg->in_size ? PARAM(arg) : NULL;
+ struct fuse_file_info fi;
- if (flags & FUSE_IOCTL_DIR &&
- !(req->se->conn.want & FUSE_CAP_IOCTL_DIR)) {
- fuse_reply_err(req, ENOTTY);
- return;
- }
+ if (flags & FUSE_IOCTL_DIR && !(req->se->conn.want & FUSE_CAP_IOCTL_DIR)) {
+ fuse_reply_err(req, ENOTTY);
+ return;
+ }
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
- if (sizeof(void *) == 4 && req->se->conn.proto_minor >= 16 &&
- !(flags & FUSE_IOCTL_32BIT)) {
- req->ioctl_64bit = 1;
- }
+ if (sizeof(void *) == 4 && req->se->conn.proto_minor >= 16 &&
+ !(flags & FUSE_IOCTL_32BIT)) {
+ req->ioctl_64bit = 1;
+ }
- if (req->se->op.ioctl)
- req->se->op.ioctl(req, nodeid, arg->cmd,
- (void *)(uintptr_t)arg->arg, &fi, flags,
- in_buf, arg->in_size, arg->out_size);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.ioctl) {
+ req->se->op.ioctl(req, nodeid, arg->cmd, (void *)(uintptr_t)arg->arg,
+ &fi, flags, in_buf, arg->in_size, arg->out_size);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
void fuse_pollhandle_destroy(struct fuse_pollhandle *ph)
{
- free(ph);
+ free(ph);
}
static void do_poll(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_poll_in *arg = (struct fuse_poll_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_poll_in *arg = (struct fuse_poll_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- fi.poll_events = arg->events;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fi.poll_events = arg->events;
- if (req->se->op.poll) {
- struct fuse_pollhandle *ph = NULL;
+ if (req->se->op.poll) {
+ struct fuse_pollhandle *ph = NULL;
- if (arg->flags & FUSE_POLL_SCHEDULE_NOTIFY) {
- ph = malloc(sizeof(struct fuse_pollhandle));
- if (ph == NULL) {
- fuse_reply_err(req, ENOMEM);
- return;
- }
- ph->kh = arg->kh;
- ph->se = req->se;
- }
+ if (arg->flags & FUSE_POLL_SCHEDULE_NOTIFY) {
+ ph = malloc(sizeof(struct fuse_pollhandle));
+ if (ph == NULL) {
+ fuse_reply_err(req, ENOMEM);
+ return;
+ }
+ ph->kh = arg->kh;
+ ph->se = req->se;
+ }
- req->se->op.poll(req, nodeid, &fi, ph);
- } else {
- fuse_reply_err(req, ENOSYS);
- }
+ req->se->op.poll(req, nodeid, &fi, ph);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_fallocate(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_fallocate_in *arg = (struct fuse_fallocate_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_fallocate_in *arg = (struct fuse_fallocate_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
- if (req->se->op.fallocate)
- req->se->op.fallocate(req, nodeid, arg->mode, arg->offset, arg->length, &fi);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.fallocate) {
+ req->se->op.fallocate(req, nodeid, arg->mode, arg->offset, arg->length,
+ &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
-static void do_copy_file_range(fuse_req_t req, fuse_ino_t nodeid_in, const void *inarg)
+static void do_copy_file_range(fuse_req_t req, fuse_ino_t nodeid_in,
+ const void *inarg)
{
- struct fuse_copy_file_range_in *arg = (struct fuse_copy_file_range_in *) inarg;
- struct fuse_file_info fi_in, fi_out;
+ struct fuse_copy_file_range_in *arg =
+ (struct fuse_copy_file_range_in *)inarg;
+ struct fuse_file_info fi_in, fi_out;
- memset(&fi_in, 0, sizeof(fi_in));
- fi_in.fh = arg->fh_in;
+ memset(&fi_in, 0, sizeof(fi_in));
+ fi_in.fh = arg->fh_in;
- memset(&fi_out, 0, sizeof(fi_out));
- fi_out.fh = arg->fh_out;
+ memset(&fi_out, 0, sizeof(fi_out));
+ fi_out.fh = arg->fh_out;
- if (req->se->op.copy_file_range)
- req->se->op.copy_file_range(req, nodeid_in, arg->off_in,
- &fi_in, arg->nodeid_out,
- arg->off_out, &fi_out, arg->len,
- arg->flags);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.copy_file_range) {
+ req->se->op.copy_file_range(req, nodeid_in, arg->off_in, &fi_in,
+ arg->nodeid_out, arg->off_out, &fi_out,
+ arg->len, arg->flags);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_lseek(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_lseek_in *arg = (struct fuse_lseek_in *) inarg;
- struct fuse_file_info fi;
+ struct fuse_lseek_in *arg = (struct fuse_lseek_in *)inarg;
+ struct fuse_file_info fi;
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
- if (req->se->op.lseek)
- req->se->op.lseek(req, nodeid, arg->offset, arg->whence, &fi);
- else
- fuse_reply_err(req, ENOSYS);
+ if (req->se->op.lseek) {
+ req->se->op.lseek(req, nodeid, arg->offset, arg->whence, &fi);
+ } else {
+ fuse_reply_err(req, ENOSYS);
+ }
}
static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_init_in *arg = (struct fuse_init_in *) inarg;
- struct fuse_init_out outarg;
- struct fuse_session *se = req->se;
- size_t bufsize = se->bufsize;
- size_t outargsize = sizeof(outarg);
-
- (void) nodeid;
- if (se->debug) {
- fuse_log(FUSE_LOG_DEBUG, "INIT: %u.%u\n", arg->major, arg->minor);
- if (arg->major == 7 && arg->minor >= 6) {
- fuse_log(FUSE_LOG_DEBUG, "flags=0x%08x\n", arg->flags);
- fuse_log(FUSE_LOG_DEBUG, "max_readahead=0x%08x\n",
- arg->max_readahead);
- }
- }
- se->conn.proto_major = arg->major;
- se->conn.proto_minor = arg->minor;
- se->conn.capable = 0;
- se->conn.want = 0;
-
- memset(&outarg, 0, sizeof(outarg));
- outarg.major = FUSE_KERNEL_VERSION;
- outarg.minor = FUSE_KERNEL_MINOR_VERSION;
-
- if (arg->major < 7) {
- fuse_log(FUSE_LOG_ERR, "fuse: unsupported protocol version: %u.%u\n",
- arg->major, arg->minor);
- fuse_reply_err(req, EPROTO);
- return;
- }
-
- if (arg->major > 7) {
- /* Wait for a second INIT request with a 7.X version */
- send_reply_ok(req, &outarg, sizeof(outarg));
- return;
- }
-
- if (arg->minor >= 6) {
- if (arg->max_readahead < se->conn.max_readahead)
- se->conn.max_readahead = arg->max_readahead;
- if (arg->flags & FUSE_ASYNC_READ)
- se->conn.capable |= FUSE_CAP_ASYNC_READ;
- if (arg->flags & FUSE_POSIX_LOCKS)
- se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
- if (arg->flags & FUSE_ATOMIC_O_TRUNC)
- se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
- if (arg->flags & FUSE_EXPORT_SUPPORT)
- se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
- if (arg->flags & FUSE_DONT_MASK)
- se->conn.capable |= FUSE_CAP_DONT_MASK;
- if (arg->flags & FUSE_FLOCK_LOCKS)
- se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
- if (arg->flags & FUSE_AUTO_INVAL_DATA)
- se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
- if (arg->flags & FUSE_DO_READDIRPLUS)
- se->conn.capable |= FUSE_CAP_READDIRPLUS;
- if (arg->flags & FUSE_READDIRPLUS_AUTO)
- se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
- if (arg->flags & FUSE_ASYNC_DIO)
- se->conn.capable |= FUSE_CAP_ASYNC_DIO;
- if (arg->flags & FUSE_WRITEBACK_CACHE)
- se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
- if (arg->flags & FUSE_NO_OPEN_SUPPORT)
- se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
- if (arg->flags & FUSE_PARALLEL_DIROPS)
- se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
- if (arg->flags & FUSE_POSIX_ACL)
- se->conn.capable |= FUSE_CAP_POSIX_ACL;
- if (arg->flags & FUSE_HANDLE_KILLPRIV)
- se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
- if (arg->flags & FUSE_NO_OPENDIR_SUPPORT)
- se->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;
- if (!(arg->flags & FUSE_MAX_PAGES)) {
- size_t max_bufsize =
- FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize()
- + FUSE_BUFFER_HEADER_SIZE;
- if (bufsize > max_bufsize) {
- bufsize = max_bufsize;
- }
- }
- } else {
- se->conn.max_readahead = 0;
- }
-
- if (se->conn.proto_minor >= 14) {
+ struct fuse_init_in *arg = (struct fuse_init_in *)inarg;
+ struct fuse_init_out outarg;
+ struct fuse_session *se = req->se;
+ size_t bufsize = se->bufsize;
+ size_t outargsize = sizeof(outarg);
+
+ (void)nodeid;
+ if (se->debug) {
+ fuse_log(FUSE_LOG_DEBUG, "INIT: %u.%u\n", arg->major, arg->minor);
+ if (arg->major == 7 && arg->minor >= 6) {
+ fuse_log(FUSE_LOG_DEBUG, "flags=0x%08x\n", arg->flags);
+ fuse_log(FUSE_LOG_DEBUG, "max_readahead=0x%08x\n",
+ arg->max_readahead);
+ }
+ }
+ se->conn.proto_major = arg->major;
+ se->conn.proto_minor = arg->minor;
+ se->conn.capable = 0;
+ se->conn.want = 0;
+
+ memset(&outarg, 0, sizeof(outarg));
+ outarg.major = FUSE_KERNEL_VERSION;
+ outarg.minor = FUSE_KERNEL_MINOR_VERSION;
+
+ if (arg->major < 7) {
+ fuse_log(FUSE_LOG_ERR, "fuse: unsupported protocol version: %u.%u\n",
+ arg->major, arg->minor);
+ fuse_reply_err(req, EPROTO);
+ return;
+ }
+
+ if (arg->major > 7) {
+ /* Wait for a second INIT request with a 7.X version */
+ send_reply_ok(req, &outarg, sizeof(outarg));
+ return;
+ }
+
+ if (arg->minor >= 6) {
+ if (arg->max_readahead < se->conn.max_readahead) {
+ se->conn.max_readahead = arg->max_readahead;
+ }
+ if (arg->flags & FUSE_ASYNC_READ) {
+ se->conn.capable |= FUSE_CAP_ASYNC_READ;
+ }
+ if (arg->flags & FUSE_POSIX_LOCKS) {
+ se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
+ }
+ if (arg->flags & FUSE_ATOMIC_O_TRUNC) {
+ se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
+ }
+ if (arg->flags & FUSE_EXPORT_SUPPORT) {
+ se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
+ }
+ if (arg->flags & FUSE_DONT_MASK) {
+ se->conn.capable |= FUSE_CAP_DONT_MASK;
+ }
+ if (arg->flags & FUSE_FLOCK_LOCKS) {
+ se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
+ }
+ if (arg->flags & FUSE_AUTO_INVAL_DATA) {
+ se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
+ }
+ if (arg->flags & FUSE_DO_READDIRPLUS) {
+ se->conn.capable |= FUSE_CAP_READDIRPLUS;
+ }
+ if (arg->flags & FUSE_READDIRPLUS_AUTO) {
+ se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
+ }
+ if (arg->flags & FUSE_ASYNC_DIO) {
+ se->conn.capable |= FUSE_CAP_ASYNC_DIO;
+ }
+ if (arg->flags & FUSE_WRITEBACK_CACHE) {
+ se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
+ }
+ if (arg->flags & FUSE_NO_OPEN_SUPPORT) {
+ se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
+ }
+ if (arg->flags & FUSE_PARALLEL_DIROPS) {
+ se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
+ }
+ if (arg->flags & FUSE_POSIX_ACL) {
+ se->conn.capable |= FUSE_CAP_POSIX_ACL;
+ }
+ if (arg->flags & FUSE_HANDLE_KILLPRIV) {
+ se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
+ }
+ if (arg->flags & FUSE_NO_OPENDIR_SUPPORT) {
+ se->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;
+ }
+ if (!(arg->flags & FUSE_MAX_PAGES)) {
+ size_t max_bufsize =
+ FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize() +
+ FUSE_BUFFER_HEADER_SIZE;
+ if (bufsize > max_bufsize) {
+ bufsize = max_bufsize;
+ }
+ }
+ } else {
+ se->conn.max_readahead = 0;
+ }
+
+ if (se->conn.proto_minor >= 14) {
#ifdef HAVE_SPLICE
#ifdef HAVE_VMSPLICE
- se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
+ se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
#endif
- se->conn.capable |= FUSE_CAP_SPLICE_READ;
+ se->conn.capable |= FUSE_CAP_SPLICE_READ;
#endif
- }
- if (se->conn.proto_minor >= 18)
- se->conn.capable |= FUSE_CAP_IOCTL_DIR;
-
- /* Default settings for modern filesystems.
- *
- * Most of these capabilities were disabled by default in
- * libfuse2 for backwards compatibility reasons. In libfuse3,
- * we can finally enable them by default (as long as they're
- * supported by the kernel).
- */
-#define LL_SET_DEFAULT(cond, cap) \
- if ((cond) && (se->conn.capable & (cap))) \
- se->conn.want |= (cap)
- LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_READ);
- LL_SET_DEFAULT(1, FUSE_CAP_PARALLEL_DIROPS);
- LL_SET_DEFAULT(1, FUSE_CAP_AUTO_INVAL_DATA);
- LL_SET_DEFAULT(1, FUSE_CAP_HANDLE_KILLPRIV);
- LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_DIO);
- LL_SET_DEFAULT(1, FUSE_CAP_IOCTL_DIR);
- LL_SET_DEFAULT(1, FUSE_CAP_ATOMIC_O_TRUNC);
- LL_SET_DEFAULT(se->op.write_buf, FUSE_CAP_SPLICE_READ);
- LL_SET_DEFAULT(se->op.getlk && se->op.setlk,
- FUSE_CAP_POSIX_LOCKS);
- LL_SET_DEFAULT(se->op.flock, FUSE_CAP_FLOCK_LOCKS);
- LL_SET_DEFAULT(se->op.readdirplus, FUSE_CAP_READDIRPLUS);
- LL_SET_DEFAULT(se->op.readdirplus && se->op.readdir,
- FUSE_CAP_READDIRPLUS_AUTO);
- se->conn.time_gran = 1;
-
- if (bufsize < FUSE_MIN_READ_BUFFER) {
- fuse_log(FUSE_LOG_ERR, "fuse: warning: buffer size too small: %zu\n",
- bufsize);
- bufsize = FUSE_MIN_READ_BUFFER;
- }
- se->bufsize = bufsize;
-
- if (se->conn.max_write > bufsize - FUSE_BUFFER_HEADER_SIZE)
- se->conn.max_write = bufsize - FUSE_BUFFER_HEADER_SIZE;
-
- se->got_init = 1;
- if (se->op.init)
- se->op.init(se->userdata, &se->conn);
-
- if (se->conn.want & (~se->conn.capable)) {
- fuse_log(FUSE_LOG_ERR, "fuse: error: filesystem requested capabilities "
- "0x%x that are not supported by kernel, aborting.\n",
- se->conn.want & (~se->conn.capable));
- fuse_reply_err(req, EPROTO);
- se->error = -EPROTO;
- fuse_session_exit(se);
- return;
- }
-
- if (se->conn.max_write < bufsize - FUSE_BUFFER_HEADER_SIZE) {
- se->bufsize = se->conn.max_write + FUSE_BUFFER_HEADER_SIZE;
- }
- if (arg->flags & FUSE_MAX_PAGES) {
- outarg.flags |= FUSE_MAX_PAGES;
- outarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;
- }
-
- /* Always enable big writes, this is superseded
- by the max_write option */
- outarg.flags |= FUSE_BIG_WRITES;
-
- if (se->conn.want & FUSE_CAP_ASYNC_READ)
- outarg.flags |= FUSE_ASYNC_READ;
- if (se->conn.want & FUSE_CAP_POSIX_LOCKS)
- outarg.flags |= FUSE_POSIX_LOCKS;
- if (se->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)
- outarg.flags |= FUSE_ATOMIC_O_TRUNC;
- if (se->conn.want & FUSE_CAP_EXPORT_SUPPORT)
- outarg.flags |= FUSE_EXPORT_SUPPORT;
- if (se->conn.want & FUSE_CAP_DONT_MASK)
- outarg.flags |= FUSE_DONT_MASK;
- if (se->conn.want & FUSE_CAP_FLOCK_LOCKS)
- outarg.flags |= FUSE_FLOCK_LOCKS;
- if (se->conn.want & FUSE_CAP_AUTO_INVAL_DATA)
- outarg.flags |= FUSE_AUTO_INVAL_DATA;
- if (se->conn.want & FUSE_CAP_READDIRPLUS)
- outarg.flags |= FUSE_DO_READDIRPLUS;
- if (se->conn.want & FUSE_CAP_READDIRPLUS_AUTO)
- outarg.flags |= FUSE_READDIRPLUS_AUTO;
- if (se->conn.want & FUSE_CAP_ASYNC_DIO)
- outarg.flags |= FUSE_ASYNC_DIO;
- if (se->conn.want & FUSE_CAP_WRITEBACK_CACHE)
- outarg.flags |= FUSE_WRITEBACK_CACHE;
- if (se->conn.want & FUSE_CAP_POSIX_ACL)
- outarg.flags |= FUSE_POSIX_ACL;
- outarg.max_readahead = se->conn.max_readahead;
- outarg.max_write = se->conn.max_write;
- if (se->conn.proto_minor >= 13) {
- if (se->conn.max_background >= (1 << 16))
- se->conn.max_background = (1 << 16) - 1;
- if (se->conn.congestion_threshold > se->conn.max_background)
- se->conn.congestion_threshold = se->conn.max_background;
- if (!se->conn.congestion_threshold) {
- se->conn.congestion_threshold =
- se->conn.max_background * 3 / 4;
- }
-
- outarg.max_background = se->conn.max_background;
- outarg.congestion_threshold = se->conn.congestion_threshold;
- }
- if (se->conn.proto_minor >= 23)
- outarg.time_gran = se->conn.time_gran;
-
- if (se->debug) {
- fuse_log(FUSE_LOG_DEBUG, " INIT: %u.%u\n", outarg.major, outarg.minor);
- fuse_log(FUSE_LOG_DEBUG, " flags=0x%08x\n", outarg.flags);
- fuse_log(FUSE_LOG_DEBUG, " max_readahead=0x%08x\n",
- outarg.max_readahead);
- fuse_log(FUSE_LOG_DEBUG, " max_write=0x%08x\n", outarg.max_write);
- fuse_log(FUSE_LOG_DEBUG, " max_background=%i\n",
- outarg.max_background);
- fuse_log(FUSE_LOG_DEBUG, " congestion_threshold=%i\n",
- outarg.congestion_threshold);
- fuse_log(FUSE_LOG_DEBUG, " time_gran=%u\n",
- outarg.time_gran);
- }
- if (arg->minor < 5)
- outargsize = FUSE_COMPAT_INIT_OUT_SIZE;
- else if (arg->minor < 23)
- outargsize = FUSE_COMPAT_22_INIT_OUT_SIZE;
-
- send_reply_ok(req, &outarg, outargsize);
+ }
+ if (se->conn.proto_minor >= 18) {
+ se->conn.capable |= FUSE_CAP_IOCTL_DIR;
+ }
+
+ /*
+ * Default settings for modern filesystems.
+ *
+ * Most of these capabilities were disabled by default in
+ * libfuse2 for backwards compatibility reasons. In libfuse3,
+ * we can finally enable them by default (as long as they're
+ * supported by the kernel).
+ */
+#define LL_SET_DEFAULT(cond, cap) \
+ if ((cond) && (se->conn.capable & (cap))) \
+ se->conn.want |= (cap)
+ LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_READ);
+ LL_SET_DEFAULT(1, FUSE_CAP_PARALLEL_DIROPS);
+ LL_SET_DEFAULT(1, FUSE_CAP_AUTO_INVAL_DATA);
+ LL_SET_DEFAULT(1, FUSE_CAP_HANDLE_KILLPRIV);
+ LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_DIO);
+ LL_SET_DEFAULT(1, FUSE_CAP_IOCTL_DIR);
+ LL_SET_DEFAULT(1, FUSE_CAP_ATOMIC_O_TRUNC);
+ LL_SET_DEFAULT(se->op.write_buf, FUSE_CAP_SPLICE_READ);
+ LL_SET_DEFAULT(se->op.getlk && se->op.setlk, FUSE_CAP_POSIX_LOCKS);
+ LL_SET_DEFAULT(se->op.flock, FUSE_CAP_FLOCK_LOCKS);
+ LL_SET_DEFAULT(se->op.readdirplus, FUSE_CAP_READDIRPLUS);
+ LL_SET_DEFAULT(se->op.readdirplus && se->op.readdir,
+ FUSE_CAP_READDIRPLUS_AUTO);
+ se->conn.time_gran = 1;
+
+ if (bufsize < FUSE_MIN_READ_BUFFER) {
+ fuse_log(FUSE_LOG_ERR, "fuse: warning: buffer size too small: %zu\n",
+ bufsize);
+ bufsize = FUSE_MIN_READ_BUFFER;
+ }
+ se->bufsize = bufsize;
+
+ if (se->conn.max_write > bufsize - FUSE_BUFFER_HEADER_SIZE) {
+ se->conn.max_write = bufsize - FUSE_BUFFER_HEADER_SIZE;
+ }
+
+ se->got_init = 1;
+ if (se->op.init) {
+ se->op.init(se->userdata, &se->conn);
+ }
+
+ if (se->conn.want & (~se->conn.capable)) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: error: filesystem requested capabilities "
+ "0x%x that are not supported by kernel, aborting.\n",
+ se->conn.want & (~se->conn.capable));
+ fuse_reply_err(req, EPROTO);
+ se->error = -EPROTO;
+ fuse_session_exit(se);
+ return;
+ }
+
+ if (se->conn.max_write < bufsize - FUSE_BUFFER_HEADER_SIZE) {
+ se->bufsize = se->conn.max_write + FUSE_BUFFER_HEADER_SIZE;
+ }
+ if (arg->flags & FUSE_MAX_PAGES) {
+ outarg.flags |= FUSE_MAX_PAGES;
+ outarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;
+ }
+
+ /*
+ * Always enable big writes, this is superseded
+ * by the max_write option
+ */
+ outarg.flags |= FUSE_BIG_WRITES;
+
+ if (se->conn.want & FUSE_CAP_ASYNC_READ) {
+ outarg.flags |= FUSE_ASYNC_READ;
+ }
+ if (se->conn.want & FUSE_CAP_POSIX_LOCKS) {
+ outarg.flags |= FUSE_POSIX_LOCKS;
+ }
+ if (se->conn.want & FUSE_CAP_ATOMIC_O_TRUNC) {
+ outarg.flags |= FUSE_ATOMIC_O_TRUNC;
+ }
+ if (se->conn.want & FUSE_CAP_EXPORT_SUPPORT) {
+ outarg.flags |= FUSE_EXPORT_SUPPORT;
+ }
+ if (se->conn.want & FUSE_CAP_DONT_MASK) {
+ outarg.flags |= FUSE_DONT_MASK;
+ }
+ if (se->conn.want & FUSE_CAP_FLOCK_LOCKS) {
+ outarg.flags |= FUSE_FLOCK_LOCKS;
+ }
+ if (se->conn.want & FUSE_CAP_AUTO_INVAL_DATA) {
+ outarg.flags |= FUSE_AUTO_INVAL_DATA;
+ }
+ if (se->conn.want & FUSE_CAP_READDIRPLUS) {
+ outarg.flags |= FUSE_DO_READDIRPLUS;
+ }
+ if (se->conn.want & FUSE_CAP_READDIRPLUS_AUTO) {
+ outarg.flags |= FUSE_READDIRPLUS_AUTO;
+ }
+ if (se->conn.want & FUSE_CAP_ASYNC_DIO) {
+ outarg.flags |= FUSE_ASYNC_DIO;
+ }
+ if (se->conn.want & FUSE_CAP_WRITEBACK_CACHE) {
+ outarg.flags |= FUSE_WRITEBACK_CACHE;
+ }
+ if (se->conn.want & FUSE_CAP_POSIX_ACL) {
+ outarg.flags |= FUSE_POSIX_ACL;
+ }
+ outarg.max_readahead = se->conn.max_readahead;
+ outarg.max_write = se->conn.max_write;
+ if (se->conn.proto_minor >= 13) {
+ if (se->conn.max_background >= (1 << 16)) {
+ se->conn.max_background = (1 << 16) - 1;
+ }
+ if (se->conn.congestion_threshold > se->conn.max_background) {
+ se->conn.congestion_threshold = se->conn.max_background;
+ }
+ if (!se->conn.congestion_threshold) {
+ se->conn.congestion_threshold = se->conn.max_background * 3 / 4;
+ }
+
+ outarg.max_background = se->conn.max_background;
+ outarg.congestion_threshold = se->conn.congestion_threshold;
+ }
+ if (se->conn.proto_minor >= 23) {
+ outarg.time_gran = se->conn.time_gran;
+ }
+
+ if (se->debug) {
+ fuse_log(FUSE_LOG_DEBUG, " INIT: %u.%u\n", outarg.major,
+ outarg.minor);
+ fuse_log(FUSE_LOG_DEBUG, " flags=0x%08x\n", outarg.flags);
+ fuse_log(FUSE_LOG_DEBUG, " max_readahead=0x%08x\n",
+ outarg.max_readahead);
+ fuse_log(FUSE_LOG_DEBUG, " max_write=0x%08x\n", outarg.max_write);
+ fuse_log(FUSE_LOG_DEBUG, " max_background=%i\n",
+ outarg.max_background);
+ fuse_log(FUSE_LOG_DEBUG, " congestion_threshold=%i\n",
+ outarg.congestion_threshold);
+ fuse_log(FUSE_LOG_DEBUG, " time_gran=%u\n", outarg.time_gran);
+ }
+ if (arg->minor < 5) {
+ outargsize = FUSE_COMPAT_INIT_OUT_SIZE;
+ } else if (arg->minor < 23) {
+ outargsize = FUSE_COMPAT_22_INIT_OUT_SIZE;
+ }
+
+ send_reply_ok(req, &outarg, outargsize);
}
static void do_destroy(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
- struct fuse_session *se = req->se;
+ struct fuse_session *se = req->se;
- (void) nodeid;
- (void) inarg;
+ (void)nodeid;
+ (void)inarg;
- se->got_destroy = 1;
- if (se->op.destroy)
- se->op.destroy(se->userdata);
+ se->got_destroy = 1;
+ if (se->op.destroy) {
+ se->op.destroy(se->userdata);
+ }
- send_reply_ok(req, NULL, 0);
+ send_reply_ok(req, NULL, 0);
}
static void list_del_nreq(struct fuse_notify_req *nreq)
{
- struct fuse_notify_req *prev = nreq->prev;
- struct fuse_notify_req *next = nreq->next;
- prev->next = next;
- next->prev = prev;
+ struct fuse_notify_req *prev = nreq->prev;
+ struct fuse_notify_req *next = nreq->next;
+ prev->next = next;
+ next->prev = prev;
}
static void list_add_nreq(struct fuse_notify_req *nreq,
- struct fuse_notify_req *next)
+ struct fuse_notify_req *next)
{
- struct fuse_notify_req *prev = next->prev;
- nreq->next = next;
- nreq->prev = prev;
- prev->next = nreq;
- next->prev = nreq;
+ struct fuse_notify_req *prev = next->prev;
+ nreq->next = next;
+ nreq->prev = prev;
+ prev->next = nreq;
+ next->prev = nreq;
}
static void list_init_nreq(struct fuse_notify_req *nreq)
{
- nreq->next = nreq;
- nreq->prev = nreq;
+ nreq->next = nreq;
+ nreq->prev = nreq;
}
static void do_notify_reply(fuse_req_t req, fuse_ino_t nodeid,
- const void *inarg, const struct fuse_buf *buf)
+ const void *inarg, const struct fuse_buf *buf)
{
- struct fuse_session *se = req->se;
- struct fuse_notify_req *nreq;
- struct fuse_notify_req *head;
+ struct fuse_session *se = req->se;
+ struct fuse_notify_req *nreq;
+ struct fuse_notify_req *head;
- pthread_mutex_lock(&se->lock);
- head = &se->notify_list;
- for (nreq = head->next; nreq != head; nreq = nreq->next) {
- if (nreq->unique == req->unique) {
- list_del_nreq(nreq);
- break;
- }
- }
- pthread_mutex_unlock(&se->lock);
+ pthread_mutex_lock(&se->lock);
+ head = &se->notify_list;
+ for (nreq = head->next; nreq != head; nreq = nreq->next) {
+ if (nreq->unique == req->unique) {
+ list_del_nreq(nreq);
+ break;
+ }
+ }
+ pthread_mutex_unlock(&se->lock);
- if (nreq != head)
- nreq->reply(nreq, req, nodeid, inarg, buf);
+ if (nreq != head) {
+ nreq->reply(nreq, req, nodeid, inarg, buf);
+ }
}
static int send_notify_iov(struct fuse_session *se, int notify_code,
- struct iovec *iov, int count)
+ struct iovec *iov, int count)
{
- struct fuse_out_header out;
+ struct fuse_out_header out;
- if (!se->got_init)
- return -ENOTCONN;
+ if (!se->got_init) {
+ return -ENOTCONN;
+ }
- out.unique = 0;
- out.error = notify_code;
- iov[0].iov_base = &out;
- iov[0].iov_len = sizeof(struct fuse_out_header);
+ out.unique = 0;
+ out.error = notify_code;
+ iov[0].iov_base = &out;
+ iov[0].iov_len = sizeof(struct fuse_out_header);
- return fuse_send_msg(se, NULL, iov, count);
+ return fuse_send_msg(se, NULL, iov, count);
}
int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph)
{
- if (ph != NULL) {
- struct fuse_notify_poll_wakeup_out outarg;
- struct iovec iov[2];
+ if (ph != NULL) {
+ struct fuse_notify_poll_wakeup_out outarg;
+ struct iovec iov[2];
- outarg.kh = ph->kh;
+ outarg.kh = ph->kh;
- iov[1].iov_base = &outarg;
- iov[1].iov_len = sizeof(outarg);
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
- return send_notify_iov(ph->se, FUSE_NOTIFY_POLL, iov, 2);
- } else {
- return 0;
- }
+ return send_notify_iov(ph->se, FUSE_NOTIFY_POLL, iov, 2);
+ } else {
+ return 0;
+ }
}
int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
- off_t off, off_t len)
+ off_t off, off_t len)
{
- struct fuse_notify_inval_inode_out outarg;
- struct iovec iov[2];
+ struct fuse_notify_inval_inode_out outarg;
+ struct iovec iov[2];
+
+ if (!se) {
+ return -EINVAL;
+ }
- if (!se)
- return -EINVAL;
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 12) {
+ return -ENOSYS;
+ }
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
- return -ENOSYS;
-
- outarg.ino = ino;
- outarg.off = off;
- outarg.len = len;
+ outarg.ino = ino;
+ outarg.off = off;
+ outarg.len = len;
- iov[1].iov_base = &outarg;
- iov[1].iov_len = sizeof(outarg);
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
- return send_notify_iov(se, FUSE_NOTIFY_INVAL_INODE, iov, 2);
+ return send_notify_iov(se, FUSE_NOTIFY_INVAL_INODE, iov, 2);
}
int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
- const char *name, size_t namelen)
+ const char *name, size_t namelen)
{
- struct fuse_notify_inval_entry_out outarg;
- struct iovec iov[3];
+ struct fuse_notify_inval_entry_out outarg;
+ struct iovec iov[3];
+
+ if (!se) {
+ return -EINVAL;
+ }
- if (!se)
- return -EINVAL;
-
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
- return -ENOSYS;
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 12) {
+ return -ENOSYS;
+ }
- outarg.parent = parent;
- outarg.namelen = namelen;
- outarg.padding = 0;
+ outarg.parent = parent;
+ outarg.namelen = namelen;
+ outarg.padding = 0;
- iov[1].iov_base = &outarg;
- iov[1].iov_len = sizeof(outarg);
- iov[2].iov_base = (void *)name;
- iov[2].iov_len = namelen + 1;
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
+ iov[2].iov_base = (void *)name;
+ iov[2].iov_len = namelen + 1;
- return send_notify_iov(se, FUSE_NOTIFY_INVAL_ENTRY, iov, 3);
+ return send_notify_iov(se, FUSE_NOTIFY_INVAL_ENTRY, iov, 3);
}
-int fuse_lowlevel_notify_delete(struct fuse_session *se,
- fuse_ino_t parent, fuse_ino_t child,
- const char *name, size_t namelen)
+int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
+ fuse_ino_t child, const char *name,
+ size_t namelen)
{
- struct fuse_notify_delete_out outarg;
- struct iovec iov[3];
+ struct fuse_notify_delete_out outarg;
+ struct iovec iov[3];
- if (!se)
- return -EINVAL;
+ if (!se) {
+ return -EINVAL;
+ }
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 18)
- return -ENOSYS;
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 18) {
+ return -ENOSYS;
+ }
- outarg.parent = parent;
- outarg.child = child;
- outarg.namelen = namelen;
- outarg.padding = 0;
+ outarg.parent = parent;
+ outarg.child = child;
+ outarg.namelen = namelen;
+ outarg.padding = 0;
- iov[1].iov_base = &outarg;
- iov[1].iov_len = sizeof(outarg);
- iov[2].iov_base = (void *)name;
- iov[2].iov_len = namelen + 1;
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
+ iov[2].iov_base = (void *)name;
+ iov[2].iov_len = namelen + 1;
- return send_notify_iov(se, FUSE_NOTIFY_DELETE, iov, 3);
+ return send_notify_iov(se, FUSE_NOTIFY_DELETE, iov, 3);
}
int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
- off_t offset, struct fuse_bufvec *bufv,
- enum fuse_buf_copy_flags flags)
+ off_t offset, struct fuse_bufvec *bufv,
+ enum fuse_buf_copy_flags flags)
{
- struct fuse_out_header out;
- struct fuse_notify_store_out outarg;
- struct iovec iov[3];
- size_t size = fuse_buf_size(bufv);
- int res;
+ struct fuse_out_header out;
+ struct fuse_notify_store_out outarg;
+ struct iovec iov[3];
+ size_t size = fuse_buf_size(bufv);
+ int res;
- if (!se)
- return -EINVAL;
+ if (!se) {
+ return -EINVAL;
+ }
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 15)
- return -ENOSYS;
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 15) {
+ return -ENOSYS;
+ }
- out.unique = 0;
- out.error = FUSE_NOTIFY_STORE;
+ out.unique = 0;
+ out.error = FUSE_NOTIFY_STORE;
- outarg.nodeid = ino;
- outarg.offset = offset;
- outarg.size = size;
- outarg.padding = 0;
+ outarg.nodeid = ino;
+ outarg.offset = offset;
+ outarg.size = size;
+ outarg.padding = 0;
- iov[0].iov_base = &out;
- iov[0].iov_len = sizeof(out);
- iov[1].iov_base = &outarg;
- iov[1].iov_len = sizeof(outarg);
+ iov[0].iov_base = &out;
+ iov[0].iov_len = sizeof(out);
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
- res = fuse_send_data_iov(se, NULL, iov, 2, bufv, flags);
- if (res > 0)
- res = -res;
+ res = fuse_send_data_iov(se, NULL, iov, 2, bufv, flags);
+ if (res > 0) {
+ res = -res;
+ }
- return res;
+ return res;
}
struct fuse_retrieve_req {
- struct fuse_notify_req nreq;
- void *cookie;
+ struct fuse_notify_req nreq;
+ void *cookie;
};
-static void fuse_ll_retrieve_reply(struct fuse_notify_req *nreq,
- fuse_req_t req, fuse_ino_t ino,
- const void *inarg,
- const struct fuse_buf *ibuf)
-{
- struct fuse_session *se = req->se;
- struct fuse_retrieve_req *rreq =
- container_of(nreq, struct fuse_retrieve_req, nreq);
- const struct fuse_notify_retrieve_in *arg = inarg;
- struct fuse_bufvec bufv = {
- .buf[0] = *ibuf,
- .count = 1,
- };
-
- if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
- bufv.buf[0].mem = PARAM(arg);
-
- bufv.buf[0].size -= sizeof(struct fuse_in_header) +
- sizeof(struct fuse_notify_retrieve_in);
-
- if (bufv.buf[0].size < arg->size) {
- fuse_log(FUSE_LOG_ERR, "fuse: retrieve reply: buffer size too small\n");
- fuse_reply_none(req);
- goto out;
- }
- bufv.buf[0].size = arg->size;
-
- if (se->op.retrieve_reply) {
- se->op.retrieve_reply(req, rreq->cookie, ino,
- arg->offset, &bufv);
- } else {
- fuse_reply_none(req);
- }
+static void fuse_ll_retrieve_reply(struct fuse_notify_req *nreq, fuse_req_t req,
+ fuse_ino_t ino, const void *inarg,
+ const struct fuse_buf *ibuf)
+{
+ struct fuse_session *se = req->se;
+ struct fuse_retrieve_req *rreq =
+ container_of(nreq, struct fuse_retrieve_req, nreq);
+ const struct fuse_notify_retrieve_in *arg = inarg;
+ struct fuse_bufvec bufv = {
+ .buf[0] = *ibuf,
+ .count = 1,
+ };
+
+ if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD)) {
+ bufv.buf[0].mem = PARAM(arg);
+ }
+
+ bufv.buf[0].size -=
+ sizeof(struct fuse_in_header) + sizeof(struct fuse_notify_retrieve_in);
+
+ if (bufv.buf[0].size < arg->size) {
+ fuse_log(FUSE_LOG_ERR, "fuse: retrieve reply: buffer size too small\n");
+ fuse_reply_none(req);
+ goto out;
+ }
+ bufv.buf[0].size = arg->size;
+
+ if (se->op.retrieve_reply) {
+ se->op.retrieve_reply(req, rreq->cookie, ino, arg->offset, &bufv);
+ } else {
+ fuse_reply_none(req);
+ }
out:
- free(rreq);
+ free(rreq);
}
int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
- size_t size, off_t offset, void *cookie)
+ size_t size, off_t offset, void *cookie)
{
- struct fuse_notify_retrieve_out outarg;
- struct iovec iov[2];
- struct fuse_retrieve_req *rreq;
- int err;
+ struct fuse_notify_retrieve_out outarg;
+ struct iovec iov[2];
+ struct fuse_retrieve_req *rreq;
+ int err;
- if (!se)
- return -EINVAL;
+ if (!se) {
+ return -EINVAL;
+ }
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 15)
- return -ENOSYS;
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 15) {
+ return -ENOSYS;
+ }
- rreq = malloc(sizeof(*rreq));
- if (rreq == NULL)
- return -ENOMEM;
+ rreq = malloc(sizeof(*rreq));
+ if (rreq == NULL) {
+ return -ENOMEM;
+ }
- pthread_mutex_lock(&se->lock);
- rreq->cookie = cookie;
- rreq->nreq.unique = se->notify_ctr++;
- rreq->nreq.reply = fuse_ll_retrieve_reply;
- list_add_nreq(&rreq->nreq, &se->notify_list);
- pthread_mutex_unlock(&se->lock);
+ pthread_mutex_lock(&se->lock);
+ rreq->cookie = cookie;
+ rreq->nreq.unique = se->notify_ctr++;
+ rreq->nreq.reply = fuse_ll_retrieve_reply;
+ list_add_nreq(&rreq->nreq, &se->notify_list);
+ pthread_mutex_unlock(&se->lock);
- outarg.notify_unique = rreq->nreq.unique;
- outarg.nodeid = ino;
- outarg.offset = offset;
- outarg.size = size;
- outarg.padding = 0;
+ outarg.notify_unique = rreq->nreq.unique;
+ outarg.nodeid = ino;
+ outarg.offset = offset;
+ outarg.size = size;
+ outarg.padding = 0;
- iov[1].iov_base = &outarg;
- iov[1].iov_len = sizeof(outarg);
+ iov[1].iov_base = &outarg;
+ iov[1].iov_len = sizeof(outarg);
- err = send_notify_iov(se, FUSE_NOTIFY_RETRIEVE, iov, 2);
- if (err) {
- pthread_mutex_lock(&se->lock);
- list_del_nreq(&rreq->nreq);
- pthread_mutex_unlock(&se->lock);
- free(rreq);
- }
+ err = send_notify_iov(se, FUSE_NOTIFY_RETRIEVE, iov, 2);
+ if (err) {
+ pthread_mutex_lock(&se->lock);
+ list_del_nreq(&rreq->nreq);
+ pthread_mutex_unlock(&se->lock);
+ free(rreq);
+ }
- return err;
+ return err;
}
void *fuse_req_userdata(fuse_req_t req)
{
- return req->se->userdata;
+ return req->se->userdata;
}
const struct fuse_ctx *fuse_req_ctx(fuse_req_t req)
{
- return &req->ctx;
+ return &req->ctx;
}
void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
- void *data)
+ void *data)
{
- pthread_mutex_lock(&req->lock);
- pthread_mutex_lock(&req->se->lock);
- req->u.ni.func = func;
- req->u.ni.data = data;
- pthread_mutex_unlock(&req->se->lock);
- if (req->interrupted && func)
- func(req, data);
- pthread_mutex_unlock(&req->lock);
+ pthread_mutex_lock(&req->lock);
+ pthread_mutex_lock(&req->se->lock);
+ req->u.ni.func = func;
+ req->u.ni.data = data;
+ pthread_mutex_unlock(&req->se->lock);
+ if (req->interrupted && func) {
+ func(req, data);
+ }
+ pthread_mutex_unlock(&req->lock);
}
int fuse_req_interrupted(fuse_req_t req)
{
- int interrupted;
+ int interrupted;
- pthread_mutex_lock(&req->se->lock);
- interrupted = req->interrupted;
- pthread_mutex_unlock(&req->se->lock);
+ pthread_mutex_lock(&req->se->lock);
+ interrupted = req->interrupted;
+ pthread_mutex_unlock(&req->se->lock);
- return interrupted;
+ return interrupted;
}
static struct {
- void (*func)(fuse_req_t, fuse_ino_t, const void *);
- const char *name;
+ void (*func)(fuse_req_t, fuse_ino_t, const void *);
+ const char *name;
} fuse_ll_ops[] = {
- [FUSE_LOOKUP] = { do_lookup, "LOOKUP" },
- [FUSE_FORGET] = { do_forget, "FORGET" },
- [FUSE_GETATTR] = { do_getattr, "GETATTR" },
- [FUSE_SETATTR] = { do_setattr, "SETATTR" },
- [FUSE_READLINK] = { do_readlink, "READLINK" },
- [FUSE_SYMLINK] = { do_symlink, "SYMLINK" },
- [FUSE_MKNOD] = { do_mknod, "MKNOD" },
- [FUSE_MKDIR] = { do_mkdir, "MKDIR" },
- [FUSE_UNLINK] = { do_unlink, "UNLINK" },
- [FUSE_RMDIR] = { do_rmdir, "RMDIR" },
- [FUSE_RENAME] = { do_rename, "RENAME" },
- [FUSE_LINK] = { do_link, "LINK" },
- [FUSE_OPEN] = { do_open, "OPEN" },
- [FUSE_READ] = { do_read, "READ" },
- [FUSE_WRITE] = { do_write, "WRITE" },
- [FUSE_STATFS] = { do_statfs, "STATFS" },
- [FUSE_RELEASE] = { do_release, "RELEASE" },
- [FUSE_FSYNC] = { do_fsync, "FSYNC" },
- [FUSE_SETXATTR] = { do_setxattr, "SETXATTR" },
- [FUSE_GETXATTR] = { do_getxattr, "GETXATTR" },
- [FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" },
- [FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" },
- [FUSE_FLUSH] = { do_flush, "FLUSH" },
- [FUSE_INIT] = { do_init, "INIT" },
- [FUSE_OPENDIR] = { do_opendir, "OPENDIR" },
- [FUSE_READDIR] = { do_readdir, "READDIR" },
- [FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" },
- [FUSE_FSYNCDIR] = { do_fsyncdir, "FSYNCDIR" },
- [FUSE_GETLK] = { do_getlk, "GETLK" },
- [FUSE_SETLK] = { do_setlk, "SETLK" },
- [FUSE_SETLKW] = { do_setlkw, "SETLKW" },
- [FUSE_ACCESS] = { do_access, "ACCESS" },
- [FUSE_CREATE] = { do_create, "CREATE" },
- [FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" },
- [FUSE_BMAP] = { do_bmap, "BMAP" },
- [FUSE_IOCTL] = { do_ioctl, "IOCTL" },
- [FUSE_POLL] = { do_poll, "POLL" },
- [FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" },
- [FUSE_DESTROY] = { do_destroy, "DESTROY" },
- [FUSE_NOTIFY_REPLY] = { (void *) 1, "NOTIFY_REPLY" },
- [FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" },
- [FUSE_READDIRPLUS] = { do_readdirplus, "READDIRPLUS"},
- [FUSE_RENAME2] = { do_rename2, "RENAME2" },
- [FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" },
- [FUSE_LSEEK] = { do_lseek, "LSEEK" },
+ [FUSE_LOOKUP] = { do_lookup, "LOOKUP" },
+ [FUSE_FORGET] = { do_forget, "FORGET" },
+ [FUSE_GETATTR] = { do_getattr, "GETATTR" },
+ [FUSE_SETATTR] = { do_setattr, "SETATTR" },
+ [FUSE_READLINK] = { do_readlink, "READLINK" },
+ [FUSE_SYMLINK] = { do_symlink, "SYMLINK" },
+ [FUSE_MKNOD] = { do_mknod, "MKNOD" },
+ [FUSE_MKDIR] = { do_mkdir, "MKDIR" },
+ [FUSE_UNLINK] = { do_unlink, "UNLINK" },
+ [FUSE_RMDIR] = { do_rmdir, "RMDIR" },
+ [FUSE_RENAME] = { do_rename, "RENAME" },
+ [FUSE_LINK] = { do_link, "LINK" },
+ [FUSE_OPEN] = { do_open, "OPEN" },
+ [FUSE_READ] = { do_read, "READ" },
+ [FUSE_WRITE] = { do_write, "WRITE" },
+ [FUSE_STATFS] = { do_statfs, "STATFS" },
+ [FUSE_RELEASE] = { do_release, "RELEASE" },
+ [FUSE_FSYNC] = { do_fsync, "FSYNC" },
+ [FUSE_SETXATTR] = { do_setxattr, "SETXATTR" },
+ [FUSE_GETXATTR] = { do_getxattr, "GETXATTR" },
+ [FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" },
+ [FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" },
+ [FUSE_FLUSH] = { do_flush, "FLUSH" },
+ [FUSE_INIT] = { do_init, "INIT" },
+ [FUSE_OPENDIR] = { do_opendir, "OPENDIR" },
+ [FUSE_READDIR] = { do_readdir, "READDIR" },
+ [FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" },
+ [FUSE_FSYNCDIR] = { do_fsyncdir, "FSYNCDIR" },
+ [FUSE_GETLK] = { do_getlk, "GETLK" },
+ [FUSE_SETLK] = { do_setlk, "SETLK" },
+ [FUSE_SETLKW] = { do_setlkw, "SETLKW" },
+ [FUSE_ACCESS] = { do_access, "ACCESS" },
+ [FUSE_CREATE] = { do_create, "CREATE" },
+ [FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" },
+ [FUSE_BMAP] = { do_bmap, "BMAP" },
+ [FUSE_IOCTL] = { do_ioctl, "IOCTL" },
+ [FUSE_POLL] = { do_poll, "POLL" },
+ [FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" },
+ [FUSE_DESTROY] = { do_destroy, "DESTROY" },
+ [FUSE_NOTIFY_REPLY] = { (void *)1, "NOTIFY_REPLY" },
+ [FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" },
+ [FUSE_READDIRPLUS] = { do_readdirplus, "READDIRPLUS" },
+ [FUSE_RENAME2] = { do_rename2, "RENAME2" },
+ [FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" },
+ [FUSE_LSEEK] = { do_lseek, "LSEEK" },
};
#define FUSE_MAXOP (sizeof(fuse_ll_ops) / sizeof(fuse_ll_ops[0]))
static const char *opname(enum fuse_opcode opcode)
{
- if (opcode >= FUSE_MAXOP || !fuse_ll_ops[opcode].name)
- return "???";
- else
- return fuse_ll_ops[opcode].name;
+ if (opcode >= FUSE_MAXOP || !fuse_ll_ops[opcode].name) {
+ return "???";
+ } else {
+ return fuse_ll_ops[opcode].name;
+ }
}
void fuse_session_process_buf(struct fuse_session *se,
- const struct fuse_buf *buf)
+ const struct fuse_buf *buf)
{
- fuse_session_process_buf_int(se, buf, NULL);
+ fuse_session_process_buf_int(se, buf, NULL);
}
void fuse_session_process_buf_int(struct fuse_session *se,
- const struct fuse_buf *buf, struct fuse_chan *ch)
-{
- struct fuse_in_header *in;
- const void *inarg;
- struct fuse_req *req;
- int err;
-
- in = buf->mem;
-
- if (se->debug) {
- fuse_log(FUSE_LOG_DEBUG,
- "unique: %llu, opcode: %s (%i), nodeid: %llu, insize: %zu, pid: %u\n",
- (unsigned long long) in->unique,
- opname((enum fuse_opcode) in->opcode), in->opcode,
- (unsigned long long) in->nodeid, buf->size, in->pid);
- }
-
- req = fuse_ll_alloc_req(se);
- if (req == NULL) {
- struct fuse_out_header out = {
- .unique = in->unique,
- .error = -ENOMEM,
- };
- struct iovec iov = {
- .iov_base = &out,
- .iov_len = sizeof(struct fuse_out_header),
- };
-
- fuse_send_msg(se, ch, &iov, 1);
- return;
- }
-
- req->unique = in->unique;
- req->ctx.uid = in->uid;
- req->ctx.gid = in->gid;
- req->ctx.pid = in->pid;
- req->ch = ch;
-
- err = EIO;
- if (!se->got_init) {
- enum fuse_opcode expected;
-
- expected = se->cuse_data ? CUSE_INIT : FUSE_INIT;
- if (in->opcode != expected)
- goto reply_err;
- } else if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT)
- goto reply_err;
-
- err = EACCES;
- /* Implement -o allow_root */
- if (se->deny_others && in->uid != se->owner && in->uid != 0 &&
- in->opcode != FUSE_INIT && in->opcode != FUSE_READ &&
- in->opcode != FUSE_WRITE && in->opcode != FUSE_FSYNC &&
- in->opcode != FUSE_RELEASE && in->opcode != FUSE_READDIR &&
- in->opcode != FUSE_FSYNCDIR && in->opcode != FUSE_RELEASEDIR &&
- in->opcode != FUSE_NOTIFY_REPLY &&
- in->opcode != FUSE_READDIRPLUS)
- goto reply_err;
-
- err = ENOSYS;
- if (in->opcode >= FUSE_MAXOP || !fuse_ll_ops[in->opcode].func)
- goto reply_err;
- if (in->opcode != FUSE_INTERRUPT) {
- struct fuse_req *intr;
- pthread_mutex_lock(&se->lock);
- intr = check_interrupt(se, req);
- list_add_req(req, &se->list);
- pthread_mutex_unlock(&se->lock);
- if (intr)
- fuse_reply_err(intr, EAGAIN);
- }
-
- inarg = (void *) &in[1];
- if (in->opcode == FUSE_WRITE && se->op.write_buf)
- do_write_buf(req, in->nodeid, inarg, buf);
- else if (in->opcode == FUSE_NOTIFY_REPLY)
- do_notify_reply(req, in->nodeid, inarg, buf);
- else
- fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
-
- return;
+ const struct fuse_buf *buf,
+ struct fuse_chan *ch)
+{
+ struct fuse_in_header *in;
+ const void *inarg;
+ struct fuse_req *req;
+ int err;
+
+ in = buf->mem;
+
+ if (se->debug) {
+ fuse_log(FUSE_LOG_DEBUG,
+ "unique: %llu, opcode: %s (%i), nodeid: %llu, insize: %zu, "
+ "pid: %u\n",
+ (unsigned long long)in->unique,
+ opname((enum fuse_opcode)in->opcode), in->opcode,
+ (unsigned long long)in->nodeid, buf->size, in->pid);
+ }
+
+ req = fuse_ll_alloc_req(se);
+ if (req == NULL) {
+ struct fuse_out_header out = {
+ .unique = in->unique,
+ .error = -ENOMEM,
+ };
+ struct iovec iov = {
+ .iov_base = &out,
+ .iov_len = sizeof(struct fuse_out_header),
+ };
+
+ fuse_send_msg(se, ch, &iov, 1);
+ return;
+ }
+
+ req->unique = in->unique;
+ req->ctx.uid = in->uid;
+ req->ctx.gid = in->gid;
+ req->ctx.pid = in->pid;
+ req->ch = ch;
+
+ err = EIO;
+ if (!se->got_init) {
+ enum fuse_opcode expected;
+
+ expected = se->cuse_data ? CUSE_INIT : FUSE_INIT;
+ if (in->opcode != expected) {
+ goto reply_err;
+ }
+ } else if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT) {
+ goto reply_err;
+ }
+
+ err = EACCES;
+ /* Implement -o allow_root */
+ if (se->deny_others && in->uid != se->owner && in->uid != 0 &&
+ in->opcode != FUSE_INIT && in->opcode != FUSE_READ &&
+ in->opcode != FUSE_WRITE && in->opcode != FUSE_FSYNC &&
+ in->opcode != FUSE_RELEASE && in->opcode != FUSE_READDIR &&
+ in->opcode != FUSE_FSYNCDIR && in->opcode != FUSE_RELEASEDIR &&
+ in->opcode != FUSE_NOTIFY_REPLY && in->opcode != FUSE_READDIRPLUS) {
+ goto reply_err;
+ }
+
+ err = ENOSYS;
+ if (in->opcode >= FUSE_MAXOP || !fuse_ll_ops[in->opcode].func) {
+ goto reply_err;
+ }
+ if (in->opcode != FUSE_INTERRUPT) {
+ struct fuse_req *intr;
+ pthread_mutex_lock(&se->lock);
+ intr = check_interrupt(se, req);
+ list_add_req(req, &se->list);
+ pthread_mutex_unlock(&se->lock);
+ if (intr) {
+ fuse_reply_err(intr, EAGAIN);
+ }
+ }
+
+ inarg = (void *)&in[1];
+ if (in->opcode == FUSE_WRITE && se->op.write_buf) {
+ do_write_buf(req, in->nodeid, inarg, buf);
+ } else if (in->opcode == FUSE_NOTIFY_REPLY) {
+ do_notify_reply(req, in->nodeid, inarg, buf);
+ } else {
+ fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
+ }
+
+ return;
reply_err:
- fuse_reply_err(req, err);
+ fuse_reply_err(req, err);
}
-#define LL_OPTION(n,o,v) \
- { n, offsetof(struct fuse_session, o), v }
+#define LL_OPTION(n, o, v) \
+ { \
+ n, offsetof(struct fuse_session, o), v \
+ }
static const struct fuse_opt fuse_ll_opts[] = {
- LL_OPTION("debug", debug, 1),
- LL_OPTION("-d", debug, 1),
- LL_OPTION("--debug", debug, 1),
- LL_OPTION("allow_root", deny_others, 1),
- FUSE_OPT_END
+ LL_OPTION("debug", debug, 1), LL_OPTION("-d", debug, 1),
+ LL_OPTION("--debug", debug, 1), LL_OPTION("allow_root", deny_others, 1),
+ FUSE_OPT_END
};
void fuse_lowlevel_version(void)
{
- printf("using FUSE kernel interface version %i.%i\n",
- FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
+ printf("using FUSE kernel interface version %i.%i\n", FUSE_KERNEL_VERSION,
+ FUSE_KERNEL_MINOR_VERSION);
}
void fuse_lowlevel_help(void)
{
- /* These are not all options, but the ones that are
- potentially of interest to an end-user */
- printf(
-" -o allow_root allow access by root\n"
-);
+ /*
+ * These are not all options, but the ones that are
+ * potentially of interest to an end-user
+ */
+ printf(" -o allow_root allow access by root\n");
}
void fuse_session_destroy(struct fuse_session *se)
{
- if (se->got_init && !se->got_destroy) {
- if (se->op.destroy)
- se->op.destroy(se->userdata);
- }
- pthread_mutex_destroy(&se->lock);
- free(se->cuse_data);
- if (se->fd != -1)
- close(se->fd);
- free(se);
+ if (se->got_init && !se->got_destroy) {
+ if (se->op.destroy) {
+ se->op.destroy(se->userdata);
+ }
+ }
+ pthread_mutex_destroy(&se->lock);
+ free(se->cuse_data);
+ if (se->fd != -1) {
+ close(se->fd);
+ }
+ free(se);
}
struct fuse_session *fuse_session_new(struct fuse_args *args,
- const struct fuse_lowlevel_ops *op,
- size_t op_size, void *userdata)
-{
- struct fuse_session *se;
-
- if (sizeof(struct fuse_lowlevel_ops) < op_size) {
- fuse_log(FUSE_LOG_ERR, "fuse: warning: library too old, some operations may not work\n");
- op_size = sizeof(struct fuse_lowlevel_ops);
- }
-
- if (args->argc == 0) {
- fuse_log(FUSE_LOG_ERR, "fuse: empty argv passed to fuse_session_new().\n");
- return NULL;
- }
-
- se = (struct fuse_session *) calloc(1, sizeof(struct fuse_session));
- if (se == NULL) {
- fuse_log(FUSE_LOG_ERR, "fuse: failed to allocate fuse object\n");
- goto out1;
- }
- se->fd = -1;
- se->conn.max_write = UINT_MAX;
- se->conn.max_readahead = UINT_MAX;
-
- /* Parse options */
- if(fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1)
- goto out2;
- if(args->argc == 1 &&
- args->argv[0][0] == '-') {
- fuse_log(FUSE_LOG_ERR, "fuse: warning: argv[0] looks like an option, but "
- "will be ignored\n");
- } else if (args->argc != 1) {
- int i;
- fuse_log(FUSE_LOG_ERR, "fuse: unknown option(s): `");
- for(i = 1; i < args->argc-1; i++)
- fuse_log(FUSE_LOG_ERR, "%s ", args->argv[i]);
- fuse_log(FUSE_LOG_ERR, "%s'\n", args->argv[i]);
- goto out4;
- }
-
- se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() +
- FUSE_BUFFER_HEADER_SIZE;
-
- list_init_req(&se->list);
- list_init_req(&se->interrupts);
- list_init_nreq(&se->notify_list);
- se->notify_ctr = 1;
- fuse_mutex_init(&se->lock);
-
- memcpy(&se->op, op, op_size);
- se->owner = getuid();
- se->userdata = userdata;
-
- return se;
+ const struct fuse_lowlevel_ops *op,
+ size_t op_size, void *userdata)
+{
+ struct fuse_session *se;
+
+ if (sizeof(struct fuse_lowlevel_ops) < op_size) {
+ fuse_log(
+ FUSE_LOG_ERR,
+ "fuse: warning: library too old, some operations may not work\n");
+ op_size = sizeof(struct fuse_lowlevel_ops);
+ }
+
+ if (args->argc == 0) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: empty argv passed to fuse_session_new().\n");
+ return NULL;
+ }
+
+ se = (struct fuse_session *)calloc(1, sizeof(struct fuse_session));
+ if (se == NULL) {
+ fuse_log(FUSE_LOG_ERR, "fuse: failed to allocate fuse object\n");
+ goto out1;
+ }
+ se->fd = -1;
+ se->conn.max_write = UINT_MAX;
+ se->conn.max_readahead = UINT_MAX;
+
+ /* Parse options */
+ if (fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1) {
+ goto out2;
+ }
+ if (args->argc == 1 && args->argv[0][0] == '-') {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: warning: argv[0] looks like an option, but "
+ "will be ignored\n");
+ } else if (args->argc != 1) {
+ int i;
+ fuse_log(FUSE_LOG_ERR, "fuse: unknown option(s): `");
+ for (i = 1; i < args->argc - 1; i++) {
+ fuse_log(FUSE_LOG_ERR, "%s ", args->argv[i]);
+ }
+ fuse_log(FUSE_LOG_ERR, "%s'\n", args->argv[i]);
+ goto out4;
+ }
+
+ se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() + FUSE_BUFFER_HEADER_SIZE;
+
+ list_init_req(&se->list);
+ list_init_req(&se->interrupts);
+ list_init_nreq(&se->notify_list);
+ se->notify_ctr = 1;
+ fuse_mutex_init(&se->lock);
+
+ memcpy(&se->op, op, op_size);
+ se->owner = getuid();
+ se->userdata = userdata;
+
+ return se;
out4:
- fuse_opt_free_args(args);
+ fuse_opt_free_args(args);
out2:
- free(se);
+ free(se);
out1:
- return NULL;
+ return NULL;
}
int fuse_session_mount(struct fuse_session *se, const char *mountpoint)
{
- int fd;
-
- /*
- * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
- * would ensue.
- */
- do {
- fd = open("/dev/null", O_RDWR);
- if (fd > 2)
- close(fd);
- } while (fd >= 0 && fd <= 2);
-
- /*
- * To allow FUSE daemons to run without privileges, the caller may open
- * /dev/fuse before launching the file system and pass on the file
- * descriptor by specifying /dev/fd/N as the mount point. Note that the
- * parent process takes care of performing the mount in this case.
- */
- fd = fuse_mnt_parse_fuse_fd(mountpoint);
- if (fd != -1) {
- if (fcntl(fd, F_GETFD) == -1) {
- fuse_log(FUSE_LOG_ERR,
- "fuse: Invalid file descriptor /dev/fd/%u\n",
- fd);
- return -1;
- }
- se->fd = fd;
- return 0;
- }
-
- /* Open channel */
- fd = fuse_kern_mount(mountpoint, se->mo);
- if (fd == -1)
- return -1;
- se->fd = fd;
-
- /* Save mountpoint */
- se->mountpoint = strdup(mountpoint);
- if (se->mountpoint == NULL)
- goto error_out;
-
- return 0;
+ int fd;
+
+ /*
+ * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
+ * would ensue.
+ */
+ do {
+ fd = open("/dev/null", O_RDWR);
+ if (fd > 2) {
+ close(fd);
+ }
+ } while (fd >= 0 && fd <= 2);
+
+ /*
+ * To allow FUSE daemons to run without privileges, the caller may open
+ * /dev/fuse before launching the file system and pass on the file
+ * descriptor by specifying /dev/fd/N as the mount point. Note that the
+ * parent process takes care of performing the mount in this case.
+ */
+ fd = fuse_mnt_parse_fuse_fd(mountpoint);
+ if (fd != -1) {
+ if (fcntl(fd, F_GETFD) == -1) {
+ fuse_log(FUSE_LOG_ERR, "fuse: Invalid file descriptor /dev/fd/%u\n",
+ fd);
+ return -1;
+ }
+ se->fd = fd;
+ return 0;
+ }
+
+ /* Open channel */
+ fd = fuse_kern_mount(mountpoint, se->mo);
+ if (fd == -1) {
+ return -1;
+ }
+ se->fd = fd;
+
+ /* Save mountpoint */
+ se->mountpoint = strdup(mountpoint);
+ if (se->mountpoint == NULL) {
+ goto error_out;
+ }
+
+ return 0;
error_out:
- fuse_kern_unmount(mountpoint, fd);
- return -1;
+ fuse_kern_unmount(mountpoint, fd);
+ return -1;
}
int fuse_session_fd(struct fuse_session *se)
{
- return se->fd;
+ return se->fd;
}
void fuse_session_unmount(struct fuse_session *se)
@@ -2384,61 +2519,66 @@ void fuse_session_unmount(struct fuse_session *se)
#ifdef linux
int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
{
- char *buf;
- size_t bufsize = 1024;
- char path[128];
- int ret;
- int fd;
- unsigned long pid = req->ctx.pid;
- char *s;
+ char *buf;
+ size_t bufsize = 1024;
+ char path[128];
+ int ret;
+ int fd;
+ unsigned long pid = req->ctx.pid;
+ char *s;
- sprintf(path, "/proc/%lu/task/%lu/status", pid, pid);
+ sprintf(path, "/proc/%lu/task/%lu/status", pid, pid);
retry:
- buf = malloc(bufsize);
- if (buf == NULL)
- return -ENOMEM;
-
- ret = -EIO;
- fd = open(path, O_RDONLY);
- if (fd == -1)
- goto out_free;
-
- ret = read(fd, buf, bufsize);
- close(fd);
- if (ret < 0) {
- ret = -EIO;
- goto out_free;
- }
-
- if ((size_t)ret == bufsize) {
- free(buf);
- bufsize *= 4;
- goto retry;
- }
-
- ret = -EIO;
- s = strstr(buf, "\nGroups:");
- if (s == NULL)
- goto out_free;
-
- s += 8;
- ret = 0;
- while (1) {
- char *end;
- unsigned long val = strtoul(s, &end, 0);
- if (end == s)
- break;
-
- s = end;
- if (ret < size)
- list[ret] = val;
- ret++;
- }
+ buf = malloc(bufsize);
+ if (buf == NULL) {
+ return -ENOMEM;
+ }
+
+ ret = -EIO;
+ fd = open(path, O_RDONLY);
+ if (fd == -1) {
+ goto out_free;
+ }
+
+ ret = read(fd, buf, bufsize);
+ close(fd);
+ if (ret < 0) {
+ ret = -EIO;
+ goto out_free;
+ }
+
+ if ((size_t)ret == bufsize) {
+ free(buf);
+ bufsize *= 4;
+ goto retry;
+ }
+
+ ret = -EIO;
+ s = strstr(buf, "\nGroups:");
+ if (s == NULL) {
+ goto out_free;
+ }
+
+ s += 8;
+ ret = 0;
+ while (1) {
+ char *end;
+ unsigned long val = strtoul(s, &end, 0);
+ if (end == s) {
+ break;
+ }
+
+ s = end;
+ if (ret < size) {
+ list[ret] = val;
+ }
+ ret++;
+ }
out_free:
- free(buf);
- return ret;
+ free(buf);
+ return ret;
}
#else /* linux */
/*
@@ -2446,23 +2586,25 @@ out_free:
*/
int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
{
- (void) req; (void) size; (void) list;
- return -ENOSYS;
+ (void)req;
+ (void)size;
+ (void)list;
+ return -ENOSYS;
}
#endif
void fuse_session_exit(struct fuse_session *se)
{
- se->exited = 1;
+ se->exited = 1;
}
void fuse_session_reset(struct fuse_session *se)
{
- se->exited = 0;
- se->error = 0;
+ se->exited = 0;
+ se->error = 0;
}
int fuse_session_exited(struct fuse_session *se)
{
- return se->exited;
+ return se->exited;
}
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index 6b1adfcfd1..adb9054bb1 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -1,15 +1,16 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB.
-*/
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB.
+ */
#ifndef FUSE_LOWLEVEL_H_
#define FUSE_LOWLEVEL_H_
-/** @file
+/**
+ * @file
*
* Low level API
*
@@ -24,16 +25,16 @@
#include "fuse_common.h"
-#include <utime.h>
#include <fcntl.h>
-#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
+#include <sys/types.h>
#include <sys/uio.h>
+#include <utime.h>
-/* ----------------------------------------------------------- *
- * Miscellaneous definitions *
- * ----------------------------------------------------------- */
+/*
+ * Miscellaneous definitions
+ */
/** The node ID of the root inode */
#define FUSE_ROOT_ID 1
@@ -53,47 +54,54 @@ struct fuse_session;
/** Directory entry parameters supplied to fuse_reply_entry() */
struct fuse_entry_param {
- /** Unique inode number
- *
- * In lookup, zero means negative entry (from version 2.5)
- * Returning ENOENT also means negative entry, but by setting zero
- * ino the kernel may cache negative entries for entry_timeout
- * seconds.
- */
- fuse_ino_t ino;
-
- /** Generation number for this entry.
- *
- * If the file system will be exported over NFS, the
- * ino/generation pairs need to be unique over the file
- * system's lifetime (rather than just the mount time). So if
- * the file system reuses an inode after it has been deleted,
- * it must assign a new, previously unused generation number
- * to the inode at the same time.
- *
- */
- uint64_t generation;
-
- /** Inode attributes.
- *
- * Even if attr_timeout == 0, attr must be correct. For example,
- * for open(), FUSE uses attr.st_size from lookup() to determine
- * how many bytes to request. If this value is not correct,
- * incorrect data will be returned.
- */
- struct stat attr;
-
- /** Validity timeout (in seconds) for inode attributes. If
- attributes only change as a result of requests that come
- through the kernel, this should be set to a very large
- value. */
- double attr_timeout;
-
- /** Validity timeout (in seconds) for the name. If directory
- entries are changed/deleted only as a result of requests
- that come through the kernel, this should be set to a very
- large value. */
- double entry_timeout;
+ /**
+ * Unique inode number
+ *
+ * In lookup, zero means negative entry (from version 2.5)
+ * Returning ENOENT also means negative entry, but by setting zero
+ * ino the kernel may cache negative entries for entry_timeout
+ * seconds.
+ */
+ fuse_ino_t ino;
+
+ /**
+ * Generation number for this entry.
+ *
+ * If the file system will be exported over NFS, the
+ * ino/generation pairs need to be unique over the file
+ * system's lifetime (rather than just the mount time). So if
+ * the file system reuses an inode after it has been deleted,
+ * it must assign a new, previously unused generation number
+ * to the inode at the same time.
+ *
+ */
+ uint64_t generation;
+
+ /**
+ * Inode attributes.
+ *
+ * Even if attr_timeout == 0, attr must be correct. For example,
+ * for open(), FUSE uses attr.st_size from lookup() to determine
+ * how many bytes to request. If this value is not correct,
+ * incorrect data will be returned.
+ */
+ struct stat attr;
+
+ /**
+ * Validity timeout (in seconds) for inode attributes. If
+ * attributes only change as a result of requests that come
+ * through the kernel, this should be set to a very large
+ * value.
+ */
+ double attr_timeout;
+
+ /**
+ * Validity timeout (in seconds) for the name. If directory
+ * entries are changed/deleted only as a result of requests
+ * that come through the kernel, this should be set to a very
+ * large value.
+ */
+ double entry_timeout;
};
/**
@@ -105,38 +113,38 @@ struct fuse_entry_param {
* there is no valid uid/pid/gid that could be reported.
*/
struct fuse_ctx {
- /** User ID of the calling process */
- uid_t uid;
+ /** User ID of the calling process */
+ uid_t uid;
- /** Group ID of the calling process */
- gid_t gid;
+ /** Group ID of the calling process */
+ gid_t gid;
- /** Thread ID of the calling process */
- pid_t pid;
+ /** Thread ID of the calling process */
+ pid_t pid;
- /** Umask of the calling process */
- mode_t umask;
+ /** Umask of the calling process */
+ mode_t umask;
};
struct fuse_forget_data {
- fuse_ino_t ino;
- uint64_t nlookup;
+ fuse_ino_t ino;
+ uint64_t nlookup;
};
/* 'to_set' flags in setattr */
-#define FUSE_SET_ATTR_MODE (1 << 0)
-#define FUSE_SET_ATTR_UID (1 << 1)
-#define FUSE_SET_ATTR_GID (1 << 2)
-#define FUSE_SET_ATTR_SIZE (1 << 3)
-#define FUSE_SET_ATTR_ATIME (1 << 4)
-#define FUSE_SET_ATTR_MTIME (1 << 5)
-#define FUSE_SET_ATTR_ATIME_NOW (1 << 7)
-#define FUSE_SET_ATTR_MTIME_NOW (1 << 8)
-#define FUSE_SET_ATTR_CTIME (1 << 10)
-
-/* ----------------------------------------------------------- *
- * Request methods and replies *
- * ----------------------------------------------------------- */
+#define FUSE_SET_ATTR_MODE (1 << 0)
+#define FUSE_SET_ATTR_UID (1 << 1)
+#define FUSE_SET_ATTR_GID (1 << 2)
+#define FUSE_SET_ATTR_SIZE (1 << 3)
+#define FUSE_SET_ATTR_ATIME (1 << 4)
+#define FUSE_SET_ATTR_MTIME (1 << 5)
+#define FUSE_SET_ATTR_ATIME_NOW (1 << 7)
+#define FUSE_SET_ATTR_MTIME_NOW (1 << 8)
+#define FUSE_SET_ATTR_CTIME (1 << 10)
+
+/*
+ * Request methods and replies
+ */
/**
* Low level filesystem operations
@@ -166,1075 +174,1069 @@ struct fuse_forget_data {
* this file will not be called.
*/
struct fuse_lowlevel_ops {
- /**
- * Initialize filesystem
- *
- * This function is called when libfuse establishes
- * communication with the FUSE kernel module. The file system
- * should use this module to inspect and/or modify the
- * connection parameters provided in the `conn` structure.
- *
- * Note that some parameters may be overwritten by options
- * passed to fuse_session_new() which take precedence over the
- * values set in this handler.
- *
- * There's no reply to this function
- *
- * @param userdata the user data passed to fuse_session_new()
- */
- void (*init) (void *userdata, struct fuse_conn_info *conn);
-
- /**
- * Clean up filesystem.
- *
- * Called on filesystem exit. When this method is called, the
- * connection to the kernel may be gone already, so that eg. calls
- * to fuse_lowlevel_notify_* will fail.
- *
- * There's no reply to this function
- *
- * @param userdata the user data passed to fuse_session_new()
- */
- void (*destroy) (void *userdata);
-
- /**
- * Look up a directory entry by name and get its attributes.
- *
- * Valid replies:
- * fuse_reply_entry
- * fuse_reply_err
- *
- * @param req request handle
- * @param parent inode number of the parent directory
- * @param name the name to look up
- */
- void (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name);
-
- /**
- * Forget about an inode
- *
- * This function is called when the kernel removes an inode
- * from its internal caches.
- *
- * The inode's lookup count increases by one for every call to
- * fuse_reply_entry and fuse_reply_create. The nlookup parameter
- * indicates by how much the lookup count should be decreased.
- *
- * Inodes with a non-zero lookup count may receive request from
- * the kernel even after calls to unlink, rmdir or (when
- * overwriting an existing file) rename. Filesystems must handle
- * such requests properly and it is recommended to defer removal
- * of the inode until the lookup count reaches zero. Calls to
- * unlink, rmdir or rename will be followed closely by forget
- * unless the file or directory is open, in which case the
- * kernel issues forget only after the release or releasedir
- * calls.
- *
- * Note that if a file system will be exported over NFS the
- * inodes lifetime must extend even beyond forget. See the
- * generation field in struct fuse_entry_param above.
- *
- * On unmount the lookup count for all inodes implicitly drops
- * to zero. It is not guaranteed that the file system will
- * receive corresponding forget messages for the affected
- * inodes.
- *
- * Valid replies:
- * fuse_reply_none
- *
- * @param req request handle
- * @param ino the inode number
- * @param nlookup the number of lookups to forget
- */
- void (*forget) (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup);
-
- /**
- * Get file attributes.
- *
- * If writeback caching is enabled, the kernel may have a
- * better idea of a file's length than the FUSE file system
- * (eg if there has been a write that extended the file size,
- * but that has not yet been passed to the filesystem.n
- *
- * In this case, the st_size value provided by the file system
- * will be ignored.
- *
- * Valid replies:
- * fuse_reply_attr
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi for future use, currently always NULL
- */
- void (*getattr) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi);
-
- /**
- * Set file attributes
- *
- * In the 'attr' argument only members indicated by the 'to_set'
- * bitmask contain valid values. Other members contain undefined
- * values.
- *
- * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
- * expected to reset the setuid and setgid bits if the file
- * size or owner is being changed.
- *
- * If the setattr was invoked from the ftruncate() system call
- * under Linux kernel versions 2.6.15 or later, the fi->fh will
- * contain the value set by the open method or will be undefined
- * if the open method didn't set any value. Otherwise (not
- * ftruncate call, or kernel version earlier than 2.6.15) the fi
- * parameter will be NULL.
- *
- * Valid replies:
- * fuse_reply_attr
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param attr the attributes
- * @param to_set bit mask of attributes which should be set
- * @param fi file information, or NULL
- */
- void (*setattr) (fuse_req_t req, fuse_ino_t ino, struct stat *attr,
- int to_set, struct fuse_file_info *fi);
-
- /**
- * Read symbolic link
- *
- * Valid replies:
- * fuse_reply_readlink
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- */
- void (*readlink) (fuse_req_t req, fuse_ino_t ino);
-
- /**
- * Create file node
- *
- * Create a regular file, character device, block device, fifo or
- * socket node.
- *
- * Valid replies:
- * fuse_reply_entry
- * fuse_reply_err
- *
- * @param req request handle
- * @param parent inode number of the parent directory
- * @param name to create
- * @param mode file type and mode with which to create the new file
- * @param rdev the device number (only valid if created file is a device)
- */
- void (*mknod) (fuse_req_t req, fuse_ino_t parent, const char *name,
- mode_t mode, dev_t rdev);
-
- /**
- * Create a directory
- *
- * Valid replies:
- * fuse_reply_entry
- * fuse_reply_err
- *
- * @param req request handle
- * @param parent inode number of the parent directory
- * @param name to create
- * @param mode with which to create the new file
- */
- void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const char *name,
- mode_t mode);
-
- /**
- * Remove a file
- *
- * If the file's inode's lookup count is non-zero, the file
- * system is expected to postpone any removal of the inode
- * until the lookup count reaches zero (see description of the
- * forget function).
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param parent inode number of the parent directory
- * @param name to remove
- */
- void (*unlink) (fuse_req_t req, fuse_ino_t parent, const char *name);
-
- /**
- * Remove a directory
- *
- * If the directory's inode's lookup count is non-zero, the
- * file system is expected to postpone any removal of the
- * inode until the lookup count reaches zero (see description
- * of the forget function).
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param parent inode number of the parent directory
- * @param name to remove
- */
- void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const char *name);
-
- /**
- * Create a symbolic link
- *
- * Valid replies:
- * fuse_reply_entry
- * fuse_reply_err
- *
- * @param req request handle
- * @param link the contents of the symbolic link
- * @param parent inode number of the parent directory
- * @param name to create
- */
- void (*symlink) (fuse_req_t req, const char *link, fuse_ino_t parent,
- const char *name);
-
- /** Rename a file
- *
- * If the target exists it should be atomically replaced. If
- * the target's inode's lookup count is non-zero, the file
- * system is expected to postpone any removal of the inode
- * until the lookup count reaches zero (see description of the
- * forget function).
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure with error code EINVAL, i.e. all
- * future bmap requests will fail with EINVAL without being
- * send to the filesystem process.
- *
- * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If
- * RENAME_NOREPLACE is specified, the filesystem must not
- * overwrite *newname* if it exists and return an error
- * instead. If `RENAME_EXCHANGE` is specified, the filesystem
- * must atomically exchange the two files, i.e. both must
- * exist and neither may be deleted.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param parent inode number of the old parent directory
- * @param name old name
- * @param newparent inode number of the new parent directory
- * @param newname new name
- */
- void (*rename) (fuse_req_t req, fuse_ino_t parent, const char *name,
- fuse_ino_t newparent, const char *newname,
- unsigned int flags);
-
- /**
- * Create a hard link
- *
- * Valid replies:
- * fuse_reply_entry
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the old inode number
- * @param newparent inode number of the new parent directory
- * @param newname new name to create
- */
- void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
- const char *newname);
-
- /**
- * Open a file
- *
- * Open flags are available in fi->flags. The following rules
- * apply.
- *
- * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be
- * filtered out / handled by the kernel.
- *
- * - Access modes (O_RDONLY, O_WRONLY, O_RDWR) should be used
- * by the filesystem to check if the operation is
- * permitted. If the ``-o default_permissions`` mount
- * option is given, this check is already done by the
- * kernel before calling open() and may thus be omitted by
- * the filesystem.
- *
- * - When writeback caching is enabled, the kernel may send
- * read requests even for files opened with O_WRONLY. The
- * filesystem should be prepared to handle this.
- *
- * - When writeback caching is disabled, the filesystem is
- * expected to properly handle the O_APPEND flag and ensure
- * that each write is appending to the end of the file.
- *
- * - When writeback caching is enabled, the kernel will
- * handle O_APPEND. However, unless all changes to the file
- * come through the kernel this will not work reliably. The
- * filesystem should thus either ignore the O_APPEND flag
- * (and let the kernel handle it), or return an error
- * (indicating that reliably O_APPEND is not available).
- *
- * Filesystem may store an arbitrary file handle (pointer,
- * index, etc) in fi->fh, and use this in other all other file
- * operations (read, write, flush, release, fsync).
- *
- * Filesystem may also implement stateless file I/O and not store
- * anything in fi->fh.
- *
- * There are also some flags (direct_io, keep_cache) which the
- * filesystem may set in fi, to change the way the file is opened.
- * See fuse_file_info structure in <fuse_common.h> for more details.
- *
- * If this request is answered with an error code of ENOSYS
- * and FUSE_CAP_NO_OPEN_SUPPORT is set in
- * `fuse_conn_info.capable`, this is treated as success and
- * future calls to open and release will also succeed without being
- * sent to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_open
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- */
- void (*open) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi);
-
- /**
- * Read data
- *
- * Read should send exactly the number of bytes requested except
- * on EOF or error, otherwise the rest of the data will be
- * substituted with zeroes. An exception to this is when the file
- * has been opened in 'direct_io' mode, in which case the return
- * value of the read system call will reflect the return value of
- * this operation.
- *
- * fi->fh will contain the value set by the open method, or will
- * be undefined if the open method didn't set any value.
- *
- * Valid replies:
- * fuse_reply_buf
- * fuse_reply_iov
- * fuse_reply_data
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param size number of bytes to read
- * @param off offset to read from
- * @param fi file information
- */
- void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
- struct fuse_file_info *fi);
-
- /**
- * Write data
- *
- * Write should return exactly the number of bytes requested
- * except on error. An exception to this is when the file has
- * been opened in 'direct_io' mode, in which case the return value
- * of the write system call will reflect the return value of this
- * operation.
- *
- * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
- * expected to reset the setuid and setgid bits.
- *
- * fi->fh will contain the value set by the open method, or will
- * be undefined if the open method didn't set any value.
- *
- * Valid replies:
- * fuse_reply_write
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param buf data to write
- * @param size number of bytes to write
- * @param off offset to write to
- * @param fi file information
- */
- void (*write) (fuse_req_t req, fuse_ino_t ino, const char *buf,
- size_t size, off_t off, struct fuse_file_info *fi);
-
- /**
- * Flush method
- *
- * This is called on each close() of the opened file.
- *
- * Since file descriptors can be duplicated (dup, dup2, fork), for
- * one open call there may be many flush calls.
- *
- * Filesystems shouldn't assume that flush will always be called
- * after some writes, or that if will be called at all.
- *
- * fi->fh will contain the value set by the open method, or will
- * be undefined if the open method didn't set any value.
- *
- * NOTE: the name of the method is misleading, since (unlike
- * fsync) the filesystem is not forced to flush pending writes.
- * One reason to flush data is if the filesystem wants to return
- * write errors during close. However, such use is non-portable
- * because POSIX does not require [close] to wait for delayed I/O to
- * complete.
- *
- * If the filesystem supports file locking operations (setlk,
- * getlk) it should remove all locks belonging to 'fi->owner'.
- *
- * If this request is answered with an error code of ENOSYS,
- * this is treated as success and future calls to flush() will
- * succeed automatically without being send to the filesystem
- * process.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- *
- * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
- */
- void (*flush) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi);
-
- /**
- * Release an open file
- *
- * Release is called when there are no more references to an open
- * file: all file descriptors are closed and all memory mappings
- * are unmapped.
- *
- * For every open call there will be exactly one release call (unless
- * the filesystem is force-unmounted).
- *
- * The filesystem may reply with an error, but error values are
- * not returned to close() or munmap() which triggered the
- * release.
- *
- * fi->fh will contain the value set by the open method, or will
- * be undefined if the open method didn't set any value.
- * fi->flags will contain the same flags as for open.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- */
- void (*release) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi);
-
- /**
- * Synchronize file contents
- *
- * If the datasync parameter is non-zero, then only the user data
- * should be flushed, not the meta data.
- *
- * If this request is answered with an error code of ENOSYS,
- * this is treated as success and future calls to fsync() will
- * succeed automatically without being send to the filesystem
- * process.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param datasync flag indicating if only data should be flushed
- * @param fi file information
- */
- void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync,
- struct fuse_file_info *fi);
-
- /**
- * Open a directory
- *
- * Filesystem may store an arbitrary file handle (pointer, index,
- * etc) in fi->fh, and use this in other all other directory
- * stream operations (readdir, releasedir, fsyncdir).
- *
- * If this request is answered with an error code of ENOSYS and
- * FUSE_CAP_NO_OPENDIR_SUPPORT is set in `fuse_conn_info.capable`,
- * this is treated as success and future calls to opendir and
- * releasedir will also succeed without being sent to the filesystem
- * process. In addition, the kernel will cache readdir results
- * as if opendir returned FOPEN_KEEP_CACHE | FOPEN_CACHE_DIR.
- *
- * Valid replies:
- * fuse_reply_open
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- */
- void (*opendir) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi);
-
- /**
- * Read directory
- *
- * Send a buffer filled using fuse_add_direntry(), with size not
- * exceeding the requested size. Send an empty buffer on end of
- * stream.
- *
- * fi->fh will contain the value set by the opendir method, or
- * will be undefined if the opendir method didn't set any value.
- *
- * Returning a directory entry from readdir() does not affect
- * its lookup count.
- *
- * If off_t is non-zero, then it will correspond to one of the off_t
- * values that was previously returned by readdir() for the same
- * directory handle. In this case, readdir() should skip over entries
- * coming before the position defined by the off_t value. If entries
- * are added or removed while the directory handle is open, they filesystem
- * may still include the entries that have been removed, and may not
- * report the entries that have been created. However, addition or
- * removal of entries must never cause readdir() to skip over unrelated
- * entries or to report them more than once. This means
- * that off_t can not be a simple index that enumerates the entries
- * that have been returned but must contain sufficient information to
- * uniquely determine the next directory entry to return even when the
- * set of entries is changing.
- *
- * The function does not have to report the '.' and '..'
- * entries, but is allowed to do so. Note that, if readdir does
- * not return '.' or '..', they will not be implicitly returned,
- * and this behavior is observable by the caller.
- *
- * Valid replies:
- * fuse_reply_buf
- * fuse_reply_data
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param size maximum number of bytes to send
- * @param off offset to continue reading the directory stream
- * @param fi file information
- */
- void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
- struct fuse_file_info *fi);
-
- /**
- * Release an open directory
- *
- * For every opendir call there will be exactly one releasedir
- * call (unless the filesystem is force-unmounted).
- *
- * fi->fh will contain the value set by the opendir method, or
- * will be undefined if the opendir method didn't set any value.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- */
- void (*releasedir) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi);
-
- /**
- * Synchronize directory contents
- *
- * If the datasync parameter is non-zero, then only the directory
- * contents should be flushed, not the meta data.
- *
- * fi->fh will contain the value set by the opendir method, or
- * will be undefined if the opendir method didn't set any value.
- *
- * If this request is answered with an error code of ENOSYS,
- * this is treated as success and future calls to fsyncdir() will
- * succeed automatically without being send to the filesystem
- * process.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param datasync flag indicating if only data should be flushed
- * @param fi file information
- */
- void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync,
- struct fuse_file_info *fi);
-
- /**
- * Get file system statistics
- *
- * Valid replies:
- * fuse_reply_statfs
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number, zero means "undefined"
- */
- void (*statfs) (fuse_req_t req, fuse_ino_t ino);
-
- /**
- * Set an extended attribute
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
- * future setxattr() requests will fail with EOPNOTSUPP without being
- * send to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_err
- */
- void (*setxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
- const char *value, size_t size, int flags);
-
- /**
- * Get an extended attribute
- *
- * If size is zero, the size of the value should be sent with
- * fuse_reply_xattr.
- *
- * If the size is non-zero, and the value fits in the buffer, the
- * value should be sent with fuse_reply_buf.
- *
- * If the size is too small for the value, the ERANGE error should
- * be sent.
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
- * future getxattr() requests will fail with EOPNOTSUPP without being
- * send to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_buf
- * fuse_reply_data
- * fuse_reply_xattr
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param name of the extended attribute
- * @param size maximum size of the value to send
- */
- void (*getxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
- size_t size);
-
- /**
- * List extended attribute names
- *
- * If size is zero, the total size of the attribute list should be
- * sent with fuse_reply_xattr.
- *
- * If the size is non-zero, and the null character separated
- * attribute list fits in the buffer, the list should be sent with
- * fuse_reply_buf.
- *
- * If the size is too small for the list, the ERANGE error should
- * be sent.
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
- * future listxattr() requests will fail with EOPNOTSUPP without being
- * send to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_buf
- * fuse_reply_data
- * fuse_reply_xattr
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param size maximum size of the list to send
- */
- void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size);
-
- /**
- * Remove an extended attribute
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
- * future removexattr() requests will fail with EOPNOTSUPP without being
- * send to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param name of the extended attribute
- */
- void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const char *name);
-
- /**
- * Check file access permissions
- *
- * This will be called for the access() and chdir() system
- * calls. If the 'default_permissions' mount option is given,
- * this method is not called.
- *
- * This method is not called under Linux kernel versions 2.4.x
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent success, i.e. this and all future access()
- * requests will succeed without being send to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param mask requested access mode
- */
- void (*access) (fuse_req_t req, fuse_ino_t ino, int mask);
-
- /**
- * Create and open a file
- *
- * If the file does not exist, first create it with the specified
- * mode, and then open it.
- *
- * See the description of the open handler for more
- * information.
- *
- * If this method is not implemented or under Linux kernel
- * versions earlier than 2.6.15, the mknod() and open() methods
- * will be called instead.
- *
- * If this request is answered with an error code of ENOSYS, the handler
- * is treated as not implemented (i.e., for this and future requests the
- * mknod() and open() handlers will be called instead).
- *
- * Valid replies:
- * fuse_reply_create
- * fuse_reply_err
- *
- * @param req request handle
- * @param parent inode number of the parent directory
- * @param name to create
- * @param mode file type and mode with which to create the new file
- * @param fi file information
- */
- void (*create) (fuse_req_t req, fuse_ino_t parent, const char *name,
- mode_t mode, struct fuse_file_info *fi);
-
- /**
- * Test for a POSIX file lock
- *
- * Valid replies:
- * fuse_reply_lock
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- * @param lock the region/type to test
- */
- void (*getlk) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi, struct flock *lock);
-
- /**
- * Acquire, modify or release a POSIX file lock
- *
- * For POSIX threads (NPTL) there's a 1-1 relation between pid and
- * owner, but otherwise this is not always the case. For checking
- * lock ownership, 'fi->owner' must be used. The l_pid field in
- * 'struct flock' should only be used to fill in this field in
- * getlk().
- *
- * Note: if the locking methods are not implemented, the kernel
- * will still allow file locking to work locally. Hence these are
- * only interesting for network filesystems and similar.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- * @param lock the region/type to set
- * @param sleep locking operation may sleep
- */
- void (*setlk) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi,
- struct flock *lock, int sleep);
-
- /**
- * Map block index within file to block index within device
- *
- * Note: This makes sense only for block device backed filesystems
- * mounted with the 'blkdev' option
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure, i.e. all future bmap() requests will
- * fail with the same error code without being send to the filesystem
- * process.
- *
- * Valid replies:
- * fuse_reply_bmap
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param blocksize unit of block index
- * @param idx block index within file
- */
- void (*bmap) (fuse_req_t req, fuse_ino_t ino, size_t blocksize,
- uint64_t idx);
-
- /**
- * Ioctl
- *
- * Note: For unrestricted ioctls (not allowed for FUSE
- * servers), data in and out areas can be discovered by giving
- * iovs and setting FUSE_IOCTL_RETRY in *flags*. For
- * restricted ioctls, kernel prepares in/out data area
- * according to the information encoded in cmd.
- *
- * Valid replies:
- * fuse_reply_ioctl_retry
- * fuse_reply_ioctl
- * fuse_reply_ioctl_iov
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param cmd ioctl command
- * @param arg ioctl argument
- * @param fi file information
- * @param flags for FUSE_IOCTL_* flags
- * @param in_buf data fetched from the caller
- * @param in_bufsz number of fetched bytes
- * @param out_bufsz maximum size of output data
- *
- * Note : the unsigned long request submitted by the application
- * is truncated to 32 bits.
- */
- void (*ioctl) (fuse_req_t req, fuse_ino_t ino, unsigned int cmd,
- void *arg, struct fuse_file_info *fi, unsigned flags,
- const void *in_buf, size_t in_bufsz, size_t out_bufsz);
-
- /**
- * Poll for IO readiness
- *
- * Note: If ph is non-NULL, the client should notify
- * when IO readiness events occur by calling
- * fuse_lowlevel_notify_poll() with the specified ph.
- *
- * Regardless of the number of times poll with a non-NULL ph
- * is received, single notification is enough to clear all.
- * Notifying more times incurs overhead but doesn't harm
- * correctness.
- *
- * The callee is responsible for destroying ph with
- * fuse_pollhandle_destroy() when no longer in use.
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as success (with a kernel-defined default poll-mask) and
- * future calls to pull() will succeed the same way without being send
- * to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_poll
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- * @param ph poll handle to be used for notification
- */
- void (*poll) (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
- struct fuse_pollhandle *ph);
-
- /**
- * Write data made available in a buffer
- *
- * This is a more generic version of the ->write() method. If
- * FUSE_CAP_SPLICE_READ is set in fuse_conn_info.want and the
- * kernel supports splicing from the fuse device, then the
- * data will be made available in pipe for supporting zero
- * copy data transfer.
- *
- * buf->count is guaranteed to be one (and thus buf->idx is
- * always zero). The write_buf handler must ensure that
- * bufv->off is correctly updated (reflecting the number of
- * bytes read from bufv->buf[0]).
- *
- * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
- * expected to reset the setuid and setgid bits.
- *
- * Valid replies:
- * fuse_reply_write
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param bufv buffer containing the data
- * @param off offset to write to
- * @param fi file information
- */
- void (*write_buf) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_bufvec *bufv, off_t off,
- struct fuse_file_info *fi);
-
- /**
- * Callback function for the retrieve request
- *
- * Valid replies:
- * fuse_reply_none
- *
- * @param req request handle
- * @param cookie user data supplied to fuse_lowlevel_notify_retrieve()
- * @param ino the inode number supplied to fuse_lowlevel_notify_retrieve()
- * @param offset the offset supplied to fuse_lowlevel_notify_retrieve()
- * @param bufv the buffer containing the returned data
- */
- void (*retrieve_reply) (fuse_req_t req, void *cookie, fuse_ino_t ino,
- off_t offset, struct fuse_bufvec *bufv);
-
- /**
- * Forget about multiple inodes
- *
- * See description of the forget function for more
- * information.
- *
- * Valid replies:
- * fuse_reply_none
- *
- * @param req request handle
- */
- void (*forget_multi) (fuse_req_t req, size_t count,
- struct fuse_forget_data *forgets);
-
- /**
- * Acquire, modify or release a BSD file lock
- *
- * Note: if the locking methods are not implemented, the kernel
- * will still allow file locking to work locally. Hence these are
- * only interesting for network filesystems and similar.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param fi file information
- * @param op the locking operation, see flock(2)
- */
- void (*flock) (fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi, int op);
-
- /**
- * Allocate requested space. If this function returns success then
- * subsequent writes to the specified range shall not fail due to the lack
- * of free space on the file system storage media.
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
- * future fallocate() requests will fail with EOPNOTSUPP without being
- * send to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param offset starting point for allocated region
- * @param length size of allocated region
- * @param mode determines the operation to be performed on the given range,
- * see fallocate(2)
- */
- void (*fallocate) (fuse_req_t req, fuse_ino_t ino, int mode,
- off_t offset, off_t length, struct fuse_file_info *fi);
-
- /**
- * Read directory with attributes
- *
- * Send a buffer filled using fuse_add_direntry_plus(), with size not
- * exceeding the requested size. Send an empty buffer on end of
- * stream.
- *
- * fi->fh will contain the value set by the opendir method, or
- * will be undefined if the opendir method didn't set any value.
- *
- * In contrast to readdir() (which does not affect the lookup counts),
- * the lookup count of every entry returned by readdirplus(), except "."
- * and "..", is incremented by one.
- *
- * Valid replies:
- * fuse_reply_buf
- * fuse_reply_data
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param size maximum number of bytes to send
- * @param off offset to continue reading the directory stream
- * @param fi file information
- */
- void (*readdirplus) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
- struct fuse_file_info *fi);
-
- /**
- * Copy a range of data from one file to another
- *
- * Performs an optimized copy between two file descriptors without the
- * additional cost of transferring data through the FUSE kernel module
- * to user space (glibc) and then back into the FUSE filesystem again.
- *
- * In case this method is not implemented, glibc falls back to reading
- * data from the source and writing to the destination. Effectively
- * doing an inefficient copy of the data.
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
- * future copy_file_range() requests will fail with EOPNOTSUPP without
- * being send to the filesystem process.
- *
- * Valid replies:
- * fuse_reply_write
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino_in the inode number or the source file
- * @param off_in starting point from were the data should be read
- * @param fi_in file information of the source file
- * @param ino_out the inode number or the destination file
- * @param off_out starting point where the data should be written
- * @param fi_out file information of the destination file
- * @param len maximum size of the data to copy
- * @param flags passed along with the copy_file_range() syscall
- */
- void (*copy_file_range) (fuse_req_t req, fuse_ino_t ino_in,
- off_t off_in, struct fuse_file_info *fi_in,
- fuse_ino_t ino_out, off_t off_out,
- struct fuse_file_info *fi_out, size_t len,
- int flags);
-
- /**
- * Find next data or hole after the specified offset
- *
- * If this request is answered with an error code of ENOSYS, this is
- * treated as a permanent failure, i.e. all future lseek() requests will
- * fail with the same error code without being send to the filesystem
- * process.
- *
- * Valid replies:
- * fuse_reply_lseek
- * fuse_reply_err
- *
- * @param req request handle
- * @param ino the inode number
- * @param off offset to start search from
- * @param whence either SEEK_DATA or SEEK_HOLE
- * @param fi file information
- */
- void (*lseek) (fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
- struct fuse_file_info *fi);
+ /**
+ * Initialize filesystem
+ *
+ * This function is called when libfuse establishes
+ * communication with the FUSE kernel module. The file system
+ * should use this module to inspect and/or modify the
+ * connection parameters provided in the `conn` structure.
+ *
+ * Note that some parameters may be overwritten by options
+ * passed to fuse_session_new() which take precedence over the
+ * values set in this handler.
+ *
+ * There's no reply to this function
+ *
+ * @param userdata the user data passed to fuse_session_new()
+ */
+ void (*init)(void *userdata, struct fuse_conn_info *conn);
+
+ /**
+ * Clean up filesystem.
+ *
+ * Called on filesystem exit. When this method is called, the
+ * connection to the kernel may be gone already, so that eg. calls
+ * to fuse_lowlevel_notify_* will fail.
+ *
+ * There's no reply to this function
+ *
+ * @param userdata the user data passed to fuse_session_new()
+ */
+ void (*destroy)(void *userdata);
+
+ /**
+ * Look up a directory entry by name and get its attributes.
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name the name to look up
+ */
+ void (*lookup)(fuse_req_t req, fuse_ino_t parent, const char *name);
+
+ /**
+ * Forget about an inode
+ *
+ * This function is called when the kernel removes an inode
+ * from its internal caches.
+ *
+ * The inode's lookup count increases by one for every call to
+ * fuse_reply_entry and fuse_reply_create. The nlookup parameter
+ * indicates by how much the lookup count should be decreased.
+ *
+ * Inodes with a non-zero lookup count may receive request from
+ * the kernel even after calls to unlink, rmdir or (when
+ * overwriting an existing file) rename. Filesystems must handle
+ * such requests properly and it is recommended to defer removal
+ * of the inode until the lookup count reaches zero. Calls to
+ * unlink, rmdir or rename will be followed closely by forget
+ * unless the file or directory is open, in which case the
+ * kernel issues forget only after the release or releasedir
+ * calls.
+ *
+ * Note that if a file system will be exported over NFS the
+ * inodes lifetime must extend even beyond forget. See the
+ * generation field in struct fuse_entry_param above.
+ *
+ * On unmount the lookup count for all inodes implicitly drops
+ * to zero. It is not guaranteed that the file system will
+ * receive corresponding forget messages for the affected
+ * inodes.
+ *
+ * Valid replies:
+ * fuse_reply_none
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param nlookup the number of lookups to forget
+ */
+ void (*forget)(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup);
+
+ /**
+ * Get file attributes.
+ *
+ * If writeback caching is enabled, the kernel may have a
+ * better idea of a file's length than the FUSE file system
+ * (eg if there has been a write that extended the file size,
+ * but that has not yet been passed to the filesystem.n
+ *
+ * In this case, the st_size value provided by the file system
+ * will be ignored.
+ *
+ * Valid replies:
+ * fuse_reply_attr
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi for future use, currently always NULL
+ */
+ void (*getattr)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
+
+ /**
+ * Set file attributes
+ *
+ * In the 'attr' argument only members indicated by the 'to_set'
+ * bitmask contain valid values. Other members contain undefined
+ * values.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits if the file
+ * size or owner is being changed.
+ *
+ * If the setattr was invoked from the ftruncate() system call
+ * under Linux kernel versions 2.6.15 or later, the fi->fh will
+ * contain the value set by the open method or will be undefined
+ * if the open method didn't set any value. Otherwise (not
+ * ftruncate call, or kernel version earlier than 2.6.15) the fi
+ * parameter will be NULL.
+ *
+ * Valid replies:
+ * fuse_reply_attr
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param attr the attributes
+ * @param to_set bit mask of attributes which should be set
+ * @param fi file information, or NULL
+ */
+ void (*setattr)(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
+ int to_set, struct fuse_file_info *fi);
+
+ /**
+ * Read symbolic link
+ *
+ * Valid replies:
+ * fuse_reply_readlink
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ */
+ void (*readlink)(fuse_req_t req, fuse_ino_t ino);
+
+ /**
+ * Create file node
+ *
+ * Create a regular file, character device, block device, fifo or
+ * socket node.
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to create
+ * @param mode file type and mode with which to create the new file
+ * @param rdev the device number (only valid if created file is a device)
+ */
+ void (*mknod)(fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode, dev_t rdev);
+
+ /**
+ * Create a directory
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to create
+ * @param mode with which to create the new file
+ */
+ void (*mkdir)(fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode);
+
+ /**
+ * Remove a file
+ *
+ * If the file's inode's lookup count is non-zero, the file
+ * system is expected to postpone any removal of the inode
+ * until the lookup count reaches zero (see description of the
+ * forget function).
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to remove
+ */
+ void (*unlink)(fuse_req_t req, fuse_ino_t parent, const char *name);
+
+ /**
+ * Remove a directory
+ *
+ * If the directory's inode's lookup count is non-zero, the
+ * file system is expected to postpone any removal of the
+ * inode until the lookup count reaches zero (see description
+ * of the forget function).
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to remove
+ */
+ void (*rmdir)(fuse_req_t req, fuse_ino_t parent, const char *name);
+
+ /**
+ * Create a symbolic link
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param link the contents of the symbolic link
+ * @param parent inode number of the parent directory
+ * @param name to create
+ */
+ void (*symlink)(fuse_req_t req, const char *link, fuse_ino_t parent,
+ const char *name);
+
+ /**
+ * Rename a file
+ *
+ * If the target exists it should be atomically replaced. If
+ * the target's inode's lookup count is non-zero, the file
+ * system is expected to postpone any removal of the inode
+ * until the lookup count reaches zero (see description of the
+ * forget function).
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EINVAL, i.e. all
+ * future bmap requests will fail with EINVAL without being
+ * send to the filesystem process.
+ *
+ * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If
+ * RENAME_NOREPLACE is specified, the filesystem must not
+ * overwrite *newname* if it exists and return an error
+ * instead. If `RENAME_EXCHANGE` is specified, the filesystem
+ * must atomically exchange the two files, i.e. both must
+ * exist and neither may be deleted.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the old parent directory
+ * @param name old name
+ * @param newparent inode number of the new parent directory
+ * @param newname new name
+ */
+ void (*rename)(fuse_req_t req, fuse_ino_t parent, const char *name,
+ fuse_ino_t newparent, const char *newname,
+ unsigned int flags);
+
+ /**
+ * Create a hard link
+ *
+ * Valid replies:
+ * fuse_reply_entry
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the old inode number
+ * @param newparent inode number of the new parent directory
+ * @param newname new name to create
+ */
+ void (*link)(fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
+ const char *newname);
+
+ /**
+ * Open a file
+ *
+ * Open flags are available in fi->flags. The following rules
+ * apply.
+ *
+ * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be
+ * filtered out / handled by the kernel.
+ *
+ * - Access modes (O_RDONLY, O_WRONLY, O_RDWR) should be used
+ * by the filesystem to check if the operation is
+ * permitted. If the ``-o default_permissions`` mount
+ * option is given, this check is already done by the
+ * kernel before calling open() and may thus be omitted by
+ * the filesystem.
+ *
+ * - When writeback caching is enabled, the kernel may send
+ * read requests even for files opened with O_WRONLY. The
+ * filesystem should be prepared to handle this.
+ *
+ * - When writeback caching is disabled, the filesystem is
+ * expected to properly handle the O_APPEND flag and ensure
+ * that each write is appending to the end of the file.
+ *
+ * - When writeback caching is enabled, the kernel will
+ * handle O_APPEND. However, unless all changes to the file
+ * come through the kernel this will not work reliably. The
+ * filesystem should thus either ignore the O_APPEND flag
+ * (and let the kernel handle it), or return an error
+ * (indicating that reliably O_APPEND is not available).
+ *
+ * Filesystem may store an arbitrary file handle (pointer,
+ * index, etc) in fi->fh, and use this in other all other file
+ * operations (read, write, flush, release, fsync).
+ *
+ * Filesystem may also implement stateless file I/O and not store
+ * anything in fi->fh.
+ *
+ * There are also some flags (direct_io, keep_cache) which the
+ * filesystem may set in fi, to change the way the file is opened.
+ * See fuse_file_info structure in <fuse_common.h> for more details.
+ *
+ * If this request is answered with an error code of ENOSYS
+ * and FUSE_CAP_NO_OPEN_SUPPORT is set in
+ * `fuse_conn_info.capable`, this is treated as success and
+ * future calls to open and release will also succeed without being
+ * sent to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_open
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ */
+ void (*open)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
+
+ /**
+ * Read data
+ *
+ * Read should send exactly the number of bytes requested except
+ * on EOF or error, otherwise the rest of the data will be
+ * substituted with zeroes. An exception to this is when the file
+ * has been opened in 'direct_io' mode, in which case the return
+ * value of the read system call will reflect the return value of
+ * this operation.
+ *
+ * fi->fh will contain the value set by the open method, or will
+ * be undefined if the open method didn't set any value.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_iov
+ * fuse_reply_data
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param size number of bytes to read
+ * @param off offset to read from
+ * @param fi file information
+ */
+ void (*read)(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
+ struct fuse_file_info *fi);
+
+ /**
+ * Write data
+ *
+ * Write should return exactly the number of bytes requested
+ * except on error. An exception to this is when the file has
+ * been opened in 'direct_io' mode, in which case the return value
+ * of the write system call will reflect the return value of this
+ * operation.
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ *
+ * fi->fh will contain the value set by the open method, or will
+ * be undefined if the open method didn't set any value.
+ *
+ * Valid replies:
+ * fuse_reply_write
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param buf data to write
+ * @param size number of bytes to write
+ * @param off offset to write to
+ * @param fi file information
+ */
+ void (*write)(fuse_req_t req, fuse_ino_t ino, const char *buf, size_t size,
+ off_t off, struct fuse_file_info *fi);
+
+ /**
+ * Flush method
+ *
+ * This is called on each close() of the opened file.
+ *
+ * Since file descriptors can be duplicated (dup, dup2, fork), for
+ * one open call there may be many flush calls.
+ *
+ * Filesystems shouldn't assume that flush will always be called
+ * after some writes, or that if will be called at all.
+ *
+ * fi->fh will contain the value set by the open method, or will
+ * be undefined if the open method didn't set any value.
+ *
+ * NOTE: the name of the method is misleading, since (unlike
+ * fsync) the filesystem is not forced to flush pending writes.
+ * One reason to flush data is if the filesystem wants to return
+ * write errors during close. However, such use is non-portable
+ * because POSIX does not require [close] to wait for delayed I/O to
+ * complete.
+ *
+ * If the filesystem supports file locking operations (setlk,
+ * getlk) it should remove all locks belonging to 'fi->owner'.
+ *
+ * If this request is answered with an error code of ENOSYS,
+ * this is treated as success and future calls to flush() will
+ * succeed automatically without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ *
+ * [close]:
+ * http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
+ */
+ void (*flush)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
+
+ /**
+ * Release an open file
+ *
+ * Release is called when there are no more references to an open
+ * file: all file descriptors are closed and all memory mappings
+ * are unmapped.
+ *
+ * For every open call there will be exactly one release call (unless
+ * the filesystem is force-unmounted).
+ *
+ * The filesystem may reply with an error, but error values are
+ * not returned to close() or munmap() which triggered the
+ * release.
+ *
+ * fi->fh will contain the value set by the open method, or will
+ * be undefined if the open method didn't set any value.
+ * fi->flags will contain the same flags as for open.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ */
+ void (*release)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
+
+ /**
+ * Synchronize file contents
+ *
+ * If the datasync parameter is non-zero, then only the user data
+ * should be flushed, not the meta data.
+ *
+ * If this request is answered with an error code of ENOSYS,
+ * this is treated as success and future calls to fsync() will
+ * succeed automatically without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param datasync flag indicating if only data should be flushed
+ * @param fi file information
+ */
+ void (*fsync)(fuse_req_t req, fuse_ino_t ino, int datasync,
+ struct fuse_file_info *fi);
+
+ /**
+ * Open a directory
+ *
+ * Filesystem may store an arbitrary file handle (pointer, index,
+ * etc) in fi->fh, and use this in other all other directory
+ * stream operations (readdir, releasedir, fsyncdir).
+ *
+ * If this request is answered with an error code of ENOSYS and
+ * FUSE_CAP_NO_OPENDIR_SUPPORT is set in `fuse_conn_info.capable`,
+ * this is treated as success and future calls to opendir and
+ * releasedir will also succeed without being sent to the filesystem
+ * process. In addition, the kernel will cache readdir results
+ * as if opendir returned FOPEN_KEEP_CACHE | FOPEN_CACHE_DIR.
+ *
+ * Valid replies:
+ * fuse_reply_open
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ */
+ void (*opendir)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi);
+
+ /**
+ * Read directory
+ *
+ * Send a buffer filled using fuse_add_direntry(), with size not
+ * exceeding the requested size. Send an empty buffer on end of
+ * stream.
+ *
+ * fi->fh will contain the value set by the opendir method, or
+ * will be undefined if the opendir method didn't set any value.
+ *
+ * Returning a directory entry from readdir() does not affect
+ * its lookup count.
+ *
+ * If off_t is non-zero, then it will correspond to one of the off_t
+ * values that was previously returned by readdir() for the same
+ * directory handle. In this case, readdir() should skip over entries
+ * coming before the position defined by the off_t value. If entries
+ * are added or removed while the directory handle is open, they filesystem
+ * may still include the entries that have been removed, and may not
+ * report the entries that have been created. However, addition or
+ * removal of entries must never cause readdir() to skip over unrelated
+ * entries or to report them more than once. This means
+ * that off_t can not be a simple index that enumerates the entries
+ * that have been returned but must contain sufficient information to
+ * uniquely determine the next directory entry to return even when the
+ * set of entries is changing.
+ *
+ * The function does not have to report the '.' and '..'
+ * entries, but is allowed to do so. Note that, if readdir does
+ * not return '.' or '..', they will not be implicitly returned,
+ * and this behavior is observable by the caller.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_data
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param size maximum number of bytes to send
+ * @param off offset to continue reading the directory stream
+ * @param fi file information
+ */
+ void (*readdir)(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
+ struct fuse_file_info *fi);
+
+ /**
+ * Release an open directory
+ *
+ * For every opendir call there will be exactly one releasedir
+ * call (unless the filesystem is force-unmounted).
+ *
+ * fi->fh will contain the value set by the opendir method, or
+ * will be undefined if the opendir method didn't set any value.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ */
+ void (*releasedir)(fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi);
+
+ /**
+ * Synchronize directory contents
+ *
+ * If the datasync parameter is non-zero, then only the directory
+ * contents should be flushed, not the meta data.
+ *
+ * fi->fh will contain the value set by the opendir method, or
+ * will be undefined if the opendir method didn't set any value.
+ *
+ * If this request is answered with an error code of ENOSYS,
+ * this is treated as success and future calls to fsyncdir() will
+ * succeed automatically without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param datasync flag indicating if only data should be flushed
+ * @param fi file information
+ */
+ void (*fsyncdir)(fuse_req_t req, fuse_ino_t ino, int datasync,
+ struct fuse_file_info *fi);
+
+ /**
+ * Get file system statistics
+ *
+ * Valid replies:
+ * fuse_reply_statfs
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number, zero means "undefined"
+ */
+ void (*statfs)(fuse_req_t req, fuse_ino_t ino);
+
+ /**
+ * Set an extended attribute
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future setxattr() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ */
+ void (*setxattr)(fuse_req_t req, fuse_ino_t ino, const char *name,
+ const char *value, size_t size, int flags);
+
+ /**
+ * Get an extended attribute
+ *
+ * If size is zero, the size of the value should be sent with
+ * fuse_reply_xattr.
+ *
+ * If the size is non-zero, and the value fits in the buffer, the
+ * value should be sent with fuse_reply_buf.
+ *
+ * If the size is too small for the value, the ERANGE error should
+ * be sent.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future getxattr() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_data
+ * fuse_reply_xattr
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param name of the extended attribute
+ * @param size maximum size of the value to send
+ */
+ void (*getxattr)(fuse_req_t req, fuse_ino_t ino, const char *name,
+ size_t size);
+
+ /**
+ * List extended attribute names
+ *
+ * If size is zero, the total size of the attribute list should be
+ * sent with fuse_reply_xattr.
+ *
+ * If the size is non-zero, and the null character separated
+ * attribute list fits in the buffer, the list should be sent with
+ * fuse_reply_buf.
+ *
+ * If the size is too small for the list, the ERANGE error should
+ * be sent.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future listxattr() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_data
+ * fuse_reply_xattr
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param size maximum size of the list to send
+ */
+ void (*listxattr)(fuse_req_t req, fuse_ino_t ino, size_t size);
+
+ /**
+ * Remove an extended attribute
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future removexattr() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param name of the extended attribute
+ */
+ void (*removexattr)(fuse_req_t req, fuse_ino_t ino, const char *name);
+
+ /**
+ * Check file access permissions
+ *
+ * This will be called for the access() and chdir() system
+ * calls. If the 'default_permissions' mount option is given,
+ * this method is not called.
+ *
+ * This method is not called under Linux kernel versions 2.4.x
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent success, i.e. this and all future access()
+ * requests will succeed without being send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param mask requested access mode
+ */
+ void (*access)(fuse_req_t req, fuse_ino_t ino, int mask);
+
+ /**
+ * Create and open a file
+ *
+ * If the file does not exist, first create it with the specified
+ * mode, and then open it.
+ *
+ * See the description of the open handler for more
+ * information.
+ *
+ * If this method is not implemented or under Linux kernel
+ * versions earlier than 2.6.15, the mknod() and open() methods
+ * will be called instead.
+ *
+ * If this request is answered with an error code of ENOSYS, the handler
+ * is treated as not implemented (i.e., for this and future requests the
+ * mknod() and open() handlers will be called instead).
+ *
+ * Valid replies:
+ * fuse_reply_create
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param parent inode number of the parent directory
+ * @param name to create
+ * @param mode file type and mode with which to create the new file
+ * @param fi file information
+ */
+ void (*create)(fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode, struct fuse_file_info *fi);
+
+ /**
+ * Test for a POSIX file lock
+ *
+ * Valid replies:
+ * fuse_reply_lock
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ * @param lock the region/type to test
+ */
+ void (*getlk)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
+ struct flock *lock);
+
+ /**
+ * Acquire, modify or release a POSIX file lock
+ *
+ * For POSIX threads (NPTL) there's a 1-1 relation between pid and
+ * owner, but otherwise this is not always the case. For checking
+ * lock ownership, 'fi->owner' must be used. The l_pid field in
+ * 'struct flock' should only be used to fill in this field in
+ * getlk().
+ *
+ * Note: if the locking methods are not implemented, the kernel
+ * will still allow file locking to work locally. Hence these are
+ * only interesting for network filesystems and similar.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ * @param lock the region/type to set
+ * @param sleep locking operation may sleep
+ */
+ void (*setlk)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
+ struct flock *lock, int sleep);
+
+ /**
+ * Map block index within file to block index within device
+ *
+ * Note: This makes sense only for block device backed filesystems
+ * mounted with the 'blkdev' option
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure, i.e. all future bmap() requests will
+ * fail with the same error code without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_bmap
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param blocksize unit of block index
+ * @param idx block index within file
+ */
+ void (*bmap)(fuse_req_t req, fuse_ino_t ino, size_t blocksize,
+ uint64_t idx);
+
+ /**
+ * Ioctl
+ *
+ * Note: For unrestricted ioctls (not allowed for FUSE
+ * servers), data in and out areas can be discovered by giving
+ * iovs and setting FUSE_IOCTL_RETRY in *flags*. For
+ * restricted ioctls, kernel prepares in/out data area
+ * according to the information encoded in cmd.
+ *
+ * Valid replies:
+ * fuse_reply_ioctl_retry
+ * fuse_reply_ioctl
+ * fuse_reply_ioctl_iov
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param cmd ioctl command
+ * @param arg ioctl argument
+ * @param fi file information
+ * @param flags for FUSE_IOCTL_* flags
+ * @param in_buf data fetched from the caller
+ * @param in_bufsz number of fetched bytes
+ * @param out_bufsz maximum size of output data
+ *
+ * Note : the unsigned long request submitted by the application
+ * is truncated to 32 bits.
+ */
+ void (*ioctl)(fuse_req_t req, fuse_ino_t ino, unsigned int cmd, void *arg,
+ struct fuse_file_info *fi, unsigned flags, const void *in_buf,
+ size_t in_bufsz, size_t out_bufsz);
+
+ /**
+ * Poll for IO readiness
+ *
+ * Note: If ph is non-NULL, the client should notify
+ * when IO readiness events occur by calling
+ * fuse_lowlevel_notify_poll() with the specified ph.
+ *
+ * Regardless of the number of times poll with a non-NULL ph
+ * is received, single notification is enough to clear all.
+ * Notifying more times incurs overhead but doesn't harm
+ * correctness.
+ *
+ * The callee is responsible for destroying ph with
+ * fuse_pollhandle_destroy() when no longer in use.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as success (with a kernel-defined default poll-mask) and
+ * future calls to pull() will succeed the same way without being send
+ * to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_poll
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ * @param ph poll handle to be used for notification
+ */
+ void (*poll)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
+ struct fuse_pollhandle *ph);
+
+ /**
+ * Write data made available in a buffer
+ *
+ * This is a more generic version of the ->write() method. If
+ * FUSE_CAP_SPLICE_READ is set in fuse_conn_info.want and the
+ * kernel supports splicing from the fuse device, then the
+ * data will be made available in pipe for supporting zero
+ * copy data transfer.
+ *
+ * buf->count is guaranteed to be one (and thus buf->idx is
+ * always zero). The write_buf handler must ensure that
+ * bufv->off is correctly updated (reflecting the number of
+ * bytes read from bufv->buf[0]).
+ *
+ * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+ * expected to reset the setuid and setgid bits.
+ *
+ * Valid replies:
+ * fuse_reply_write
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param bufv buffer containing the data
+ * @param off offset to write to
+ * @param fi file information
+ */
+ void (*write_buf)(fuse_req_t req, fuse_ino_t ino, struct fuse_bufvec *bufv,
+ off_t off, struct fuse_file_info *fi);
+
+ /**
+ * Callback function for the retrieve request
+ *
+ * Valid replies:
+ * fuse_reply_none
+ *
+ * @param req request handle
+ * @param cookie user data supplied to fuse_lowlevel_notify_retrieve()
+ * @param ino the inode number supplied to fuse_lowlevel_notify_retrieve()
+ * @param offset the offset supplied to fuse_lowlevel_notify_retrieve()
+ * @param bufv the buffer containing the returned data
+ */
+ void (*retrieve_reply)(fuse_req_t req, void *cookie, fuse_ino_t ino,
+ off_t offset, struct fuse_bufvec *bufv);
+
+ /**
+ * Forget about multiple inodes
+ *
+ * See description of the forget function for more
+ * information.
+ *
+ * Valid replies:
+ * fuse_reply_none
+ *
+ * @param req request handle
+ */
+ void (*forget_multi)(fuse_req_t req, size_t count,
+ struct fuse_forget_data *forgets);
+
+ /**
+ * Acquire, modify or release a BSD file lock
+ *
+ * Note: if the locking methods are not implemented, the kernel
+ * will still allow file locking to work locally. Hence these are
+ * only interesting for network filesystems and similar.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param fi file information
+ * @param op the locking operation, see flock(2)
+ */
+ void (*flock)(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
+ int op);
+
+ /**
+ * Allocate requested space. If this function returns success then
+ * subsequent writes to the specified range shall not fail due to the lack
+ * of free space on the file system storage media.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future fallocate() requests will fail with EOPNOTSUPP without being
+ * send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param offset starting point for allocated region
+ * @param length size of allocated region
+ * @param mode determines the operation to be performed on the given range,
+ * see fallocate(2)
+ */
+ void (*fallocate)(fuse_req_t req, fuse_ino_t ino, int mode, off_t offset,
+ off_t length, struct fuse_file_info *fi);
+
+ /**
+ * Read directory with attributes
+ *
+ * Send a buffer filled using fuse_add_direntry_plus(), with size not
+ * exceeding the requested size. Send an empty buffer on end of
+ * stream.
+ *
+ * fi->fh will contain the value set by the opendir method, or
+ * will be undefined if the opendir method didn't set any value.
+ *
+ * In contrast to readdir() (which does not affect the lookup counts),
+ * the lookup count of every entry returned by readdirplus(), except "."
+ * and "..", is incremented by one.
+ *
+ * Valid replies:
+ * fuse_reply_buf
+ * fuse_reply_data
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param size maximum number of bytes to send
+ * @param off offset to continue reading the directory stream
+ * @param fi file information
+ */
+ void (*readdirplus)(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
+ struct fuse_file_info *fi);
+
+ /**
+ * Copy a range of data from one file to another
+ *
+ * Performs an optimized copy between two file descriptors without the
+ * additional cost of transferring data through the FUSE kernel module
+ * to user space (glibc) and then back into the FUSE filesystem again.
+ *
+ * In case this method is not implemented, glibc falls back to reading
+ * data from the source and writing to the destination. Effectively
+ * doing an inefficient copy of the data.
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure with error code EOPNOTSUPP, i.e. all
+ * future copy_file_range() requests will fail with EOPNOTSUPP without
+ * being send to the filesystem process.
+ *
+ * Valid replies:
+ * fuse_reply_write
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino_in the inode number or the source file
+ * @param off_in starting point from were the data should be read
+ * @param fi_in file information of the source file
+ * @param ino_out the inode number or the destination file
+ * @param off_out starting point where the data should be written
+ * @param fi_out file information of the destination file
+ * @param len maximum size of the data to copy
+ * @param flags passed along with the copy_file_range() syscall
+ */
+ void (*copy_file_range)(fuse_req_t req, fuse_ino_t ino_in, off_t off_in,
+ struct fuse_file_info *fi_in, fuse_ino_t ino_out,
+ off_t off_out, struct fuse_file_info *fi_out,
+ size_t len, int flags);
+
+ /**
+ * Find next data or hole after the specified offset
+ *
+ * If this request is answered with an error code of ENOSYS, this is
+ * treated as a permanent failure, i.e. all future lseek() requests will
+ * fail with the same error code without being send to the filesystem
+ * process.
+ *
+ * Valid replies:
+ * fuse_reply_lseek
+ * fuse_reply_err
+ *
+ * @param req request handle
+ * @param ino the inode number
+ * @param off offset to start search from
+ * @param whence either SEEK_DATA or SEEK_HOLE
+ * @param fi file information
+ */
+ void (*lseek)(fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
+ struct fuse_file_info *fi);
};
/**
@@ -1305,7 +1307,7 @@ int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e);
* @return zero for success, -errno for failure to send reply
*/
int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
- const struct fuse_file_info *fi);
+ const struct fuse_file_info *fi);
/**
* Reply with attributes
@@ -1315,11 +1317,11 @@ int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
*
* @param req request handle
* @param attr the attributes
- * @param attr_timeout validity timeout (in seconds) for the attributes
+ * @param attr_timeout validity timeout (in seconds) for the attributes
* @return zero for success, -errno for failure to send reply
*/
int fuse_reply_attr(fuse_req_t req, const struct stat *attr,
- double attr_timeout);
+ double attr_timeout);
/**
* Reply with the contents of a symbolic link
@@ -1417,7 +1419,7 @@ int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
* @return zero for success, -errno for failure to send reply
*/
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
- enum fuse_buf_copy_flags flags);
+ enum fuse_buf_copy_flags flags);
/**
* Reply with data vector
@@ -1480,9 +1482,9 @@ int fuse_reply_lock(fuse_req_t req, const struct flock *lock);
*/
int fuse_reply_bmap(fuse_req_t req, uint64_t idx);
-/* ----------------------------------------------------------- *
- * Filling a buffer in readdir *
- * ----------------------------------------------------------- */
+/*
+ * Filling a buffer in readdir
+ */
/**
* Add a directory entry to the buffer
@@ -1512,8 +1514,7 @@ int fuse_reply_bmap(fuse_req_t req, uint64_t idx);
* @return the space needed for the entry
*/
size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,
- const char *name, const struct stat *stbuf,
- off_t off);
+ const char *name, const struct stat *stbuf, off_t off);
/**
* Add a directory entry to the buffer with the attributes
@@ -1529,8 +1530,8 @@ size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,
* @return the space needed for the entry
*/
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);
+ const char *name,
+ const struct fuse_entry_param *e, off_t off);
/**
* Reply to ask for data fetch and output buffer preparation. ioctl
@@ -1547,9 +1548,9 @@ size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize,
* @param out_count number of entries in out_iov
* @return zero for success, -errno for failure to send reply
*/
-int fuse_reply_ioctl_retry(fuse_req_t req,
- const struct iovec *in_iov, size_t in_count,
- const struct iovec *out_iov, size_t out_count);
+int fuse_reply_ioctl_retry(fuse_req_t req, const struct iovec *in_iov,
+ size_t in_count, const struct iovec *out_iov,
+ size_t out_count);
/**
* Reply to finish ioctl
@@ -1576,7 +1577,7 @@ int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size);
* @param count the size of vector
*/
int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
- int count);
+ int count);
/**
* Reply with poll result event mask
@@ -1598,9 +1599,9 @@ int fuse_reply_poll(fuse_req_t req, unsigned revents);
*/
int fuse_reply_lseek(fuse_req_t req, off_t off);
-/* ----------------------------------------------------------- *
- * Notification *
- * ----------------------------------------------------------- */
+/*
+ * Notification
+ */
/**
* Notify IO readiness event
@@ -1635,7 +1636,7 @@ int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph);
* @return zero for success, -errno for failure
*/
int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
- off_t off, off_t len);
+ off_t off, off_t len);
/**
* Notify to invalidate parent attributes and the dentry matching
@@ -1663,7 +1664,7 @@ int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
* @return zero for success, -errno for failure
*/
int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
- const char *name, size_t namelen);
+ const char *name, size_t namelen);
/**
* This function behaves like fuse_lowlevel_notify_inval_entry() with
@@ -1693,9 +1694,9 @@ int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
* @param namelen strlen() of file name
* @return zero for success, -errno for failure
*/
-int fuse_lowlevel_notify_delete(struct fuse_session *se,
- fuse_ino_t parent, fuse_ino_t child,
- const char *name, size_t namelen);
+int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
+ fuse_ino_t child, const char *name,
+ size_t namelen);
/**
* Store data to the kernel buffers
@@ -1723,8 +1724,8 @@ int fuse_lowlevel_notify_delete(struct fuse_session *se,
* @return zero for success, -errno for failure
*/
int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
- off_t offset, struct fuse_bufvec *bufv,
- enum fuse_buf_copy_flags flags);
+ off_t offset, struct fuse_bufvec *bufv,
+ enum fuse_buf_copy_flags flags);
/**
* Retrieve data from the kernel buffers
*
@@ -1755,12 +1756,12 @@ int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
* @return zero for success, -errno for failure
*/
int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
- size_t size, off_t offset, void *cookie);
+ size_t size, off_t offset, void *cookie);
-/* ----------------------------------------------------------- *
- * Utility functions *
- * ----------------------------------------------------------- */
+/*
+ * Utility functions
+ */
/**
* Get the userdata from the request
@@ -1822,7 +1823,7 @@ typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data);
* @param data user data passed to the callback function
*/
void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
- void *data);
+ void *data);
/**
* Check if a request has already been interrupted
@@ -1833,9 +1834,9 @@ void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
int fuse_req_interrupted(fuse_req_t req);
-/* ----------------------------------------------------------- *
- * Inquiry functions *
- * ----------------------------------------------------------- */
+/*
+ * Inquiry functions
+ */
/**
* Print low-level version information to stdout.
@@ -1854,18 +1855,18 @@ void fuse_lowlevel_help(void);
*/
void fuse_cmdline_help(void);
-/* ----------------------------------------------------------- *
- * Filesystem setup & teardown *
- * ----------------------------------------------------------- */
+/*
+ * Filesystem setup & teardown
+ */
struct fuse_cmdline_opts {
- int foreground;
- int debug;
- int nodefault_subtype;
- char *mountpoint;
- int show_version;
- int show_help;
- unsigned int max_idle_threads;
+ int foreground;
+ int debug;
+ int nodefault_subtype;
+ char *mountpoint;
+ int show_version;
+ int show_help;
+ unsigned int max_idle_threads;
};
/**
@@ -1886,8 +1887,7 @@ struct fuse_cmdline_opts {
* @param opts output argument for parsed options
* @return 0 on success, -1 on failure
*/
-int fuse_parse_cmdline(struct fuse_args *args,
- struct fuse_cmdline_opts *opts);
+int fuse_parse_cmdline(struct fuse_args *args, struct fuse_cmdline_opts *opts);
/**
* Create a low level session.
@@ -1918,8 +1918,8 @@ int fuse_parse_cmdline(struct fuse_args *args,
* @return the fuse session on success, NULL on failure
**/
struct fuse_session *fuse_session_new(struct fuse_args *args,
- const struct fuse_lowlevel_ops *op,
- size_t op_size, void *userdata);
+ const struct fuse_lowlevel_ops *op,
+ size_t op_size, void *userdata);
/**
* Mount a FUSE file system.
@@ -2014,9 +2014,9 @@ void fuse_session_unmount(struct fuse_session *se);
*/
void fuse_session_destroy(struct fuse_session *se);
-/* ----------------------------------------------------------- *
- * Custom event loop support *
- * ----------------------------------------------------------- */
+/*
+ * Custom event loop support
+ */
/**
* Return file descriptor for communication with kernel.
@@ -2043,7 +2043,7 @@ int fuse_session_fd(struct fuse_session *se);
* @param buf the fuse_buf containing the request
*/
void fuse_session_process_buf(struct fuse_session *se,
- const struct fuse_buf *buf);
+ const struct fuse_buf *buf);
/**
* Read a raw request from the kernel into the supplied buffer.
diff --git a/tools/virtiofsd/fuse_misc.h b/tools/virtiofsd/fuse_misc.h
index 2f6663ed7d..f252baa752 100644
--- a/tools/virtiofsd/fuse_misc.h
+++ b/tools/virtiofsd/fuse_misc.h
@@ -1,18 +1,18 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB
-*/
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB
+ */
#include <pthread.h>
/*
- Versioned symbols cannot be used in some cases because it
- - confuse the dynamic linker in uClibc
- - not supported on MacOSX (in MachO binary format)
-*/
+ * Versioned symbols cannot be used in some cases because it
+ * - confuse the dynamic linker in uClibc
+ * - not supported on MacOSX (in MachO binary format)
+ */
#if (!defined(__UCLIBC__) && !defined(__APPLE__))
#define FUSE_SYMVER(x) __asm__(x)
#else
@@ -25,11 +25,11 @@
/* Is this hack still needed? */
static inline void fuse_mutex_init(pthread_mutex_t *mut)
{
- pthread_mutexattr_t attr;
- pthread_mutexattr_init(&attr);
- pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
- pthread_mutex_init(mut, &attr);
- pthread_mutexattr_destroy(&attr);
+ pthread_mutexattr_t attr;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
+ pthread_mutex_init(mut, &attr);
+ pthread_mutexattr_destroy(&attr);
}
#endif
diff --git a/tools/virtiofsd/fuse_opt.c b/tools/virtiofsd/fuse_opt.c
index 93066b926e..edd36f4a3b 100644
--- a/tools/virtiofsd/fuse_opt.c
+++ b/tools/virtiofsd/fuse_opt.c
@@ -1,423 +1,450 @@
/*
- 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
-*/
+ * 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 "fuse_opt.h"
#include "config.h"
#include "fuse_i.h"
-#include "fuse_opt.h"
#include "fuse_misc.h"
+#include <assert.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 *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;
- }
+ 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;
+ 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;
+ 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)
+ 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;
+ 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);
+ 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;
+ 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);
+ 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;
+ 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);
+ 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);
+ 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);
+ return add_opt_common(&ctx->opts, opt, 1);
}
static int call_proc(struct fuse_opt_context *ctx, const char *arg, int key,
- int iso)
+ 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);
+ 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;
+ 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)
+ const char *arg, unsigned *sepp)
{
- for (; opt && opt->templ; opt++)
- if (match_template(opt->templ, arg, sepp))
- return opt;
- return NULL;
+ 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;
+ 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)
+ 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;
+ 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)
+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;
+ 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)
+ 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;
+ 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);
+ 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' &&
- s[2] >= '0' && s[2] <= '7') {
- *d++ = (s[0] - '0') * 0100 +
- (s[1] - '0') * 0010 +
- (s[2] - '0');
- s += 2;
- } else {
- *d++ = *s;
- }
- } else {
- *d++ = *s;
- }
- }
- s++;
- }
-
- return 0;
+ 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' &&
+ s[2] >= '0' && s[2] <= '7') {
+ *d++ = (s[0] - '0') * 0100 + (s[1] - '0') * 0010 +
+ (s[2] - '0');
+ s += 2;
+ } else {
+ *d++ = *s;
+ }
+ } else {
+ *d++ = *s;
+ }
+ }
+ s++;
+ }
+
+ return 0;
}
static int process_option_group(struct fuse_opt_context *ctx, const char *opts)
{
- int res;
- char *copy = strdup(opts);
-
- if (!copy) {
- fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");
- return -1;
- }
- res = process_real_option_group(ctx, copy);
- free(copy);
- return res;
+ int res;
+ char *copy = strdup(opts);
+
+ if (!copy) {
+ fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");
+ return -1;
+ }
+ res = process_real_option_group(ctx, copy);
+ free(copy);
+ return res;
}
static int process_one(struct fuse_opt_context *ctx, const char *arg)
{
- if (ctx->nonopt || arg[0] != '-')
- return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
- else if (arg[1] == 'o') {
- if (arg[2])
- return process_option_group(ctx, arg + 2);
- else {
- if (next_arg(ctx, arg) == -1)
- return -1;
-
- return process_option_group(ctx,
- ctx->argv[ctx->argctr]);
- }
- } else if (arg[1] == '-' && !arg[2]) {
- if (add_arg(ctx, arg) == -1)
- return -1;
- ctx->nonopt = ctx->outargs.argc;
- return 0;
- } else
- return process_gopt(ctx, arg, 0);
+ if (ctx->nonopt || arg[0] != '-') {
+ return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
+ } else if (arg[1] == 'o') {
+ if (arg[2]) {
+ return process_option_group(ctx, arg + 2);
+ } else {
+ if (next_arg(ctx, arg) == -1) {
+ return -1;
+ }
+
+ return process_option_group(ctx, ctx->argv[ctx->argctr]);
+ }
+ } else if (arg[1] == '-' && !arg[2]) {
+ if (add_arg(ctx, arg) == -1) {
+ return -1;
+ }
+ ctx->nonopt = ctx->outargs.argc;
+ return 0;
+ } else {
+ return process_gopt(ctx, arg, 0);
+ }
}
static int opt_parse(struct fuse_opt_context *ctx)
{
- if (ctx->argc) {
- if (add_arg(ctx, ctx->argv[0]) == -1)
- return -1;
- }
-
- for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)
- if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
- return -1;
-
- if (ctx->opts) {
- if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
- fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)
- return -1;
- }
-
- /* If option separator ("--") is the last argument, remove it */
- if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&
- strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {
- free(ctx->outargs.argv[ctx->outargs.argc - 1]);
- ctx->outargs.argv[--ctx->outargs.argc] = NULL;
- }
-
- return 0;
+ if (ctx->argc) {
+ if (add_arg(ctx, ctx->argv[0]) == -1) {
+ return -1;
+ }
+ }
+
+ for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++) {
+ if (process_one(ctx, ctx->argv[ctx->argctr]) == -1) {
+ return -1;
+ }
+ }
+
+ if (ctx->opts) {
+ if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
+ fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1) {
+ return -1;
+ }
+ }
+
+ /* If option separator ("--") is the last argument, remove it */
+ if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&
+ strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {
+ free(ctx->outargs.argv[ctx->outargs.argc - 1]);
+ ctx->outargs.argv[--ctx->outargs.argc] = NULL;
+ }
+
+ return 0;
}
int fuse_opt_parse(struct fuse_args *args, void *data,
- const struct fuse_opt opts[], fuse_opt_proc_t proc)
+ const struct fuse_opt opts[], fuse_opt_proc_t proc)
{
- int res;
- struct fuse_opt_context ctx = {
- .data = data,
- .opt = opts,
- .proc = proc,
- };
-
- if (!args || !args->argv || !args->argc)
- return 0;
-
- ctx.argc = args->argc;
- ctx.argv = args->argv;
-
- res = opt_parse(&ctx);
- if (res != -1) {
- struct fuse_args tmp = *args;
- *args = ctx.outargs;
- ctx.outargs = tmp;
- }
- free(ctx.opts);
- fuse_opt_free_args(&ctx.outargs);
- return res;
+ int res;
+ struct fuse_opt_context ctx = {
+ .data = data,
+ .opt = opts,
+ .proc = proc,
+ };
+
+ if (!args || !args->argv || !args->argc) {
+ return 0;
+ }
+
+ ctx.argc = args->argc;
+ ctx.argv = args->argv;
+
+ res = opt_parse(&ctx);
+ if (res != -1) {
+ struct fuse_args tmp = *args;
+ *args = ctx.outargs;
+ ctx.outargs = tmp;
+ }
+ free(ctx.opts);
+ fuse_opt_free_args(&ctx.outargs);
+ return res;
}
diff --git a/tools/virtiofsd/fuse_opt.h b/tools/virtiofsd/fuse_opt.h
index 69102555be..8f59b4d301 100644
--- a/tools/virtiofsd/fuse_opt.h
+++ b/tools/virtiofsd/fuse_opt.h
@@ -1,10 +1,10 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB.
-*/
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB.
+ */
#ifndef FUSE_OPT_H_
#define FUSE_OPT_H_
@@ -37,7 +37,7 @@
*
* - 'offsetof(struct foo, member)' actions i) and iii)
*
- * - -1 action ii)
+ * - -1 action ii)
*
* The 'offsetof()' macro is defined in the <stddef.h> header.
*
@@ -48,7 +48,7 @@
*
* The types of templates are:
*
- * 1) "-x", "-foo", "--foo", "--foo-bar", etc. These match only
+ * 1) "-x", "-foo", "--foo", "--foo-bar", etc. These match only
* themselves. Invalid values are "--" and anything beginning
* with "-o"
*
@@ -71,58 +71,67 @@
* freed.
*/
struct fuse_opt {
- /** Matching template and optional parameter formatting */
- const char *templ;
+ /** Matching template and optional parameter formatting */
+ const char *templ;
- /**
- * Offset of variable within 'data' parameter of fuse_opt_parse()
- * or -1
- */
- unsigned long offset;
+ /**
+ * Offset of variable within 'data' parameter of fuse_opt_parse()
+ * or -1
+ */
+ unsigned long offset;
- /**
- * Value to set the variable to, or to be passed as 'key' to the
- * processing function. Ignored if template has a format
- */
- int value;
+ /**
+ * Value to set the variable to, or to be passed as 'key' to the
+ * processing function. Ignored if template has a format
+ */
+ int value;
};
/**
- * Key option. In case of a match, the processing function will be
+ * Key option. In case of a match, the processing function will be
* called with the specified key.
*/
-#define FUSE_OPT_KEY(templ, key) { templ, -1U, key }
+#define FUSE_OPT_KEY(templ, key) \
+ { \
+ templ, -1U, key \
+ }
/**
- * Last option. An array of 'struct fuse_opt' must end with a NULL
+ * Last option. An array of 'struct fuse_opt' must end with a NULL
* template value
*/
-#define FUSE_OPT_END { NULL, 0, 0 }
+#define FUSE_OPT_END \
+ { \
+ NULL, 0, 0 \
+ }
/**
* Argument list
*/
struct fuse_args {
- /** Argument count */
- int argc;
+ /** Argument count */
+ int argc;
- /** Argument vector. NULL terminated */
- char **argv;
+ /** Argument vector. NULL terminated */
+ char **argv;
- /** Is 'argv' allocated? */
- int allocated;
+ /** Is 'argv' allocated? */
+ int allocated;
};
/**
* Initializer for 'struct fuse_args'
*/
-#define FUSE_ARGS_INIT(argc, argv) { argc, argv, 0 }
+#define FUSE_ARGS_INIT(argc, argv) \
+ { \
+ argc, argv, 0 \
+ }
/**
* Key value passed to the processing function if an option did not
* match any template
*/
-#define FUSE_OPT_KEY_OPT -1
+#define FUSE_OPT_KEY_OPT -1
/**
* Key value passed to the processing function for all non-options
@@ -130,7 +139,7 @@ struct fuse_args {
* Non-options are the arguments beginning with a character other than
* '-' or all arguments after the special '--' option
*/
-#define FUSE_OPT_KEY_NONOPT -2
+#define FUSE_OPT_KEY_NONOPT -2
/**
* Special key value for options to keep
@@ -174,7 +183,7 @@ struct fuse_args {
* @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept
*/
typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
- struct fuse_args *outargs);
+ struct fuse_args *outargs);
/**
* Option parsing function
@@ -197,7 +206,7 @@ typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
* @return -1 on error, 0 on success
*/
int fuse_opt_parse(struct fuse_args *args, void *data,
- const struct fuse_opt opts[], fuse_opt_proc_t proc);
+ const struct fuse_opt opts[], fuse_opt_proc_t proc);
/**
* Add an option to a comma separated option list
diff --git a/tools/virtiofsd/fuse_signals.c b/tools/virtiofsd/fuse_signals.c
index 4271947bd4..19d6791cb9 100644
--- a/tools/virtiofsd/fuse_signals.c
+++ b/tools/virtiofsd/fuse_signals.c
@@ -1,91 +1,95 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
-
- Utility functions for setting signal handlers.
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB
-*/
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * Utility functions for setting signal handlers.
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB
+ */
#include "config.h"
-#include "fuse_lowlevel.h"
#include "fuse_i.h"
+#include "fuse_lowlevel.h"
-#include <stdio.h>
-#include <string.h>
#include <signal.h>
+#include <stdio.h>
#include <stdlib.h>
+#include <string.h>
static struct fuse_session *fuse_instance;
static void exit_handler(int sig)
{
- if (fuse_instance) {
- fuse_session_exit(fuse_instance);
- if(sig <= 0) {
- fuse_log(FUSE_LOG_ERR, "assertion error: signal value <= 0\n");
- abort();
- }
- fuse_instance->error = sig;
- }
+ if (fuse_instance) {
+ fuse_session_exit(fuse_instance);
+ if (sig <= 0) {
+ fuse_log(FUSE_LOG_ERR, "assertion error: signal value <= 0\n");
+ abort();
+ }
+ fuse_instance->error = sig;
+ }
}
static void do_nothing(int sig)
{
- (void) sig;
+ (void)sig;
}
static int set_one_signal_handler(int sig, void (*handler)(int), int remove)
{
- struct sigaction sa;
- struct sigaction old_sa;
+ struct sigaction sa;
+ struct sigaction old_sa;
- memset(&sa, 0, sizeof(struct sigaction));
- sa.sa_handler = remove ? SIG_DFL : handler;
- sigemptyset(&(sa.sa_mask));
- sa.sa_flags = 0;
+ memset(&sa, 0, sizeof(struct sigaction));
+ sa.sa_handler = remove ? SIG_DFL : handler;
+ sigemptyset(&(sa.sa_mask));
+ sa.sa_flags = 0;
- if (sigaction(sig, NULL, &old_sa) == -1) {
- perror("fuse: cannot get old signal handler");
- return -1;
- }
+ if (sigaction(sig, NULL, &old_sa) == -1) {
+ perror("fuse: cannot get old signal handler");
+ return -1;
+ }
- if (old_sa.sa_handler == (remove ? handler : SIG_DFL) &&
- sigaction(sig, &sa, NULL) == -1) {
- perror("fuse: cannot set signal handler");
- return -1;
- }
- return 0;
+ if (old_sa.sa_handler == (remove ? handler : SIG_DFL) &&
+ sigaction(sig, &sa, NULL) == -1) {
+ perror("fuse: cannot set signal handler");
+ return -1;
+ }
+ return 0;
}
int fuse_set_signal_handlers(struct fuse_session *se)
{
- /* If we used SIG_IGN instead of the do_nothing function,
- then we would be unable to tell if we set SIG_IGN (and
- thus should reset to SIG_DFL in fuse_remove_signal_handlers)
- or if it was already set to SIG_IGN (and should be left
- untouched. */
- if (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||
- set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||
- set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||
- set_one_signal_handler(SIGPIPE, do_nothing, 0) == -1)
- return -1;
+ /*
+ * If we used SIG_IGN instead of the do_nothing function,
+ * then we would be unable to tell if we set SIG_IGN (and
+ * thus should reset to SIG_DFL in fuse_remove_signal_handlers)
+ * or if it was already set to SIG_IGN (and should be left
+ * untouched.
+ */
+ if (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||
+ set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||
+ set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||
+ set_one_signal_handler(SIGPIPE, do_nothing, 0) == -1) {
+ return -1;
+ }
- fuse_instance = se;
- return 0;
+ fuse_instance = se;
+ return 0;
}
void fuse_remove_signal_handlers(struct fuse_session *se)
{
- if (fuse_instance != se)
- fuse_log(FUSE_LOG_ERR,
- "fuse: fuse_remove_signal_handlers: unknown session\n");
- else
- fuse_instance = NULL;
+ if (fuse_instance != se) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: fuse_remove_signal_handlers: unknown session\n");
+ } else {
+ fuse_instance = NULL;
+ }
- set_one_signal_handler(SIGHUP, exit_handler, 1);
- set_one_signal_handler(SIGINT, exit_handler, 1);
- set_one_signal_handler(SIGTERM, exit_handler, 1);
- set_one_signal_handler(SIGPIPE, do_nothing, 1);
+ set_one_signal_handler(SIGHUP, exit_handler, 1);
+ set_one_signal_handler(SIGINT, exit_handler, 1);
+ set_one_signal_handler(SIGTERM, exit_handler, 1);
+ set_one_signal_handler(SIGPIPE, do_nothing, 1);
}
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 5a2e64c6d0..5711dd2660 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -1,297 +1,309 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * Helper functions to create (simple) standalone programs. With the
+ * aid of these functions it should be possible to create full FUSE
+ * file system by implementing nothing but the request handlers.
- Helper functions to create (simple) standalone programs. With the
- aid of these functions it should be possible to create full FUSE
- file system by implementing nothing but the request handlers.
-
- This program can be distributed under the terms of the GNU LGPLv2.
- See the file COPYING.LIB.
-*/
+ * 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_lowlevel.h"
#include "fuse_misc.h"
#include "fuse_opt.h"
-#include "fuse_lowlevel.h"
#include "mount_util.h"
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
-#include <stddef.h>
-#include <unistd.h>
#include <string.h>
-#include <limits.h>
-#include <errno.h>
#include <sys/param.h>
+#include <unistd.h>
-#define FUSE_HELPER_OPT(t, p) \
- { t, offsetof(struct fuse_cmdline_opts, p), 1 }
+#define FUSE_HELPER_OPT(t, p) \
+ { \
+ t, offsetof(struct fuse_cmdline_opts, p), 1 \
+ }
static const struct fuse_opt fuse_helper_opts[] = {
- FUSE_HELPER_OPT("-h", show_help),
- FUSE_HELPER_OPT("--help", show_help),
- FUSE_HELPER_OPT("-V", show_version),
- FUSE_HELPER_OPT("--version", show_version),
- FUSE_HELPER_OPT("-d", debug),
- FUSE_HELPER_OPT("debug", debug),
- FUSE_HELPER_OPT("-d", foreground),
- FUSE_HELPER_OPT("debug", foreground),
- FUSE_OPT_KEY("-d", FUSE_OPT_KEY_KEEP),
- FUSE_OPT_KEY("debug", FUSE_OPT_KEY_KEEP),
- FUSE_HELPER_OPT("-f", foreground),
- FUSE_HELPER_OPT("fsname=", nodefault_subtype),
- FUSE_OPT_KEY("fsname=", FUSE_OPT_KEY_KEEP),
- FUSE_HELPER_OPT("subtype=", nodefault_subtype),
- FUSE_OPT_KEY("subtype=", FUSE_OPT_KEY_KEEP),
- FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),
- FUSE_OPT_END
+ FUSE_HELPER_OPT("-h", show_help),
+ FUSE_HELPER_OPT("--help", show_help),
+ FUSE_HELPER_OPT("-V", show_version),
+ FUSE_HELPER_OPT("--version", show_version),
+ FUSE_HELPER_OPT("-d", debug),
+ FUSE_HELPER_OPT("debug", debug),
+ FUSE_HELPER_OPT("-d", foreground),
+ FUSE_HELPER_OPT("debug", foreground),
+ FUSE_OPT_KEY("-d", FUSE_OPT_KEY_KEEP),
+ FUSE_OPT_KEY("debug", FUSE_OPT_KEY_KEEP),
+ FUSE_HELPER_OPT("-f", foreground),
+ FUSE_HELPER_OPT("fsname=", nodefault_subtype),
+ FUSE_OPT_KEY("fsname=", FUSE_OPT_KEY_KEEP),
+ FUSE_HELPER_OPT("subtype=", nodefault_subtype),
+ FUSE_OPT_KEY("subtype=", FUSE_OPT_KEY_KEEP),
+ FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),
+ FUSE_OPT_END
};
struct fuse_conn_info_opts {
- int atomic_o_trunc;
- int no_remote_posix_lock;
- int no_remote_flock;
- int splice_write;
- int splice_move;
- int splice_read;
- int no_splice_write;
- int no_splice_move;
- int no_splice_read;
- int auto_inval_data;
- int no_auto_inval_data;
- int no_readdirplus;
- int no_readdirplus_auto;
- int async_dio;
- int no_async_dio;
- int writeback_cache;
- int no_writeback_cache;
- int async_read;
- int sync_read;
- unsigned max_write;
- unsigned max_readahead;
- unsigned max_background;
- unsigned congestion_threshold;
- unsigned time_gran;
- int set_max_write;
- int set_max_readahead;
- int set_max_background;
- int set_congestion_threshold;
- int set_time_gran;
+ int atomic_o_trunc;
+ int no_remote_posix_lock;
+ int no_remote_flock;
+ int splice_write;
+ int splice_move;
+ int splice_read;
+ int no_splice_write;
+ int no_splice_move;
+ int no_splice_read;
+ int auto_inval_data;
+ int no_auto_inval_data;
+ int no_readdirplus;
+ int no_readdirplus_auto;
+ int async_dio;
+ int no_async_dio;
+ int writeback_cache;
+ int no_writeback_cache;
+ int async_read;
+ int sync_read;
+ unsigned max_write;
+ unsigned max_readahead;
+ unsigned max_background;
+ unsigned congestion_threshold;
+ unsigned time_gran;
+ int set_max_write;
+ int set_max_readahead;
+ int set_max_background;
+ int set_congestion_threshold;
+ int set_time_gran;
};
-#define CONN_OPTION(t, p, v) \
- { t, offsetof(struct fuse_conn_info_opts, p), v }
+#define CONN_OPTION(t, p, v) \
+ { \
+ t, offsetof(struct fuse_conn_info_opts, p), v \
+ }
static const struct fuse_opt conn_info_opt_spec[] = {
- CONN_OPTION("max_write=%u", max_write, 0),
- CONN_OPTION("max_write=", set_max_write, 1),
- CONN_OPTION("max_readahead=%u", max_readahead, 0),
- CONN_OPTION("max_readahead=", set_max_readahead, 1),
- CONN_OPTION("max_background=%u", max_background, 0),
- CONN_OPTION("max_background=", set_max_background, 1),
- CONN_OPTION("congestion_threshold=%u", congestion_threshold, 0),
- CONN_OPTION("congestion_threshold=", set_congestion_threshold, 1),
- CONN_OPTION("sync_read", sync_read, 1),
- CONN_OPTION("async_read", async_read, 1),
- CONN_OPTION("atomic_o_trunc", atomic_o_trunc, 1),
- CONN_OPTION("no_remote_lock", no_remote_posix_lock, 1),
- CONN_OPTION("no_remote_lock", no_remote_flock, 1),
- CONN_OPTION("no_remote_flock", no_remote_flock, 1),
- CONN_OPTION("no_remote_posix_lock", no_remote_posix_lock, 1),
- CONN_OPTION("splice_write", splice_write, 1),
- CONN_OPTION("no_splice_write", no_splice_write, 1),
- CONN_OPTION("splice_move", splice_move, 1),
- CONN_OPTION("no_splice_move", no_splice_move, 1),
- CONN_OPTION("splice_read", splice_read, 1),
- CONN_OPTION("no_splice_read", no_splice_read, 1),
- CONN_OPTION("auto_inval_data", auto_inval_data, 1),
- CONN_OPTION("no_auto_inval_data", no_auto_inval_data, 1),
- CONN_OPTION("readdirplus=no", no_readdirplus, 1),
- CONN_OPTION("readdirplus=yes", no_readdirplus, 0),
- CONN_OPTION("readdirplus=yes", no_readdirplus_auto, 1),
- CONN_OPTION("readdirplus=auto", no_readdirplus, 0),
- CONN_OPTION("readdirplus=auto", no_readdirplus_auto, 0),
- CONN_OPTION("async_dio", async_dio, 1),
- CONN_OPTION("no_async_dio", no_async_dio, 1),
- CONN_OPTION("writeback_cache", writeback_cache, 1),
- CONN_OPTION("no_writeback_cache", no_writeback_cache, 1),
- CONN_OPTION("time_gran=%u", time_gran, 0),
- CONN_OPTION("time_gran=", set_time_gran, 1),
- FUSE_OPT_END
+ CONN_OPTION("max_write=%u", max_write, 0),
+ CONN_OPTION("max_write=", set_max_write, 1),
+ CONN_OPTION("max_readahead=%u", max_readahead, 0),
+ CONN_OPTION("max_readahead=", set_max_readahead, 1),
+ CONN_OPTION("max_background=%u", max_background, 0),
+ CONN_OPTION("max_background=", set_max_background, 1),
+ CONN_OPTION("congestion_threshold=%u", congestion_threshold, 0),
+ CONN_OPTION("congestion_threshold=", set_congestion_threshold, 1),
+ CONN_OPTION("sync_read", sync_read, 1),
+ CONN_OPTION("async_read", async_read, 1),
+ CONN_OPTION("atomic_o_trunc", atomic_o_trunc, 1),
+ CONN_OPTION("no_remote_lock", no_remote_posix_lock, 1),
+ CONN_OPTION("no_remote_lock", no_remote_flock, 1),
+ CONN_OPTION("no_remote_flock", no_remote_flock, 1),
+ CONN_OPTION("no_remote_posix_lock", no_remote_posix_lock, 1),
+ CONN_OPTION("splice_write", splice_write, 1),
+ CONN_OPTION("no_splice_write", no_splice_write, 1),
+ CONN_OPTION("splice_move", splice_move, 1),
+ CONN_OPTION("no_splice_move", no_splice_move, 1),
+ CONN_OPTION("splice_read", splice_read, 1),
+ CONN_OPTION("no_splice_read", no_splice_read, 1),
+ CONN_OPTION("auto_inval_data", auto_inval_data, 1),
+ CONN_OPTION("no_auto_inval_data", no_auto_inval_data, 1),
+ CONN_OPTION("readdirplus=no", no_readdirplus, 1),
+ CONN_OPTION("readdirplus=yes", no_readdirplus, 0),
+ CONN_OPTION("readdirplus=yes", no_readdirplus_auto, 1),
+ CONN_OPTION("readdirplus=auto", no_readdirplus, 0),
+ CONN_OPTION("readdirplus=auto", no_readdirplus_auto, 0),
+ CONN_OPTION("async_dio", async_dio, 1),
+ CONN_OPTION("no_async_dio", no_async_dio, 1),
+ CONN_OPTION("writeback_cache", writeback_cache, 1),
+ CONN_OPTION("no_writeback_cache", no_writeback_cache, 1),
+ CONN_OPTION("time_gran=%u", time_gran, 0),
+ CONN_OPTION("time_gran=", set_time_gran, 1),
+ FUSE_OPT_END
};
void fuse_cmdline_help(void)
{
- printf(" -h --help print help\n"
- " -V --version print version\n"
- " -d -o debug enable debug output (implies -f)\n"
- " -f foreground operation\n"
- " -o max_idle_threads the maximum number of idle worker threads\n"
- " allowed (default: 10)\n");
+ printf(
+ " -h --help print help\n"
+ " -V --version print version\n"
+ " -d -o debug enable debug output (implies -f)\n"
+ " -f foreground operation\n"
+ " -o max_idle_threads the maximum number of idle worker threads\n"
+ " allowed (default: 10)\n");
}
static int fuse_helper_opt_proc(void *data, const char *arg, int key,
- struct fuse_args *outargs)
+ struct fuse_args *outargs)
{
- (void) outargs;
- struct fuse_cmdline_opts *opts = data;
-
- switch (key) {
- case FUSE_OPT_KEY_NONOPT:
- if (!opts->mountpoint) {
- if (fuse_mnt_parse_fuse_fd(arg) != -1) {
- return fuse_opt_add_opt(&opts->mountpoint, arg);
- }
-
- char mountpoint[PATH_MAX] = "";
- if (realpath(arg, mountpoint) == NULL) {
- fuse_log(FUSE_LOG_ERR,
- "fuse: bad mount point `%s': %s\n",
- arg, strerror(errno));
- return -1;
- }
- return fuse_opt_add_opt(&opts->mountpoint, mountpoint);
- } else {
- fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
- return -1;
- }
-
- default:
- /* Pass through unknown options */
- return 1;
- }
+ (void)outargs;
+ struct fuse_cmdline_opts *opts = data;
+
+ switch (key) {
+ case FUSE_OPT_KEY_NONOPT:
+ if (!opts->mountpoint) {
+ if (fuse_mnt_parse_fuse_fd(arg) != -1) {
+ return fuse_opt_add_opt(&opts->mountpoint, arg);
+ }
+
+ char mountpoint[PATH_MAX] = "";
+ if (realpath(arg, mountpoint) == NULL) {
+ fuse_log(FUSE_LOG_ERR, "fuse: bad mount point `%s': %s\n", arg,
+ strerror(errno));
+ return -1;
+ }
+ return fuse_opt_add_opt(&opts->mountpoint, mountpoint);
+ } else {
+ fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
+ return -1;
+ }
+
+ default:
+ /* Pass through unknown options */
+ return 1;
+ }
}
-int fuse_parse_cmdline(struct fuse_args *args,
- struct fuse_cmdline_opts *opts)
+int fuse_parse_cmdline(struct fuse_args *args, struct fuse_cmdline_opts *opts)
{
- memset(opts, 0, sizeof(struct fuse_cmdline_opts));
+ memset(opts, 0, sizeof(struct fuse_cmdline_opts));
- opts->max_idle_threads = 10;
+ opts->max_idle_threads = 10;
- if (fuse_opt_parse(args, opts, fuse_helper_opts,
- fuse_helper_opt_proc) == -1)
- return -1;
+ if (fuse_opt_parse(args, opts, fuse_helper_opts, fuse_helper_opt_proc) ==
+ -1) {
+ return -1;
+ }
- return 0;
+ return 0;
}
int fuse_daemonize(int foreground)
{
- if (!foreground) {
- int nullfd;
- int waiter[2];
- char completed;
-
- if (pipe(waiter)) {
- perror("fuse_daemonize: pipe");
- return -1;
- }
-
- /*
- * demonize current process by forking it and killing the
- * parent. This makes current process as a child of 'init'.
- */
- switch(fork()) {
- case -1:
- perror("fuse_daemonize: fork");
- return -1;
- case 0:
- break;
- default:
- (void) read(waiter[0], &completed, sizeof(completed));
- _exit(0);
- }
-
- if (setsid() == -1) {
- perror("fuse_daemonize: setsid");
- return -1;
- }
-
- (void) chdir("/");
-
- nullfd = open("/dev/null", O_RDWR, 0);
- if (nullfd != -1) {
- (void) dup2(nullfd, 0);
- (void) dup2(nullfd, 1);
- (void) dup2(nullfd, 2);
- if (nullfd > 2)
- close(nullfd);
- }
-
- /* Propagate completion of daemon initialization */
- completed = 1;
- (void) write(waiter[1], &completed, sizeof(completed));
- close(waiter[0]);
- close(waiter[1]);
- } else {
- (void) chdir("/");
- }
- return 0;
+ if (!foreground) {
+ int nullfd;
+ int waiter[2];
+ char completed;
+
+ if (pipe(waiter)) {
+ perror("fuse_daemonize: pipe");
+ return -1;
+ }
+
+ /*
+ * demonize current process by forking it and killing the
+ * parent. This makes current process as a child of 'init'.
+ */
+ switch (fork()) {
+ case -1:
+ perror("fuse_daemonize: fork");
+ return -1;
+ case 0:
+ break;
+ default:
+ (void)read(waiter[0], &completed, sizeof(completed));
+ _exit(0);
+ }
+
+ if (setsid() == -1) {
+ perror("fuse_daemonize: setsid");
+ return -1;
+ }
+
+ (void)chdir("/");
+
+ nullfd = open("/dev/null", O_RDWR, 0);
+ if (nullfd != -1) {
+ (void)dup2(nullfd, 0);
+ (void)dup2(nullfd, 1);
+ (void)dup2(nullfd, 2);
+ if (nullfd > 2) {
+ close(nullfd);
+ }
+ }
+
+ /* Propagate completion of daemon initialization */
+ completed = 1;
+ (void)write(waiter[1], &completed, sizeof(completed));
+ close(waiter[0]);
+ close(waiter[1]);
+ } else {
+ (void)chdir("/");
+ }
+ return 0;
}
void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts,
- struct fuse_conn_info *conn)
+ struct fuse_conn_info *conn)
{
- if(opts->set_max_write)
- conn->max_write = opts->max_write;
- if(opts->set_max_background)
- conn->max_background = opts->max_background;
- if(opts->set_congestion_threshold)
- conn->congestion_threshold = opts->congestion_threshold;
- if(opts->set_time_gran)
- conn->time_gran = opts->time_gran;
- if(opts->set_max_readahead)
- conn->max_readahead = opts->max_readahead;
-
-#define LL_ENABLE(cond,cap) \
- if (cond) conn->want |= (cap)
-#define LL_DISABLE(cond,cap) \
- if (cond) conn->want &= ~(cap)
-
- LL_ENABLE(opts->splice_read, FUSE_CAP_SPLICE_READ);
- LL_DISABLE(opts->no_splice_read, FUSE_CAP_SPLICE_READ);
-
- LL_ENABLE(opts->splice_write, FUSE_CAP_SPLICE_WRITE);
- LL_DISABLE(opts->no_splice_write, FUSE_CAP_SPLICE_WRITE);
-
- LL_ENABLE(opts->splice_move, FUSE_CAP_SPLICE_MOVE);
- LL_DISABLE(opts->no_splice_move, FUSE_CAP_SPLICE_MOVE);
-
- LL_ENABLE(opts->auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
- LL_DISABLE(opts->no_auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
-
- LL_DISABLE(opts->no_readdirplus, FUSE_CAP_READDIRPLUS);
- LL_DISABLE(opts->no_readdirplus_auto, FUSE_CAP_READDIRPLUS_AUTO);
-
- LL_ENABLE(opts->async_dio, FUSE_CAP_ASYNC_DIO);
- LL_DISABLE(opts->no_async_dio, FUSE_CAP_ASYNC_DIO);
-
- LL_ENABLE(opts->writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
- LL_DISABLE(opts->no_writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
-
- LL_ENABLE(opts->async_read, FUSE_CAP_ASYNC_READ);
- LL_DISABLE(opts->sync_read, FUSE_CAP_ASYNC_READ);
-
- LL_DISABLE(opts->no_remote_posix_lock, FUSE_CAP_POSIX_LOCKS);
- LL_DISABLE(opts->no_remote_flock, FUSE_CAP_FLOCK_LOCKS);
+ if (opts->set_max_write) {
+ conn->max_write = opts->max_write;
+ }
+ if (opts->set_max_background) {
+ conn->max_background = opts->max_background;
+ }
+ if (opts->set_congestion_threshold) {
+ conn->congestion_threshold = opts->congestion_threshold;
+ }
+ if (opts->set_time_gran) {
+ conn->time_gran = opts->time_gran;
+ }
+ if (opts->set_max_readahead) {
+ conn->max_readahead = opts->max_readahead;
+ }
+
+#define LL_ENABLE(cond, cap) \
+ if (cond) \
+ conn->want |= (cap)
+#define LL_DISABLE(cond, cap) \
+ if (cond) \
+ conn->want &= ~(cap)
+
+ LL_ENABLE(opts->splice_read, FUSE_CAP_SPLICE_READ);
+ LL_DISABLE(opts->no_splice_read, FUSE_CAP_SPLICE_READ);
+
+ LL_ENABLE(opts->splice_write, FUSE_CAP_SPLICE_WRITE);
+ LL_DISABLE(opts->no_splice_write, FUSE_CAP_SPLICE_WRITE);
+
+ LL_ENABLE(opts->splice_move, FUSE_CAP_SPLICE_MOVE);
+ LL_DISABLE(opts->no_splice_move, FUSE_CAP_SPLICE_MOVE);
+
+ LL_ENABLE(opts->auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
+ LL_DISABLE(opts->no_auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
+
+ LL_DISABLE(opts->no_readdirplus, FUSE_CAP_READDIRPLUS);
+ LL_DISABLE(opts->no_readdirplus_auto, FUSE_CAP_READDIRPLUS_AUTO);
+
+ LL_ENABLE(opts->async_dio, FUSE_CAP_ASYNC_DIO);
+ LL_DISABLE(opts->no_async_dio, FUSE_CAP_ASYNC_DIO);
+
+ LL_ENABLE(opts->writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
+ LL_DISABLE(opts->no_writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
+
+ LL_ENABLE(opts->async_read, FUSE_CAP_ASYNC_READ);
+ LL_DISABLE(opts->sync_read, FUSE_CAP_ASYNC_READ);
+
+ LL_DISABLE(opts->no_remote_posix_lock, FUSE_CAP_POSIX_LOCKS);
+ LL_DISABLE(opts->no_remote_flock, FUSE_CAP_FLOCK_LOCKS);
}
-struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args)
+struct fuse_conn_info_opts *fuse_parse_conn_info_opts(struct fuse_args *args)
{
- struct fuse_conn_info_opts *opts;
-
- opts = calloc(1, sizeof(struct fuse_conn_info_opts));
- if(opts == NULL) {
- fuse_log(FUSE_LOG_ERR, "calloc failed\n");
- return NULL;
- }
- if(fuse_opt_parse(args, opts, conn_info_opt_spec, NULL) == -1) {
- free(opts);
- return NULL;
- }
- return opts;
+ struct fuse_conn_info_opts *opts;
+
+ opts = calloc(1, sizeof(struct fuse_conn_info_opts));
+ if (opts == NULL) {
+ fuse_log(FUSE_LOG_ERR, "calloc failed\n");
+ return NULL;
+ }
+ if (fuse_opt_parse(args, opts, conn_info_opt_spec, NULL) == -1) {
+ free(opts);
+ return NULL;
+ }
+ return opts;
}
diff --git a/tools/virtiofsd/passthrough_helpers.h b/tools/virtiofsd/passthrough_helpers.h
index 7c5f561fbc..0b98275ed5 100644
--- a/tools/virtiofsd/passthrough_helpers.h
+++ b/tools/virtiofsd/passthrough_helpers.h
@@ -28,23 +28,24 @@
* operation
*/
static int mknod_wrapper(int dirfd, const char *path, const char *link,
- int mode, dev_t rdev)
+ int mode, dev_t rdev)
{
- int res;
+ int res;
- if (S_ISREG(mode)) {
- res = openat(dirfd, path, O_CREAT | O_EXCL | O_WRONLY, mode);
- if (res >= 0)
- res = close(res);
- } else if (S_ISDIR(mode)) {
- res = mkdirat(dirfd, path, mode);
- } else if (S_ISLNK(mode) && link != NULL) {
- res = symlinkat(link, dirfd, path);
- } else if (S_ISFIFO(mode)) {
- res = mkfifoat(dirfd, path, mode);
- } else {
- res = mknodat(dirfd, path, mode, rdev);
- }
+ if (S_ISREG(mode)) {
+ res = openat(dirfd, path, O_CREAT | O_EXCL | O_WRONLY, mode);
+ if (res >= 0) {
+ res = close(res);
+ }
+ } else if (S_ISDIR(mode)) {
+ res = mkdirat(dirfd, path, mode);
+ } else if (S_ISLNK(mode) && link != NULL) {
+ res = symlinkat(link, dirfd, path);
+ } else if (S_ISFIFO(mode)) {
+ res = mkfifoat(dirfd, path, mode);
+ } else {
+ res = mknodat(dirfd, path, mode, rdev);
+ }
- return res;
+ return res;
}
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index e5f7115bc1..c5850ef803 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1,12 +1,12 @@
/*
- FUSE: Filesystem in Userspace
- Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
-
- This program can be distributed under the terms of the GNU GPLv2.
- See the file COPYING.
-*/
+ * FUSE: Filesystem in Userspace
+ * Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU GPLv2.
+ * See the file COPYING.
+ */
-/** @file
+/*
*
* This file system mirrors the existing file system hierarchy of the
* system, starting at the root file system. This is implemented by
@@ -28,7 +28,8 @@
*
* Compile with:
*
- * gcc -Wall passthrough_ll.c `pkg-config fuse3 --cflags --libs` -o passthrough_ll
+ * gcc -Wall passthrough_ll.c `pkg-config fuse3 --cflags --libs` -o
+ * passthrough_ll
*
* ## Source code ##
* \include passthrough_ll.c
@@ -39,1299 +40,1365 @@
#include "config.h"
-#include <fuse_lowlevel.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <string.h>
-#include <limits.h>
-#include <dirent.h>
#include <assert.h>
+#include <dirent.h>
#include <errno.h>
+#include <fuse_lowlevel.h>
#include <inttypes.h>
+#include <limits.h>
#include <pthread.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
#include <sys/file.h>
#include <sys/xattr.h>
+#include <unistd.h>
#include "passthrough_helpers.h"
-/* We are re-using pointers to our `struct lo_inode` and `struct
- lo_dirp` elements as inodes. This means that we must be able to
- store uintptr_t values in a fuse_ino_t variable. The following
- incantation checks this condition at compile time. */
-#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
+/*
+ * We are re-using pointers to our `struct lo_inode` and `struct
+ * lo_dirp` elements as inodes. This means that we must be able to
+ * store uintptr_t values in a fuse_ino_t variable. The following
+ * incantation checks this condition at compile time.
+ */
+#if defined(__GNUC__) && \
+ (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && \
+ !defined __cplusplus
_Static_assert(sizeof(fuse_ino_t) >= sizeof(uintptr_t),
- "fuse_ino_t too small to hold uintptr_t values!");
+ "fuse_ino_t too small to hold uintptr_t values!");
#else
-struct _uintptr_to_must_hold_fuse_ino_t_dummy_struct \
- { unsigned _uintptr_to_must_hold_fuse_ino_t:
- ((sizeof(fuse_ino_t) >= sizeof(uintptr_t)) ? 1 : -1); };
+struct _uintptr_to_must_hold_fuse_ino_t_dummy_struct {
+ unsigned _uintptr_to_must_hold_fuse_ino_t
+ : ((sizeof(fuse_ino_t) >= sizeof(uintptr_t)) ? 1 : -1);
+};
#endif
struct lo_inode {
- struct lo_inode *next; /* protected by lo->mutex */
- struct lo_inode *prev; /* protected by lo->mutex */
- int fd;
- bool is_symlink;
- ino_t ino;
- dev_t dev;
- uint64_t refcount; /* protected by lo->mutex */
+ struct lo_inode *next; /* protected by lo->mutex */
+ struct lo_inode *prev; /* protected by lo->mutex */
+ int fd;
+ bool is_symlink;
+ ino_t ino;
+ dev_t dev;
+ uint64_t refcount; /* protected by lo->mutex */
};
enum {
- CACHE_NEVER,
- CACHE_NORMAL,
- CACHE_ALWAYS,
+ CACHE_NEVER,
+ CACHE_NORMAL,
+ CACHE_ALWAYS,
};
struct lo_data {
- pthread_mutex_t mutex;
- int debug;
- int writeback;
- int flock;
- int xattr;
- const char *source;
- double timeout;
- int cache;
- int timeout_set;
- struct lo_inode root; /* protected by lo->mutex */
+ pthread_mutex_t mutex;
+ int debug;
+ int writeback;
+ int flock;
+ int xattr;
+ const char *source;
+ double timeout;
+ int cache;
+ int timeout_set;
+ struct lo_inode root; /* protected by lo->mutex */
};
static const struct fuse_opt lo_opts[] = {
- { "writeback",
- offsetof(struct lo_data, writeback), 1 },
- { "no_writeback",
- offsetof(struct lo_data, writeback), 0 },
- { "source=%s",
- offsetof(struct lo_data, source), 0 },
- { "flock",
- offsetof(struct lo_data, flock), 1 },
- { "no_flock",
- offsetof(struct lo_data, flock), 0 },
- { "xattr",
- offsetof(struct lo_data, xattr), 1 },
- { "no_xattr",
- offsetof(struct lo_data, xattr), 0 },
- { "timeout=%lf",
- offsetof(struct lo_data, timeout), 0 },
- { "timeout=",
- offsetof(struct lo_data, timeout_set), 1 },
- { "cache=never",
- offsetof(struct lo_data, cache), CACHE_NEVER },
- { "cache=auto",
- offsetof(struct lo_data, cache), CACHE_NORMAL },
- { "cache=always",
- offsetof(struct lo_data, cache), CACHE_ALWAYS },
-
- FUSE_OPT_END
+ { "writeback", offsetof(struct lo_data, writeback), 1 },
+ { "no_writeback", offsetof(struct lo_data, writeback), 0 },
+ { "source=%s", offsetof(struct lo_data, source), 0 },
+ { "flock", offsetof(struct lo_data, flock), 1 },
+ { "no_flock", offsetof(struct lo_data, flock), 0 },
+ { "xattr", offsetof(struct lo_data, xattr), 1 },
+ { "no_xattr", offsetof(struct lo_data, xattr), 0 },
+ { "timeout=%lf", offsetof(struct lo_data, timeout), 0 },
+ { "timeout=", offsetof(struct lo_data, timeout_set), 1 },
+ { "cache=never", offsetof(struct lo_data, cache), CACHE_NEVER },
+ { "cache=auto", offsetof(struct lo_data, cache), CACHE_NORMAL },
+ { "cache=always", offsetof(struct lo_data, cache), CACHE_ALWAYS },
+
+ FUSE_OPT_END
};
static struct lo_data *lo_data(fuse_req_t req)
{
- return (struct lo_data *) fuse_req_userdata(req);
+ return (struct lo_data *)fuse_req_userdata(req);
}
static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino)
{
- if (ino == FUSE_ROOT_ID)
- return &lo_data(req)->root;
- else
- return (struct lo_inode *) (uintptr_t) ino;
+ if (ino == FUSE_ROOT_ID) {
+ return &lo_data(req)->root;
+ } else {
+ return (struct lo_inode *)(uintptr_t)ino;
+ }
}
static int lo_fd(fuse_req_t req, fuse_ino_t ino)
{
- return lo_inode(req, ino)->fd;
+ return lo_inode(req, ino)->fd;
}
static bool lo_debug(fuse_req_t req)
{
- return lo_data(req)->debug != 0;
+ return lo_data(req)->debug != 0;
}
-static void lo_init(void *userdata,
- struct fuse_conn_info *conn)
+static void lo_init(void *userdata, struct fuse_conn_info *conn)
{
- struct lo_data *lo = (struct lo_data*) userdata;
-
- if(conn->capable & FUSE_CAP_EXPORT_SUPPORT)
- conn->want |= FUSE_CAP_EXPORT_SUPPORT;
-
- if (lo->writeback &&
- conn->capable & FUSE_CAP_WRITEBACK_CACHE) {
- if (lo->debug)
- fuse_log(FUSE_LOG_DEBUG, "lo_init: activating writeback\n");
- conn->want |= FUSE_CAP_WRITEBACK_CACHE;
- }
- if (lo->flock && conn->capable & FUSE_CAP_FLOCK_LOCKS) {
- if (lo->debug)
- fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
- conn->want |= FUSE_CAP_FLOCK_LOCKS;
- }
+ struct lo_data *lo = (struct lo_data *)userdata;
+
+ if (conn->capable & FUSE_CAP_EXPORT_SUPPORT) {
+ conn->want |= FUSE_CAP_EXPORT_SUPPORT;
+ }
+
+ if (lo->writeback && conn->capable & FUSE_CAP_WRITEBACK_CACHE) {
+ if (lo->debug) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating writeback\n");
+ }
+ conn->want |= FUSE_CAP_WRITEBACK_CACHE;
+ }
+ if (lo->flock && conn->capable & FUSE_CAP_FLOCK_LOCKS) {
+ if (lo->debug) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
+ }
+ conn->want |= FUSE_CAP_FLOCK_LOCKS;
+ }
}
static void lo_getattr(fuse_req_t req, fuse_ino_t ino,
- struct fuse_file_info *fi)
+ struct fuse_file_info *fi)
{
- int res;
- struct stat buf;
- struct lo_data *lo = lo_data(req);
+ int res;
+ struct stat buf;
+ struct lo_data *lo = lo_data(req);
- (void) fi;
+ (void)fi;
- res = fstatat(lo_fd(req, ino), "", &buf, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
- if (res == -1)
- return (void) fuse_reply_err(req, errno);
+ res =
+ fstatat(lo_fd(req, ino), "", &buf, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1) {
+ return (void)fuse_reply_err(req, errno);
+ }
- fuse_reply_attr(req, &buf, lo->timeout);
+ fuse_reply_attr(req, &buf, lo->timeout);
}
static int utimensat_empty_nofollow(struct lo_inode *inode,
- const struct timespec *tv)
+ const struct timespec *tv)
{
- int res;
- char procname[64];
-
- if (inode->is_symlink) {
- res = utimensat(inode->fd, "", tv,
- AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
- if (res == -1 && errno == EINVAL) {
- /* Sorry, no race free way to set times on symlink. */
- errno = EPERM;
- }
- return res;
- }
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
-
- return utimensat(AT_FDCWD, procname, tv, 0);
+ int res;
+ char procname[64];
+
+ if (inode->is_symlink) {
+ res = utimensat(inode->fd, "", tv, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1 && errno == EINVAL) {
+ /* Sorry, no race free way to set times on symlink. */
+ errno = EPERM;
+ }
+ return res;
+ }
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ return utimensat(AT_FDCWD, procname, tv, 0);
}
static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
- int valid, struct fuse_file_info *fi)
+ int valid, struct fuse_file_info *fi)
{
- int saverr;
- char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
- int ifd = inode->fd;
- int res;
-
- if (valid & FUSE_SET_ATTR_MODE) {
- if (fi) {
- res = fchmod(fi->fh, attr->st_mode);
- } else {
- sprintf(procname, "/proc/self/fd/%i", ifd);
- res = chmod(procname, attr->st_mode);
- }
- if (res == -1)
- goto out_err;
- }
- if (valid & (FUSE_SET_ATTR_UID | FUSE_SET_ATTR_GID)) {
- uid_t uid = (valid & FUSE_SET_ATTR_UID) ?
- attr->st_uid : (uid_t) -1;
- gid_t gid = (valid & FUSE_SET_ATTR_GID) ?
- attr->st_gid : (gid_t) -1;
-
- res = fchownat(ifd, "", uid, gid,
- AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
- if (res == -1)
- goto out_err;
- }
- if (valid & FUSE_SET_ATTR_SIZE) {
- if (fi) {
- res = ftruncate(fi->fh, attr->st_size);
- } else {
- sprintf(procname, "/proc/self/fd/%i", ifd);
- res = truncate(procname, attr->st_size);
- }
- if (res == -1)
- goto out_err;
- }
- if (valid & (FUSE_SET_ATTR_ATIME | FUSE_SET_ATTR_MTIME)) {
- struct timespec tv[2];
-
- tv[0].tv_sec = 0;
- tv[1].tv_sec = 0;
- tv[0].tv_nsec = UTIME_OMIT;
- tv[1].tv_nsec = UTIME_OMIT;
-
- if (valid & FUSE_SET_ATTR_ATIME_NOW)
- tv[0].tv_nsec = UTIME_NOW;
- else if (valid & FUSE_SET_ATTR_ATIME)
- tv[0] = attr->st_atim;
-
- if (valid & FUSE_SET_ATTR_MTIME_NOW)
- tv[1].tv_nsec = UTIME_NOW;
- else if (valid & FUSE_SET_ATTR_MTIME)
- tv[1] = attr->st_mtim;
-
- if (fi)
- res = futimens(fi->fh, tv);
- else
- res = utimensat_empty_nofollow(inode, tv);
- if (res == -1)
- goto out_err;
- }
-
- return lo_getattr(req, ino, fi);
+ int saverr;
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ int ifd = inode->fd;
+ int res;
+
+ if (valid & FUSE_SET_ATTR_MODE) {
+ if (fi) {
+ res = fchmod(fi->fh, attr->st_mode);
+ } else {
+ sprintf(procname, "/proc/self/fd/%i", ifd);
+ res = chmod(procname, attr->st_mode);
+ }
+ if (res == -1) {
+ goto out_err;
+ }
+ }
+ if (valid & (FUSE_SET_ATTR_UID | FUSE_SET_ATTR_GID)) {
+ uid_t uid = (valid & FUSE_SET_ATTR_UID) ? attr->st_uid : (uid_t)-1;
+ gid_t gid = (valid & FUSE_SET_ATTR_GID) ? attr->st_gid : (gid_t)-1;
+
+ res = fchownat(ifd, "", uid, gid, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1) {
+ goto out_err;
+ }
+ }
+ if (valid & FUSE_SET_ATTR_SIZE) {
+ if (fi) {
+ res = ftruncate(fi->fh, attr->st_size);
+ } else {
+ sprintf(procname, "/proc/self/fd/%i", ifd);
+ res = truncate(procname, attr->st_size);
+ }
+ if (res == -1) {
+ goto out_err;
+ }
+ }
+ if (valid & (FUSE_SET_ATTR_ATIME | FUSE_SET_ATTR_MTIME)) {
+ struct timespec tv[2];
+
+ tv[0].tv_sec = 0;
+ tv[1].tv_sec = 0;
+ tv[0].tv_nsec = UTIME_OMIT;
+ tv[1].tv_nsec = UTIME_OMIT;
+
+ if (valid & FUSE_SET_ATTR_ATIME_NOW) {
+ tv[0].tv_nsec = UTIME_NOW;
+ } else if (valid & FUSE_SET_ATTR_ATIME) {
+ tv[0] = attr->st_atim;
+ }
+
+ if (valid & FUSE_SET_ATTR_MTIME_NOW) {
+ tv[1].tv_nsec = UTIME_NOW;
+ } else if (valid & FUSE_SET_ATTR_MTIME) {
+ tv[1] = attr->st_mtim;
+ }
+
+ if (fi) {
+ res = futimens(fi->fh, tv);
+ } else {
+ res = utimensat_empty_nofollow(inode, tv);
+ }
+ if (res == -1) {
+ goto out_err;
+ }
+ }
+
+ return lo_getattr(req, ino, fi);
out_err:
- saverr = errno;
- fuse_reply_err(req, saverr);
+ saverr = errno;
+ fuse_reply_err(req, saverr);
}
static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st)
{
- struct lo_inode *p;
- struct lo_inode *ret = NULL;
-
- pthread_mutex_lock(&lo->mutex);
- for (p = lo->root.next; p != &lo->root; p = p->next) {
- if (p->ino == st->st_ino && p->dev == st->st_dev) {
- assert(p->refcount > 0);
- ret = p;
- ret->refcount++;
- break;
- }
- }
- pthread_mutex_unlock(&lo->mutex);
- return ret;
+ struct lo_inode *p;
+ struct lo_inode *ret = NULL;
+
+ pthread_mutex_lock(&lo->mutex);
+ for (p = lo->root.next; p != &lo->root; p = p->next) {
+ if (p->ino == st->st_ino && p->dev == st->st_dev) {
+ assert(p->refcount > 0);
+ ret = p;
+ ret->refcount++;
+ break;
+ }
+ }
+ pthread_mutex_unlock(&lo->mutex);
+ return ret;
}
static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
- struct fuse_entry_param *e)
+ struct fuse_entry_param *e)
{
- int newfd;
- int res;
- int saverr;
- struct lo_data *lo = lo_data(req);
- struct lo_inode *inode;
-
- memset(e, 0, sizeof(*e));
- e->attr_timeout = lo->timeout;
- e->entry_timeout = lo->timeout;
-
- newfd = openat(lo_fd(req, parent), name, O_PATH | O_NOFOLLOW);
- if (newfd == -1)
- goto out_err;
-
- res = fstatat(newfd, "", &e->attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
- if (res == -1)
- goto out_err;
-
- inode = lo_find(lo_data(req), &e->attr);
- if (inode) {
- close(newfd);
- newfd = -1;
- } else {
- struct lo_inode *prev, *next;
-
- saverr = ENOMEM;
- inode = calloc(1, sizeof(struct lo_inode));
- if (!inode)
- goto out_err;
-
- inode->is_symlink = S_ISLNK(e->attr.st_mode);
- inode->refcount = 1;
- inode->fd = newfd;
- inode->ino = e->attr.st_ino;
- inode->dev = e->attr.st_dev;
-
- pthread_mutex_lock(&lo->mutex);
- prev = &lo->root;
- next = prev->next;
- next->prev = inode;
- inode->next = next;
- inode->prev = prev;
- prev->next = inode;
- pthread_mutex_unlock(&lo->mutex);
- }
- e->ino = (uintptr_t) inode;
-
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
- (unsigned long long) parent, name, (unsigned long long) e->ino);
-
- return 0;
+ int newfd;
+ int res;
+ int saverr;
+ struct lo_data *lo = lo_data(req);
+ struct lo_inode *inode;
+
+ memset(e, 0, sizeof(*e));
+ e->attr_timeout = lo->timeout;
+ e->entry_timeout = lo->timeout;
+
+ newfd = openat(lo_fd(req, parent), name, O_PATH | O_NOFOLLOW);
+ if (newfd == -1) {
+ goto out_err;
+ }
+
+ res = fstatat(newfd, "", &e->attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1) {
+ goto out_err;
+ }
+
+ inode = lo_find(lo_data(req), &e->attr);
+ if (inode) {
+ close(newfd);
+ newfd = -1;
+ } else {
+ struct lo_inode *prev, *next;
+
+ saverr = ENOMEM;
+ inode = calloc(1, sizeof(struct lo_inode));
+ if (!inode) {
+ goto out_err;
+ }
+
+ inode->is_symlink = S_ISLNK(e->attr.st_mode);
+ inode->refcount = 1;
+ inode->fd = newfd;
+ inode->ino = e->attr.st_ino;
+ inode->dev = e->attr.st_dev;
+
+ pthread_mutex_lock(&lo->mutex);
+ prev = &lo->root;
+ next = prev->next;
+ next->prev = inode;
+ inode->next = next;
+ inode->prev = prev;
+ prev->next = inode;
+ pthread_mutex_unlock(&lo->mutex);
+ }
+ e->ino = (uintptr_t)inode;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
+ (unsigned long long)parent, name, (unsigned long long)e->ino);
+ }
+
+ return 0;
out_err:
- saverr = errno;
- if (newfd != -1)
- close(newfd);
- return saverr;
+ saverr = errno;
+ if (newfd != -1) {
+ close(newfd);
+ }
+ return saverr;
}
static void lo_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
{
- struct fuse_entry_param e;
- int err;
-
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, "lo_lookup(parent=%" PRIu64 ", name=%s)\n",
- parent, name);
-
- err = lo_do_lookup(req, parent, name, &e);
- if (err)
- fuse_reply_err(req, err);
- else
- fuse_reply_entry(req, &e);
+ struct fuse_entry_param e;
+ int err;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_lookup(parent=%" PRIu64 ", name=%s)\n",
+ parent, name);
+ }
+
+ err = lo_do_lookup(req, parent, name, &e);
+ if (err) {
+ fuse_reply_err(req, err);
+ } else {
+ fuse_reply_entry(req, &e);
+ }
}
static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
- const char *name, mode_t mode, dev_t rdev,
- const char *link)
+ const char *name, mode_t mode, dev_t rdev,
+ const char *link)
{
- int res;
- int saverr;
- struct lo_inode *dir = lo_inode(req, parent);
- struct fuse_entry_param e;
+ int res;
+ int saverr;
+ struct lo_inode *dir = lo_inode(req, parent);
+ struct fuse_entry_param e;
- saverr = ENOMEM;
+ saverr = ENOMEM;
- res = mknod_wrapper(dir->fd, name, link, mode, rdev);
+ res = mknod_wrapper(dir->fd, name, link, mode, rdev);
- saverr = errno;
- if (res == -1)
- goto out;
+ saverr = errno;
+ if (res == -1) {
+ goto out;
+ }
- saverr = lo_do_lookup(req, parent, name, &e);
- if (saverr)
- goto out;
+ saverr = lo_do_lookup(req, parent, name, &e);
+ if (saverr) {
+ goto out;
+ }
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
- (unsigned long long) parent, name, (unsigned long long) e.ino);
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
+ (unsigned long long)parent, name, (unsigned long long)e.ino);
+ }
- fuse_reply_entry(req, &e);
- return;
+ fuse_reply_entry(req, &e);
+ return;
out:
- fuse_reply_err(req, saverr);
+ fuse_reply_err(req, saverr);
}
-static void lo_mknod(fuse_req_t req, fuse_ino_t parent,
- const char *name, mode_t mode, dev_t rdev)
+static void lo_mknod(fuse_req_t req, fuse_ino_t parent, const char *name,
+ mode_t mode, dev_t rdev)
{
- lo_mknod_symlink(req, parent, name, mode, rdev, NULL);
+ lo_mknod_symlink(req, parent, name, mode, rdev, NULL);
}
static void lo_mkdir(fuse_req_t req, fuse_ino_t parent, const char *name,
- mode_t mode)
+ mode_t mode)
{
- lo_mknod_symlink(req, parent, name, S_IFDIR | mode, 0, NULL);
+ lo_mknod_symlink(req, parent, name, S_IFDIR | mode, 0, NULL);
}
-static void lo_symlink(fuse_req_t req, const char *link,
- fuse_ino_t parent, const char *name)
+static void lo_symlink(fuse_req_t req, const char *link, fuse_ino_t parent,
+ const char *name)
{
- lo_mknod_symlink(req, parent, name, S_IFLNK, 0, link);
+ lo_mknod_symlink(req, parent, name, S_IFLNK, 0, link);
}
static int linkat_empty_nofollow(struct lo_inode *inode, int dfd,
- const char *name)
+ const char *name)
{
- int res;
- char procname[64];
+ int res;
+ char procname[64];
- if (inode->is_symlink) {
- res = linkat(inode->fd, "", dfd, name, AT_EMPTY_PATH);
- if (res == -1 && (errno == ENOENT || errno == EINVAL)) {
- /* Sorry, no race free way to hard-link a symlink. */
- errno = EPERM;
- }
- return res;
- }
+ if (inode->is_symlink) {
+ res = linkat(inode->fd, "", dfd, name, AT_EMPTY_PATH);
+ if (res == -1 && (errno == ENOENT || errno == EINVAL)) {
+ /* Sorry, no race free way to hard-link a symlink. */
+ errno = EPERM;
+ }
+ return res;
+ }
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
- return linkat(AT_FDCWD, procname, dfd, name, AT_SYMLINK_FOLLOW);
+ return linkat(AT_FDCWD, procname, dfd, name, AT_SYMLINK_FOLLOW);
}
static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
- const char *name)
+ const char *name)
{
- int res;
- struct lo_data *lo = lo_data(req);
- struct lo_inode *inode = lo_inode(req, ino);
- struct fuse_entry_param e;
- int saverr;
-
- memset(&e, 0, sizeof(struct fuse_entry_param));
- e.attr_timeout = lo->timeout;
- e.entry_timeout = lo->timeout;
-
- res = linkat_empty_nofollow(inode, lo_fd(req, parent), name);
- if (res == -1)
- goto out_err;
-
- res = fstatat(inode->fd, "", &e.attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
- if (res == -1)
- goto out_err;
-
- pthread_mutex_lock(&lo->mutex);
- inode->refcount++;
- pthread_mutex_unlock(&lo->mutex);
- e.ino = (uintptr_t) inode;
-
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
- (unsigned long long) parent, name,
- (unsigned long long) e.ino);
-
- fuse_reply_entry(req, &e);
- return;
+ int res;
+ struct lo_data *lo = lo_data(req);
+ struct lo_inode *inode = lo_inode(req, ino);
+ struct fuse_entry_param e;
+ int saverr;
+
+ memset(&e, 0, sizeof(struct fuse_entry_param));
+ e.attr_timeout = lo->timeout;
+ e.entry_timeout = lo->timeout;
+
+ res = linkat_empty_nofollow(inode, lo_fd(req, parent), name);
+ if (res == -1) {
+ goto out_err;
+ }
+
+ res = fstatat(inode->fd, "", &e.attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1) {
+ goto out_err;
+ }
+
+ pthread_mutex_lock(&lo->mutex);
+ inode->refcount++;
+ pthread_mutex_unlock(&lo->mutex);
+ e.ino = (uintptr_t)inode;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
+ (unsigned long long)parent, name, (unsigned long long)e.ino);
+ }
+
+ fuse_reply_entry(req, &e);
+ return;
out_err:
- saverr = errno;
- fuse_reply_err(req, saverr);
+ saverr = errno;
+ fuse_reply_err(req, saverr);
}
static void lo_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
{
- int res;
+ int res;
- res = unlinkat(lo_fd(req, parent), name, AT_REMOVEDIR);
+ res = unlinkat(lo_fd(req, parent), name, AT_REMOVEDIR);
- fuse_reply_err(req, res == -1 ? errno : 0);
+ fuse_reply_err(req, res == -1 ? errno : 0);
}
static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
- fuse_ino_t newparent, const char *newname,
- unsigned int flags)
+ fuse_ino_t newparent, const char *newname,
+ unsigned int flags)
{
- int res;
+ int res;
- if (flags) {
- fuse_reply_err(req, EINVAL);
- return;
- }
+ if (flags) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
- res = renameat(lo_fd(req, parent), name,
- lo_fd(req, newparent), newname);
+ res = renameat(lo_fd(req, parent), name, lo_fd(req, newparent), newname);
- fuse_reply_err(req, res == -1 ? errno : 0);
+ fuse_reply_err(req, res == -1 ? errno : 0);
}
static void lo_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
{
- int res;
+ int res;
- res = unlinkat(lo_fd(req, parent), name, 0);
+ res = unlinkat(lo_fd(req, parent), name, 0);
- fuse_reply_err(req, res == -1 ? errno : 0);
+ fuse_reply_err(req, res == -1 ? errno : 0);
}
static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n)
{
- if (!inode)
- return;
-
- pthread_mutex_lock(&lo->mutex);
- assert(inode->refcount >= n);
- inode->refcount -= n;
- if (!inode->refcount) {
- struct lo_inode *prev, *next;
-
- prev = inode->prev;
- next = inode->next;
- next->prev = prev;
- prev->next = next;
-
- pthread_mutex_unlock(&lo->mutex);
- close(inode->fd);
- free(inode);
-
- } else {
- pthread_mutex_unlock(&lo->mutex);
- }
+ if (!inode) {
+ return;
+ }
+
+ pthread_mutex_lock(&lo->mutex);
+ assert(inode->refcount >= n);
+ inode->refcount -= n;
+ if (!inode->refcount) {
+ struct lo_inode *prev, *next;
+
+ prev = inode->prev;
+ next = inode->next;
+ next->prev = prev;
+ prev->next = next;
+
+ pthread_mutex_unlock(&lo->mutex);
+ close(inode->fd);
+ free(inode);
+
+ } else {
+ pthread_mutex_unlock(&lo->mutex);
+ }
}
static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{
- struct lo_data *lo = lo_data(req);
- struct lo_inode *inode = lo_inode(req, ino);
+ struct lo_data *lo = lo_data(req);
+ struct lo_inode *inode = lo_inode(req, ino);
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",
- (unsigned long long) ino,
- (unsigned long long) inode->refcount,
- (unsigned long long) nlookup);
- }
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",
+ (unsigned long long)ino, (unsigned long long)inode->refcount,
+ (unsigned long long)nlookup);
+ }
- unref_inode(lo, inode, nlookup);
+ unref_inode(lo, inode, nlookup);
}
static void lo_forget(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{
- lo_forget_one(req, ino, nlookup);
- fuse_reply_none(req);
+ lo_forget_one(req, ino, nlookup);
+ fuse_reply_none(req);
}
static void lo_forget_multi(fuse_req_t req, size_t count,
- struct fuse_forget_data *forgets)
+ struct fuse_forget_data *forgets)
{
- int i;
+ int i;
- for (i = 0; i < count; i++)
- lo_forget_one(req, forgets[i].ino, forgets[i].nlookup);
- fuse_reply_none(req);
+ for (i = 0; i < count; i++) {
+ lo_forget_one(req, forgets[i].ino, forgets[i].nlookup);
+ }
+ fuse_reply_none(req);
}
static void lo_readlink(fuse_req_t req, fuse_ino_t ino)
{
- char buf[PATH_MAX + 1];
- int res;
+ char buf[PATH_MAX + 1];
+ int res;
- res = readlinkat(lo_fd(req, ino), "", buf, sizeof(buf));
- if (res == -1)
- return (void) fuse_reply_err(req, errno);
+ res = readlinkat(lo_fd(req, ino), "", buf, sizeof(buf));
+ if (res == -1) {
+ return (void)fuse_reply_err(req, errno);
+ }
- if (res == sizeof(buf))
- return (void) fuse_reply_err(req, ENAMETOOLONG);
+ if (res == sizeof(buf)) {
+ return (void)fuse_reply_err(req, ENAMETOOLONG);
+ }
- buf[res] = '\0';
+ buf[res] = '\0';
- fuse_reply_readlink(req, buf);
+ fuse_reply_readlink(req, buf);
}
struct lo_dirp {
- DIR *dp;
- struct dirent *entry;
- off_t offset;
+ DIR *dp;
+ struct dirent *entry;
+ off_t offset;
};
static struct lo_dirp *lo_dirp(struct fuse_file_info *fi)
{
- return (struct lo_dirp *) (uintptr_t) fi->fh;
+ return (struct lo_dirp *)(uintptr_t)fi->fh;
}
-static void lo_opendir(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
+static void lo_opendir(fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi)
{
- int error = ENOMEM;
- struct lo_data *lo = lo_data(req);
- struct lo_dirp *d;
- int fd;
-
- d = calloc(1, sizeof(struct lo_dirp));
- if (d == NULL)
- goto out_err;
-
- fd = openat(lo_fd(req, ino), ".", O_RDONLY);
- if (fd == -1)
- goto out_errno;
-
- d->dp = fdopendir(fd);
- if (d->dp == NULL)
- goto out_errno;
-
- d->offset = 0;
- d->entry = NULL;
-
- fi->fh = (uintptr_t) d;
- if (lo->cache == CACHE_ALWAYS)
- fi->keep_cache = 1;
- fuse_reply_open(req, fi);
- return;
+ int error = ENOMEM;
+ struct lo_data *lo = lo_data(req);
+ struct lo_dirp *d;
+ int fd;
+
+ d = calloc(1, sizeof(struct lo_dirp));
+ if (d == NULL) {
+ goto out_err;
+ }
+
+ fd = openat(lo_fd(req, ino), ".", O_RDONLY);
+ if (fd == -1) {
+ goto out_errno;
+ }
+
+ d->dp = fdopendir(fd);
+ if (d->dp == NULL) {
+ goto out_errno;
+ }
+
+ d->offset = 0;
+ d->entry = NULL;
+
+ fi->fh = (uintptr_t)d;
+ if (lo->cache == CACHE_ALWAYS) {
+ fi->keep_cache = 1;
+ }
+ fuse_reply_open(req, fi);
+ return;
out_errno:
- error = errno;
+ error = errno;
out_err:
- if (d) {
- if (fd != -1)
- close(fd);
- free(d);
- }
- fuse_reply_err(req, error);
+ if (d) {
+ if (fd != -1) {
+ close(fd);
+ }
+ free(d);
+ }
+ fuse_reply_err(req, error);
}
static int is_dot_or_dotdot(const char *name)
{
- return name[0] == '.' && (name[1] == '\0' ||
- (name[1] == '.' && name[2] == '\0'));
+ return name[0] == '.' &&
+ (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'));
}
static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
- off_t offset, struct fuse_file_info *fi, int plus)
+ off_t offset, struct fuse_file_info *fi, int plus)
{
- struct lo_dirp *d = lo_dirp(fi);
- char *buf;
- char *p;
- size_t rem = size;
- int err;
-
- (void) ino;
-
- buf = calloc(1, size);
- if (!buf) {
- err = ENOMEM;
- goto error;
- }
- p = buf;
-
- if (offset != d->offset) {
- seekdir(d->dp, offset);
- d->entry = NULL;
- d->offset = offset;
- }
- while (1) {
- size_t entsize;
- off_t nextoff;
- const char *name;
-
- if (!d->entry) {
- errno = 0;
- d->entry = readdir(d->dp);
- if (!d->entry) {
- if (errno) { // Error
- err = errno;
- goto error;
- } else { // End of stream
- break;
- }
- }
- }
- nextoff = d->entry->d_off;
- name = d->entry->d_name;
- fuse_ino_t entry_ino = 0;
- if (plus) {
- struct fuse_entry_param e;
- if (is_dot_or_dotdot(name)) {
- e = (struct fuse_entry_param) {
- .attr.st_ino = d->entry->d_ino,
- .attr.st_mode = d->entry->d_type << 12,
- };
- } else {
- err = lo_do_lookup(req, ino, name, &e);
- if (err)
- goto error;
- entry_ino = e.ino;
- }
-
- entsize = fuse_add_direntry_plus(req, p, rem, name,
- &e, nextoff);
- } else {
- struct stat st = {
- .st_ino = d->entry->d_ino,
- .st_mode = d->entry->d_type << 12,
- };
- entsize = fuse_add_direntry(req, p, rem, name,
- &st, nextoff);
- }
- if (entsize > rem) {
- if (entry_ino != 0)
- lo_forget_one(req, entry_ino, 1);
- break;
- }
-
- p += entsize;
- rem -= entsize;
-
- d->entry = NULL;
- d->offset = nextoff;
- }
+ struct lo_dirp *d = lo_dirp(fi);
+ char *buf;
+ char *p;
+ size_t rem = size;
+ int err;
+
+ (void)ino;
+
+ buf = calloc(1, size);
+ if (!buf) {
+ err = ENOMEM;
+ goto error;
+ }
+ p = buf;
+
+ if (offset != d->offset) {
+ seekdir(d->dp, offset);
+ d->entry = NULL;
+ d->offset = offset;
+ }
+ while (1) {
+ size_t entsize;
+ off_t nextoff;
+ const char *name;
+
+ if (!d->entry) {
+ errno = 0;
+ d->entry = readdir(d->dp);
+ if (!d->entry) {
+ if (errno) { /* Error */
+ err = errno;
+ goto error;
+ } else { /* End of stream */
+ break;
+ }
+ }
+ }
+ nextoff = d->entry->d_off;
+ name = d->entry->d_name;
+ fuse_ino_t entry_ino = 0;
+ if (plus) {
+ struct fuse_entry_param e;
+ if (is_dot_or_dotdot(name)) {
+ e = (struct fuse_entry_param){
+ .attr.st_ino = d->entry->d_ino,
+ .attr.st_mode = d->entry->d_type << 12,
+ };
+ } else {
+ err = lo_do_lookup(req, ino, name, &e);
+ if (err) {
+ goto error;
+ }
+ entry_ino = e.ino;
+ }
+
+ entsize = fuse_add_direntry_plus(req, p, rem, name, &e, nextoff);
+ } else {
+ struct stat st = {
+ .st_ino = d->entry->d_ino,
+ .st_mode = d->entry->d_type << 12,
+ };
+ entsize = fuse_add_direntry(req, p, rem, name, &st, nextoff);
+ }
+ if (entsize > rem) {
+ if (entry_ino != 0) {
+ lo_forget_one(req, entry_ino, 1);
+ }
+ break;
+ }
+
+ p += entsize;
+ rem -= entsize;
+
+ d->entry = NULL;
+ d->offset = nextoff;
+ }
err = 0;
error:
- // If there's an error, we can only signal it if we haven't stored
- // any entries yet - otherwise we'd end up with wrong lookup
- // counts for the entries that are already in the buffer. So we
- // return what we've collected until that point.
- if (err && rem == size)
- fuse_reply_err(req, err);
- else
- fuse_reply_buf(req, buf, size - rem);
+ /*
+ * If there's an error, we can only signal it if we haven't stored
+ * any entries yet - otherwise we'd end up with wrong lookup
+ * counts for the entries that are already in the buffer. So we
+ * return what we've collected until that point.
+ */
+ if (err && rem == size) {
+ fuse_reply_err(req, err);
+ } else {
+ fuse_reply_buf(req, buf, size - rem);
+ }
free(buf);
}
static void lo_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
- off_t offset, struct fuse_file_info *fi)
+ off_t offset, struct fuse_file_info *fi)
{
- lo_do_readdir(req, ino, size, offset, fi, 0);
+ lo_do_readdir(req, ino, size, offset, fi, 0);
}
static void lo_readdirplus(fuse_req_t req, fuse_ino_t ino, size_t size,
- off_t offset, struct fuse_file_info *fi)
+ off_t offset, struct fuse_file_info *fi)
{
- lo_do_readdir(req, ino, size, offset, fi, 1);
+ lo_do_readdir(req, ino, size, offset, fi, 1);
}
-static void lo_releasedir(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
+static void lo_releasedir(fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi)
{
- struct lo_dirp *d = lo_dirp(fi);
- (void) ino;
- closedir(d->dp);
- free(d);
- fuse_reply_err(req, 0);
+ struct lo_dirp *d = lo_dirp(fi);
+ (void)ino;
+ closedir(d->dp);
+ free(d);
+ fuse_reply_err(req, 0);
}
static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
- mode_t mode, struct fuse_file_info *fi)
+ mode_t mode, struct fuse_file_info *fi)
{
- int fd;
- struct lo_data *lo = lo_data(req);
- struct fuse_entry_param e;
- int err;
-
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, "lo_create(parent=%" PRIu64 ", name=%s)\n",
- parent, name);
-
- fd = openat(lo_fd(req, parent), name,
- (fi->flags | O_CREAT) & ~O_NOFOLLOW, mode);
- if (fd == -1)
- return (void) fuse_reply_err(req, errno);
-
- fi->fh = fd;
- if (lo->cache == CACHE_NEVER)
- fi->direct_io = 1;
- else if (lo->cache == CACHE_ALWAYS)
- fi->keep_cache = 1;
-
- err = lo_do_lookup(req, parent, name, &e);
- if (err)
- fuse_reply_err(req, err);
- else
- fuse_reply_create(req, &e, fi);
+ int fd;
+ struct lo_data *lo = lo_data(req);
+ struct fuse_entry_param e;
+ int err;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_create(parent=%" PRIu64 ", name=%s)\n",
+ parent, name);
+ }
+
+ fd = openat(lo_fd(req, parent), name, (fi->flags | O_CREAT) & ~O_NOFOLLOW,
+ mode);
+ if (fd == -1) {
+ return (void)fuse_reply_err(req, errno);
+ }
+
+ fi->fh = fd;
+ if (lo->cache == CACHE_NEVER) {
+ fi->direct_io = 1;
+ } else if (lo->cache == CACHE_ALWAYS) {
+ fi->keep_cache = 1;
+ }
+
+ err = lo_do_lookup(req, parent, name, &e);
+ if (err) {
+ fuse_reply_err(req, err);
+ } else {
+ fuse_reply_create(req, &e, fi);
+ }
}
static void lo_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync,
- struct fuse_file_info *fi)
+ struct fuse_file_info *fi)
{
- int res;
- int fd = dirfd(lo_dirp(fi)->dp);
- (void) ino;
- if (datasync)
- res = fdatasync(fd);
- else
- res = fsync(fd);
- fuse_reply_err(req, res == -1 ? errno : 0);
+ int res;
+ int fd = dirfd(lo_dirp(fi)->dp);
+ (void)ino;
+ if (datasync) {
+ res = fdatasync(fd);
+ } else {
+ res = fsync(fd);
+ }
+ fuse_reply_err(req, res == -1 ? errno : 0);
}
static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
- int fd;
- char buf[64];
- struct lo_data *lo = lo_data(req);
-
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, "lo_open(ino=%" PRIu64 ", flags=%d)\n",
- ino, fi->flags);
-
- /* With writeback cache, kernel may send read requests even
- when userspace opened write-only */
- if (lo->writeback && (fi->flags & O_ACCMODE) == O_WRONLY) {
- fi->flags &= ~O_ACCMODE;
- fi->flags |= O_RDWR;
- }
-
- /* With writeback cache, O_APPEND is handled by the kernel.
- This breaks atomicity (since the file may change in the
- underlying filesystem, so that the kernel's idea of the
- end of the file isn't accurate anymore). In this example,
- we just accept that. A more rigorous filesystem may want
- to return an error here */
- if (lo->writeback && (fi->flags & O_APPEND))
- fi->flags &= ~O_APPEND;
-
- sprintf(buf, "/proc/self/fd/%i", lo_fd(req, ino));
- fd = open(buf, fi->flags & ~O_NOFOLLOW);
- if (fd == -1)
- return (void) fuse_reply_err(req, errno);
-
- fi->fh = fd;
- if (lo->cache == CACHE_NEVER)
- fi->direct_io = 1;
- else if (lo->cache == CACHE_ALWAYS)
- fi->keep_cache = 1;
- fuse_reply_open(req, fi);
+ int fd;
+ char buf[64];
+ struct lo_data *lo = lo_data(req);
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_open(ino=%" PRIu64 ", flags=%d)\n", ino,
+ fi->flags);
+ }
+
+ /*
+ * With writeback cache, kernel may send read requests even
+ * when userspace opened write-only
+ */
+ if (lo->writeback && (fi->flags & O_ACCMODE) == O_WRONLY) {
+ fi->flags &= ~O_ACCMODE;
+ fi->flags |= O_RDWR;
+ }
+
+ /*
+ * With writeback cache, O_APPEND is handled by the kernel.
+ * This breaks atomicity (since the file may change in the
+ * underlying filesystem, so that the kernel's idea of the
+ * end of the file isn't accurate anymore). In this example,
+ * we just accept that. A more rigorous filesystem may want
+ * to return an error here
+ */
+ if (lo->writeback && (fi->flags & O_APPEND)) {
+ fi->flags &= ~O_APPEND;
+ }
+
+ sprintf(buf, "/proc/self/fd/%i", lo_fd(req, ino));
+ fd = open(buf, fi->flags & ~O_NOFOLLOW);
+ if (fd == -1) {
+ return (void)fuse_reply_err(req, errno);
+ }
+
+ fi->fh = fd;
+ if (lo->cache == CACHE_NEVER) {
+ fi->direct_io = 1;
+ } else if (lo->cache == CACHE_ALWAYS) {
+ fi->keep_cache = 1;
+ }
+ fuse_reply_open(req, fi);
}
-static void lo_release(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
+static void lo_release(fuse_req_t req, fuse_ino_t ino,
+ struct fuse_file_info *fi)
{
- (void) ino;
+ (void)ino;
- close(fi->fh);
- fuse_reply_err(req, 0);
+ close(fi->fh);
+ fuse_reply_err(req, 0);
}
static void lo_flush(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
- int res;
- (void) ino;
- res = close(dup(fi->fh));
- fuse_reply_err(req, res == -1 ? errno : 0);
+ int res;
+ (void)ino;
+ res = close(dup(fi->fh));
+ fuse_reply_err(req, res == -1 ? errno : 0);
}
static void lo_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
- struct fuse_file_info *fi)
+ struct fuse_file_info *fi)
{
- int res;
- (void) ino;
- if (datasync)
- res = fdatasync(fi->fh);
- else
- res = fsync(fi->fh);
- fuse_reply_err(req, res == -1 ? errno : 0);
+ int res;
+ (void)ino;
+ if (datasync) {
+ res = fdatasync(fi->fh);
+ } else {
+ res = fsync(fi->fh);
+ }
+ fuse_reply_err(req, res == -1 ? errno : 0);
}
-static void lo_read(fuse_req_t req, fuse_ino_t ino, size_t size,
- off_t offset, struct fuse_file_info *fi)
+static void lo_read(fuse_req_t req, fuse_ino_t ino, size_t size, off_t offset,
+ struct fuse_file_info *fi)
{
- struct fuse_bufvec buf = FUSE_BUFVEC_INIT(size);
+ struct fuse_bufvec buf = FUSE_BUFVEC_INIT(size);
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, "lo_read(ino=%" PRIu64 ", size=%zd, "
- "off=%lu)\n", ino, size, (unsigned long) offset);
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_read(ino=%" PRIu64 ", size=%zd, "
+ "off=%lu)\n",
+ ino, size, (unsigned long)offset);
+ }
- buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
- buf.buf[0].fd = fi->fh;
- buf.buf[0].pos = offset;
+ buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
+ buf.buf[0].fd = fi->fh;
+ buf.buf[0].pos = offset;
- fuse_reply_data(req, &buf, FUSE_BUF_SPLICE_MOVE);
+ fuse_reply_data(req, &buf, FUSE_BUF_SPLICE_MOVE);
}
static void lo_write_buf(fuse_req_t req, fuse_ino_t ino,
- struct fuse_bufvec *in_buf, off_t off,
- struct fuse_file_info *fi)
+ struct fuse_bufvec *in_buf, off_t off,
+ struct fuse_file_info *fi)
{
- (void) ino;
- ssize_t res;
- struct fuse_bufvec out_buf = FUSE_BUFVEC_INIT(fuse_buf_size(in_buf));
-
- out_buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
- out_buf.buf[0].fd = fi->fh;
- out_buf.buf[0].pos = off;
-
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, "lo_write(ino=%" PRIu64 ", size=%zd, off=%lu)\n",
- ino, out_buf.buf[0].size, (unsigned long) off);
-
- res = fuse_buf_copy(&out_buf, in_buf, 0);
- if(res < 0)
- fuse_reply_err(req, -res);
- else
- fuse_reply_write(req, (size_t) res);
+ (void)ino;
+ ssize_t res;
+ struct fuse_bufvec out_buf = FUSE_BUFVEC_INIT(fuse_buf_size(in_buf));
+
+ out_buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
+ out_buf.buf[0].fd = fi->fh;
+ out_buf.buf[0].pos = off;
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_write(ino=%" PRIu64 ", size=%zd, off=%lu)\n", ino,
+ out_buf.buf[0].size, (unsigned long)off);
+ }
+
+ res = fuse_buf_copy(&out_buf, in_buf, 0);
+ if (res < 0) {
+ fuse_reply_err(req, -res);
+ } else {
+ fuse_reply_write(req, (size_t)res);
+ }
}
static void lo_statfs(fuse_req_t req, fuse_ino_t ino)
{
- int res;
- struct statvfs stbuf;
-
- res = fstatvfs(lo_fd(req, ino), &stbuf);
- if (res == -1)
- fuse_reply_err(req, errno);
- else
- fuse_reply_statfs(req, &stbuf);
+ int res;
+ struct statvfs stbuf;
+
+ res = fstatvfs(lo_fd(req, ino), &stbuf);
+ if (res == -1) {
+ fuse_reply_err(req, errno);
+ } else {
+ fuse_reply_statfs(req, &stbuf);
+ }
}
-static void lo_fallocate(fuse_req_t req, fuse_ino_t ino, int mode,
- off_t offset, off_t length, struct fuse_file_info *fi)
+static void lo_fallocate(fuse_req_t req, fuse_ino_t ino, int mode, off_t offset,
+ off_t length, struct fuse_file_info *fi)
{
- int err = EOPNOTSUPP;
- (void) ino;
+ int err = EOPNOTSUPP;
+ (void)ino;
#ifdef HAVE_FALLOCATE
- err = fallocate(fi->fh, mode, offset, length);
- if (err < 0)
- err = errno;
+ err = fallocate(fi->fh, mode, offset, length);
+ if (err < 0) {
+ err = errno;
+ }
#elif defined(HAVE_POSIX_FALLOCATE)
- if (mode) {
- fuse_reply_err(req, EOPNOTSUPP);
- return;
- }
+ if (mode) {
+ fuse_reply_err(req, EOPNOTSUPP);
+ return;
+ }
- err = posix_fallocate(fi->fh, offset, length);
+ err = posix_fallocate(fi->fh, offset, length);
#endif
- fuse_reply_err(req, err);
+ fuse_reply_err(req, err);
}
static void lo_flock(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
- int op)
+ int op)
{
- int res;
- (void) ino;
+ int res;
+ (void)ino;
- res = flock(fi->fh, op);
+ res = flock(fi->fh, op);
- fuse_reply_err(req, res == -1 ? errno : 0);
+ fuse_reply_err(req, res == -1 ? errno : 0);
}
static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
- size_t size)
+ size_t size)
{
- char *value = NULL;
- char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
- ssize_t ret;
- int saverr;
-
- saverr = ENOSYS;
- if (!lo_data(req)->xattr)
- goto out;
-
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_getxattr(ino=%" PRIu64 ", name=%s size=%zd)\n",
- ino, name, size);
- }
-
- if (inode->is_symlink) {
- /* Sorry, no race free way to getxattr on symlink. */
- saverr = EPERM;
- goto out;
- }
-
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
-
- if (size) {
- value = malloc(size);
- if (!value)
- goto out_err;
-
- ret = getxattr(procname, name, value, size);
- if (ret == -1)
- goto out_err;
- saverr = 0;
- if (ret == 0)
- goto out;
-
- fuse_reply_buf(req, value, ret);
- } else {
- ret = getxattr(procname, name, NULL, 0);
- if (ret == -1)
- goto out_err;
-
- fuse_reply_xattr(req, ret);
- }
+ char *value = NULL;
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ ssize_t ret;
+ int saverr;
+
+ saverr = ENOSYS;
+ if (!lo_data(req)->xattr) {
+ goto out;
+ }
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_getxattr(ino=%" PRIu64 ", name=%s size=%zd)\n", ino, name,
+ size);
+ }
+
+ if (inode->is_symlink) {
+ /* Sorry, no race free way to getxattr on symlink. */
+ saverr = EPERM;
+ goto out;
+ }
+
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ if (size) {
+ value = malloc(size);
+ if (!value) {
+ goto out_err;
+ }
+
+ ret = getxattr(procname, name, value, size);
+ if (ret == -1) {
+ goto out_err;
+ }
+ saverr = 0;
+ if (ret == 0) {
+ goto out;
+ }
+
+ fuse_reply_buf(req, value, ret);
+ } else {
+ ret = getxattr(procname, name, NULL, 0);
+ if (ret == -1) {
+ goto out_err;
+ }
+
+ fuse_reply_xattr(req, ret);
+ }
out_free:
- free(value);
- return;
+ free(value);
+ return;
out_err:
- saverr = errno;
+ saverr = errno;
out:
- fuse_reply_err(req, saverr);
- goto out_free;
+ fuse_reply_err(req, saverr);
+ goto out_free;
}
static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
{
- char *value = NULL;
- char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
- ssize_t ret;
- int saverr;
-
- saverr = ENOSYS;
- if (!lo_data(req)->xattr)
- goto out;
-
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_listxattr(ino=%" PRIu64 ", size=%zd)\n",
- ino, size);
- }
-
- if (inode->is_symlink) {
- /* Sorry, no race free way to listxattr on symlink. */
- saverr = EPERM;
- goto out;
- }
-
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
-
- if (size) {
- value = malloc(size);
- if (!value)
- goto out_err;
-
- ret = listxattr(procname, value, size);
- if (ret == -1)
- goto out_err;
- saverr = 0;
- if (ret == 0)
- goto out;
-
- fuse_reply_buf(req, value, ret);
- } else {
- ret = listxattr(procname, NULL, 0);
- if (ret == -1)
- goto out_err;
-
- fuse_reply_xattr(req, ret);
- }
+ char *value = NULL;
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ ssize_t ret;
+ int saverr;
+
+ saverr = ENOSYS;
+ if (!lo_data(req)->xattr) {
+ goto out;
+ }
+
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_listxattr(ino=%" PRIu64 ", size=%zd)\n",
+ ino, size);
+ }
+
+ if (inode->is_symlink) {
+ /* Sorry, no race free way to listxattr on symlink. */
+ saverr = EPERM;
+ goto out;
+ }
+
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ if (size) {
+ value = malloc(size);
+ if (!value) {
+ goto out_err;
+ }
+
+ ret = listxattr(procname, value, size);
+ if (ret == -1) {
+ goto out_err;
+ }
+ saverr = 0;
+ if (ret == 0) {
+ goto out;
+ }
+
+ fuse_reply_buf(req, value, ret);
+ } else {
+ ret = listxattr(procname, NULL, 0);
+ if (ret == -1) {
+ goto out_err;
+ }
+
+ fuse_reply_xattr(req, ret);
+ }
out_free:
- free(value);
- return;
+ free(value);
+ return;
out_err:
- saverr = errno;
+ saverr = errno;
out:
- fuse_reply_err(req, saverr);
- goto out_free;
+ fuse_reply_err(req, saverr);
+ goto out_free;
}
static void lo_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
- const char *value, size_t size, int flags)
+ const char *value, size_t size, int flags)
{
- char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
- ssize_t ret;
- int saverr;
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ ssize_t ret;
+ int saverr;
- saverr = ENOSYS;
- if (!lo_data(req)->xattr)
- goto out;
+ saverr = ENOSYS;
+ if (!lo_data(req)->xattr) {
+ goto out;
+ }
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_setxattr(ino=%" PRIu64 ", name=%s value=%s size=%zd)\n",
- ino, name, value, size);
- }
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_setxattr(ino=%" PRIu64 ", name=%s value=%s size=%zd)\n",
+ ino, name, value, size);
+ }
- if (inode->is_symlink) {
- /* Sorry, no race free way to setxattr on symlink. */
- saverr = EPERM;
- goto out;
- }
+ if (inode->is_symlink) {
+ /* Sorry, no race free way to setxattr on symlink. */
+ saverr = EPERM;
+ goto out;
+ }
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
- ret = setxattr(procname, name, value, size, flags);
- saverr = ret == -1 ? errno : 0;
+ ret = setxattr(procname, name, value, size, flags);
+ saverr = ret == -1 ? errno : 0;
out:
- fuse_reply_err(req, saverr);
+ fuse_reply_err(req, saverr);
}
static void lo_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name)
{
- char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
- ssize_t ret;
- int saverr;
+ char procname[64];
+ struct lo_inode *inode = lo_inode(req, ino);
+ ssize_t ret;
+ int saverr;
- saverr = ENOSYS;
- if (!lo_data(req)->xattr)
- goto out;
+ saverr = ENOSYS;
+ if (!lo_data(req)->xattr) {
+ goto out;
+ }
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_removexattr(ino=%" PRIu64 ", name=%s)\n",
- ino, name);
- }
+ if (lo_debug(req)) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_removexattr(ino=%" PRIu64 ", name=%s)\n",
+ ino, name);
+ }
- if (inode->is_symlink) {
- /* Sorry, no race free way to setxattr on symlink. */
- saverr = EPERM;
- goto out;
- }
+ if (inode->is_symlink) {
+ /* Sorry, no race free way to setxattr on symlink. */
+ saverr = EPERM;
+ goto out;
+ }
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
- ret = removexattr(procname, name);
- saverr = ret == -1 ? errno : 0;
+ ret = removexattr(procname, name);
+ saverr = ret == -1 ? errno : 0;
out:
- fuse_reply_err(req, saverr);
+ fuse_reply_err(req, saverr);
}
#ifdef HAVE_COPY_FILE_RANGE
static void lo_copy_file_range(fuse_req_t req, fuse_ino_t ino_in, off_t off_in,
- struct fuse_file_info *fi_in,
- fuse_ino_t ino_out, off_t off_out,
- struct fuse_file_info *fi_out, size_t len,
- int flags)
+ struct fuse_file_info *fi_in, fuse_ino_t ino_out,
+ off_t off_out, struct fuse_file_info *fi_out,
+ size_t len, int flags)
{
- ssize_t res;
-
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG, "lo_copy_file_range(ino=%" PRIu64 "/fd=%lu, "
- "off=%lu, ino=%" PRIu64 "/fd=%lu, "
- "off=%lu, size=%zd, flags=0x%x)\n",
- ino_in, fi_in->fh, off_in, ino_out, fi_out->fh, off_out,
- len, flags);
-
- res = copy_file_range(fi_in->fh, &off_in, fi_out->fh, &off_out, len,
- flags);
- if (res < 0)
- fuse_reply_err(req, -errno);
- else
- fuse_reply_write(req, res);
+ ssize_t res;
+
+ if (lo_debug(req))
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_copy_file_range(ino=%" PRIu64 "/fd=%lu, "
+ "off=%lu, ino=%" PRIu64 "/fd=%lu, "
+ "off=%lu, size=%zd, flags=0x%x)\n",
+ ino_in, fi_in->fh, off_in, ino_out, fi_out->fh, off_out, len,
+ flags);
+
+ res = copy_file_range(fi_in->fh, &off_in, fi_out->fh, &off_out, len, flags);
+ if (res < 0) {
+ fuse_reply_err(req, -errno);
+ } else {
+ fuse_reply_write(req, res);
+ }
}
#endif
static void lo_lseek(fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
- struct fuse_file_info *fi)
+ struct fuse_file_info *fi)
{
- off_t res;
-
- (void)ino;
- res = lseek(fi->fh, off, whence);
- if (res != -1)
- fuse_reply_lseek(req, res);
- else
- fuse_reply_err(req, errno);
+ off_t res;
+
+ (void)ino;
+ res = lseek(fi->fh, off, whence);
+ if (res != -1) {
+ fuse_reply_lseek(req, res);
+ } else {
+ fuse_reply_err(req, errno);
+ }
}
static struct fuse_lowlevel_ops lo_oper = {
- .init = lo_init,
- .lookup = lo_lookup,
- .mkdir = lo_mkdir,
- .mknod = lo_mknod,
- .symlink = lo_symlink,
- .link = lo_link,
- .unlink = lo_unlink,
- .rmdir = lo_rmdir,
- .rename = lo_rename,
- .forget = lo_forget,
- .forget_multi = lo_forget_multi,
- .getattr = lo_getattr,
- .setattr = lo_setattr,
- .readlink = lo_readlink,
- .opendir = lo_opendir,
- .readdir = lo_readdir,
- .readdirplus = lo_readdirplus,
- .releasedir = lo_releasedir,
- .fsyncdir = lo_fsyncdir,
- .create = lo_create,
- .open = lo_open,
- .release = lo_release,
- .flush = lo_flush,
- .fsync = lo_fsync,
- .read = lo_read,
- .write_buf = lo_write_buf,
- .statfs = lo_statfs,
- .fallocate = lo_fallocate,
- .flock = lo_flock,
- .getxattr = lo_getxattr,
- .listxattr = lo_listxattr,
- .setxattr = lo_setxattr,
- .removexattr = lo_removexattr,
+ .init = lo_init,
+ .lookup = lo_lookup,
+ .mkdir = lo_mkdir,
+ .mknod = lo_mknod,
+ .symlink = lo_symlink,
+ .link = lo_link,
+ .unlink = lo_unlink,
+ .rmdir = lo_rmdir,
+ .rename = lo_rename,
+ .forget = lo_forget,
+ .forget_multi = lo_forget_multi,
+ .getattr = lo_getattr,
+ .setattr = lo_setattr,
+ .readlink = lo_readlink,
+ .opendir = lo_opendir,
+ .readdir = lo_readdir,
+ .readdirplus = lo_readdirplus,
+ .releasedir = lo_releasedir,
+ .fsyncdir = lo_fsyncdir,
+ .create = lo_create,
+ .open = lo_open,
+ .release = lo_release,
+ .flush = lo_flush,
+ .fsync = lo_fsync,
+ .read = lo_read,
+ .write_buf = lo_write_buf,
+ .statfs = lo_statfs,
+ .fallocate = lo_fallocate,
+ .flock = lo_flock,
+ .getxattr = lo_getxattr,
+ .listxattr = lo_listxattr,
+ .setxattr = lo_setxattr,
+ .removexattr = lo_removexattr,
#ifdef HAVE_COPY_FILE_RANGE
- .copy_file_range = lo_copy_file_range,
+ .copy_file_range = lo_copy_file_range,
#endif
- .lseek = lo_lseek,
+ .lseek = lo_lseek,
};
int main(int argc, char *argv[])
{
- struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
- struct fuse_session *se;
- struct fuse_cmdline_opts opts;
- struct lo_data lo = { .debug = 0,
- .writeback = 0 };
- int ret = -1;
-
- /* Don't mask creation mode, kernel already did that */
- umask(0);
-
- pthread_mutex_init(&lo.mutex, NULL);
- lo.root.next = lo.root.prev = &lo.root;
- lo.root.fd = -1;
- lo.cache = CACHE_NORMAL;
-
- if (fuse_parse_cmdline(&args, &opts) != 0)
- return 1;
- if (opts.show_help) {
- printf("usage: %s [options] <mountpoint>\n\n", argv[0]);
- fuse_cmdline_help();
- fuse_lowlevel_help();
- ret = 0;
- goto err_out1;
- } else if (opts.show_version) {
- fuse_lowlevel_version();
- ret = 0;
- goto err_out1;
- }
-
- if(opts.mountpoint == NULL) {
- printf("usage: %s [options] <mountpoint>\n", argv[0]);
- printf(" %s --help\n", argv[0]);
- ret = 1;
- goto err_out1;
- }
-
- if (fuse_opt_parse(&args, &lo, lo_opts, NULL)== -1)
- return 1;
-
- lo.debug = opts.debug;
- lo.root.refcount = 2;
- if (lo.source) {
- struct stat stat;
- int res;
-
- res = lstat(lo.source, &stat);
- if (res == -1) {
- fuse_log(FUSE_LOG_ERR, "failed to stat source (\"%s\"): %m\n",
- lo.source);
- exit(1);
- }
- if (!S_ISDIR(stat.st_mode)) {
- fuse_log(FUSE_LOG_ERR, "source is not a directory\n");
- exit(1);
- }
-
- } else {
- lo.source = "/";
- }
- lo.root.is_symlink = false;
- if (!lo.timeout_set) {
- switch (lo.cache) {
- case CACHE_NEVER:
- lo.timeout = 0.0;
- break;
-
- case CACHE_NORMAL:
- lo.timeout = 1.0;
- break;
-
- case CACHE_ALWAYS:
- lo.timeout = 86400.0;
- break;
- }
- } else if (lo.timeout < 0) {
- fuse_log(FUSE_LOG_ERR, "timeout is negative (%lf)\n",
- lo.timeout);
- exit(1);
- }
-
- lo.root.fd = open(lo.source, O_PATH);
- if (lo.root.fd == -1) {
- fuse_log(FUSE_LOG_ERR, "open(\"%s\", O_PATH): %m\n",
- lo.source);
- exit(1);
- }
-
- se = fuse_session_new(&args, &lo_oper, sizeof(lo_oper), &lo);
- if (se == NULL)
- goto err_out1;
-
- if (fuse_set_signal_handlers(se) != 0)
- goto err_out2;
-
- if (fuse_session_mount(se, opts.mountpoint) != 0)
- goto err_out3;
-
- fuse_daemonize(opts.foreground);
-
- /* Block until ctrl+c or fusermount -u */
- if (opts.singlethread)
- ret = fuse_session_loop(se);
- else
- ret = fuse_session_loop_mt(se, opts.clone_fd);
-
- fuse_session_unmount(se);
+ struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
+ struct fuse_session *se;
+ struct fuse_cmdline_opts opts;
+ struct lo_data lo = { .debug = 0, .writeback = 0 };
+ int ret = -1;
+
+ /* Don't mask creation mode, kernel already did that */
+ umask(0);
+
+ pthread_mutex_init(&lo.mutex, NULL);
+ lo.root.next = lo.root.prev = &lo.root;
+ lo.root.fd = -1;
+ lo.cache = CACHE_NORMAL;
+
+ if (fuse_parse_cmdline(&args, &opts) != 0) {
+ return 1;
+ }
+ if (opts.show_help) {
+ printf("usage: %s [options] <mountpoint>\n\n", argv[0]);
+ fuse_cmdline_help();
+ fuse_lowlevel_help();
+ ret = 0;
+ goto err_out1;
+ } else if (opts.show_version) {
+ fuse_lowlevel_version();
+ ret = 0;
+ goto err_out1;
+ }
+
+ if (opts.mountpoint == NULL) {
+ printf("usage: %s [options] <mountpoint>\n", argv[0]);
+ printf(" %s --help\n", argv[0]);
+ ret = 1;
+ goto err_out1;
+ }
+
+ if (fuse_opt_parse(&args, &lo, lo_opts, NULL) == -1) {
+ return 1;
+ }
+
+ lo.debug = opts.debug;
+ lo.root.refcount = 2;
+ if (lo.source) {
+ struct stat stat;
+ int res;
+
+ res = lstat(lo.source, &stat);
+ if (res == -1) {
+ fuse_log(FUSE_LOG_ERR, "failed to stat source (\"%s\"): %m\n",
+ lo.source);
+ exit(1);
+ }
+ if (!S_ISDIR(stat.st_mode)) {
+ fuse_log(FUSE_LOG_ERR, "source is not a directory\n");
+ exit(1);
+ }
+
+ } else {
+ lo.source = "/";
+ }
+ lo.root.is_symlink = false;
+ if (!lo.timeout_set) {
+ switch (lo.cache) {
+ case CACHE_NEVER:
+ lo.timeout = 0.0;
+ break;
+
+ case CACHE_NORMAL:
+ lo.timeout = 1.0;
+ break;
+
+ case CACHE_ALWAYS:
+ lo.timeout = 86400.0;
+ break;
+ }
+ } else if (lo.timeout < 0) {
+ fuse_log(FUSE_LOG_ERR, "timeout is negative (%lf)\n", lo.timeout);
+ exit(1);
+ }
+
+ lo.root.fd = open(lo.source, O_PATH);
+ if (lo.root.fd == -1) {
+ fuse_log(FUSE_LOG_ERR, "open(\"%s\", O_PATH): %m\n", lo.source);
+ exit(1);
+ }
+
+ se = fuse_session_new(&args, &lo_oper, sizeof(lo_oper), &lo);
+ if (se == NULL) {
+ goto err_out1;
+ }
+
+ if (fuse_set_signal_handlers(se) != 0) {
+ goto err_out2;
+ }
+
+ if (fuse_session_mount(se, opts.mountpoint) != 0) {
+ goto err_out3;
+ }
+
+ fuse_daemonize(opts.foreground);
+
+ /* Block until ctrl+c or fusermount -u */
+ if (opts.singlethread) {
+ ret = fuse_session_loop(se);
+ } else {
+ ret = fuse_session_loop_mt(se, opts.clone_fd);
+ }
+
+ fuse_session_unmount(se);
err_out3:
- fuse_remove_signal_handlers(se);
+ fuse_remove_signal_handlers(se);
err_out2:
- fuse_session_destroy(se);
+ fuse_session_destroy(se);
err_out1:
- free(opts.mountpoint);
- fuse_opt_free_args(&args);
+ free(opts.mountpoint);
+ fuse_opt_free_args(&args);
- if (lo.root.fd >= 0)
- close(lo.root.fd);
+ if (lo.root.fd >= 0) {
+ close(lo.root.fd);
+ }
- return ret ? 1 : 0;
+ return ret ? 1 : 0;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 008/108] virtiofsd: remove mountpoint dummy argument
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (6 preceding siblings ...)
2020-01-23 16:44 ` [PULL 007/108] virtiofsd: Format imported files to qemu style Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 009/108] virtiofsd: remove unused notify reply support Dr. David Alan Gilbert (git)
` (101 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Classic FUSE file system daemons take a mountpoint argument but
virtiofsd exposes a vhost-user UNIX domain socket instead. The
mountpoint argument is not used by virtiofsd but the user is still
required to pass a dummy argument on the command-line.
Remove the mountpoint argument to clean up the command-line.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 2 +-
tools/virtiofsd/fuse_lowlevel.h | 4 +---
tools/virtiofsd/helper.c | 20 +++-----------------
tools/virtiofsd/passthrough_ll.c | 12 ++----------
4 files changed, 7 insertions(+), 31 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 5c9cb52f2a..2f32c68161 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2455,7 +2455,7 @@ out1:
return NULL;
}
-int fuse_session_mount(struct fuse_session *se, const char *mountpoint)
+int fuse_session_mount(struct fuse_session *se)
{
int fd;
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index adb9054bb1..8d8909b35d 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -1863,7 +1863,6 @@ struct fuse_cmdline_opts {
int foreground;
int debug;
int nodefault_subtype;
- char *mountpoint;
int show_version;
int show_help;
unsigned int max_idle_threads;
@@ -1924,12 +1923,11 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
/**
* Mount a FUSE file system.
*
- * @param mountpoint the mount point path
* @param se session object
*
* @return 0 on success, -1 on failure.
**/
-int fuse_session_mount(struct fuse_session *se, const char *mountpoint);
+int fuse_session_mount(struct fuse_session *se);
/**
* Enter a single threaded, blocking event loop.
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 5711dd2660..5e6f2051a7 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -140,27 +140,13 @@ void fuse_cmdline_help(void)
static int fuse_helper_opt_proc(void *data, const char *arg, int key,
struct fuse_args *outargs)
{
+ (void)data;
(void)outargs;
- struct fuse_cmdline_opts *opts = data;
switch (key) {
case FUSE_OPT_KEY_NONOPT:
- if (!opts->mountpoint) {
- if (fuse_mnt_parse_fuse_fd(arg) != -1) {
- return fuse_opt_add_opt(&opts->mountpoint, arg);
- }
-
- char mountpoint[PATH_MAX] = "";
- if (realpath(arg, mountpoint) == NULL) {
- fuse_log(FUSE_LOG_ERR, "fuse: bad mount point `%s': %s\n", arg,
- strerror(errno));
- return -1;
- }
- return fuse_opt_add_opt(&opts->mountpoint, mountpoint);
- } else {
- fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
- return -1;
- }
+ fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
+ return -1;
default:
/* Pass through unknown options */
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index c5850ef803..9377718d9d 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1297,7 +1297,7 @@ int main(int argc, char *argv[])
return 1;
}
if (opts.show_help) {
- printf("usage: %s [options] <mountpoint>\n\n", argv[0]);
+ printf("usage: %s [options]\n\n", argv[0]);
fuse_cmdline_help();
fuse_lowlevel_help();
ret = 0;
@@ -1308,13 +1308,6 @@ int main(int argc, char *argv[])
goto err_out1;
}
- if (opts.mountpoint == NULL) {
- printf("usage: %s [options] <mountpoint>\n", argv[0]);
- printf(" %s --help\n", argv[0]);
- ret = 1;
- goto err_out1;
- }
-
if (fuse_opt_parse(&args, &lo, lo_opts, NULL) == -1) {
return 1;
}
@@ -1374,7 +1367,7 @@ int main(int argc, char *argv[])
goto err_out2;
}
- if (fuse_session_mount(se, opts.mountpoint) != 0) {
+ if (fuse_session_mount(se) != 0) {
goto err_out3;
}
@@ -1393,7 +1386,6 @@ err_out3:
err_out2:
fuse_session_destroy(se);
err_out1:
- free(opts.mountpoint);
fuse_opt_free_args(&args);
if (lo.root.fd >= 0) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 009/108] virtiofsd: remove unused notify reply support
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (7 preceding siblings ...)
2020-01-23 16:44 ` [PULL 008/108] virtiofsd: remove mountpoint dummy argument Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 010/108] virtiofsd: Remove unused enum fuse_buf_copy_flags Dr. David Alan Gilbert (git)
` (100 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Notify reply support is unused by virtiofsd. The code would need to be
updated to validate input buffer sizes. Remove this unused code since
changes to it are untestable.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 147 +-------------------------------
tools/virtiofsd/fuse_lowlevel.h | 47 ----------
2 files changed, 1 insertion(+), 193 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 2f32c68161..eb0ec49d38 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -31,12 +31,6 @@
#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;
@@ -1862,52 +1856,6 @@ static void do_destroy(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
send_reply_ok(req, NULL, 0);
}
-static void list_del_nreq(struct fuse_notify_req *nreq)
-{
- struct fuse_notify_req *prev = nreq->prev;
- struct fuse_notify_req *next = nreq->next;
- prev->next = next;
- next->prev = prev;
-}
-
-static void list_add_nreq(struct fuse_notify_req *nreq,
- struct fuse_notify_req *next)
-{
- struct fuse_notify_req *prev = next->prev;
- nreq->next = next;
- nreq->prev = prev;
- prev->next = nreq;
- next->prev = nreq;
-}
-
-static void list_init_nreq(struct fuse_notify_req *nreq)
-{
- nreq->next = nreq;
- nreq->prev = nreq;
-}
-
-static void do_notify_reply(fuse_req_t req, fuse_ino_t nodeid,
- const void *inarg, const struct fuse_buf *buf)
-{
- struct fuse_session *se = req->se;
- struct fuse_notify_req *nreq;
- struct fuse_notify_req *head;
-
- pthread_mutex_lock(&se->lock);
- head = &se->notify_list;
- for (nreq = head->next; nreq != head; nreq = nreq->next) {
- if (nreq->unique == req->unique) {
- list_del_nreq(nreq);
- break;
- }
- }
- pthread_mutex_unlock(&se->lock);
-
- if (nreq != head) {
- nreq->reply(nreq, req, nodeid, inarg, buf);
- }
-}
-
static int send_notify_iov(struct fuse_session *se, int notify_code,
struct iovec *iov, int count)
{
@@ -2059,95 +2007,6 @@ int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
return res;
}
-struct fuse_retrieve_req {
- struct fuse_notify_req nreq;
- void *cookie;
-};
-
-static void fuse_ll_retrieve_reply(struct fuse_notify_req *nreq, fuse_req_t req,
- fuse_ino_t ino, const void *inarg,
- const struct fuse_buf *ibuf)
-{
- struct fuse_session *se = req->se;
- struct fuse_retrieve_req *rreq =
- container_of(nreq, struct fuse_retrieve_req, nreq);
- const struct fuse_notify_retrieve_in *arg = inarg;
- struct fuse_bufvec bufv = {
- .buf[0] = *ibuf,
- .count = 1,
- };
-
- if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD)) {
- bufv.buf[0].mem = PARAM(arg);
- }
-
- bufv.buf[0].size -=
- sizeof(struct fuse_in_header) + sizeof(struct fuse_notify_retrieve_in);
-
- if (bufv.buf[0].size < arg->size) {
- fuse_log(FUSE_LOG_ERR, "fuse: retrieve reply: buffer size too small\n");
- fuse_reply_none(req);
- goto out;
- }
- bufv.buf[0].size = arg->size;
-
- if (se->op.retrieve_reply) {
- se->op.retrieve_reply(req, rreq->cookie, ino, arg->offset, &bufv);
- } else {
- fuse_reply_none(req);
- }
-out:
- free(rreq);
-}
-
-int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
- size_t size, off_t offset, void *cookie)
-{
- struct fuse_notify_retrieve_out outarg;
- struct iovec iov[2];
- struct fuse_retrieve_req *rreq;
- int err;
-
- if (!se) {
- return -EINVAL;
- }
-
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 15) {
- return -ENOSYS;
- }
-
- rreq = malloc(sizeof(*rreq));
- if (rreq == NULL) {
- return -ENOMEM;
- }
-
- pthread_mutex_lock(&se->lock);
- rreq->cookie = cookie;
- rreq->nreq.unique = se->notify_ctr++;
- rreq->nreq.reply = fuse_ll_retrieve_reply;
- list_add_nreq(&rreq->nreq, &se->notify_list);
- pthread_mutex_unlock(&se->lock);
-
- outarg.notify_unique = rreq->nreq.unique;
- outarg.nodeid = ino;
- outarg.offset = offset;
- outarg.size = size;
- outarg.padding = 0;
-
- iov[1].iov_base = &outarg;
- iov[1].iov_len = sizeof(outarg);
-
- err = send_notify_iov(se, FUSE_NOTIFY_RETRIEVE, iov, 2);
- if (err) {
- pthread_mutex_lock(&se->lock);
- list_del_nreq(&rreq->nreq);
- pthread_mutex_unlock(&se->lock);
- free(rreq);
- }
-
- return err;
-}
-
void *fuse_req_userdata(fuse_req_t req)
{
return req->se->userdata;
@@ -2226,7 +2085,7 @@ static struct {
[FUSE_POLL] = { do_poll, "POLL" },
[FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" },
[FUSE_DESTROY] = { do_destroy, "DESTROY" },
- [FUSE_NOTIFY_REPLY] = { (void *)1, "NOTIFY_REPLY" },
+ [FUSE_NOTIFY_REPLY] = { NULL, "NOTIFY_REPLY" },
[FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" },
[FUSE_READDIRPLUS] = { do_readdirplus, "READDIRPLUS" },
[FUSE_RENAME2] = { do_rename2, "RENAME2" },
@@ -2333,8 +2192,6 @@ void fuse_session_process_buf_int(struct fuse_session *se,
inarg = (void *)&in[1];
if (in->opcode == FUSE_WRITE && se->op.write_buf) {
do_write_buf(req, in->nodeid, inarg, buf);
- } else if (in->opcode == FUSE_NOTIFY_REPLY) {
- do_notify_reply(req, in->nodeid, inarg, buf);
} else {
fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
}
@@ -2437,8 +2294,6 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
list_init_req(&se->list);
list_init_req(&se->interrupts);
- list_init_nreq(&se->notify_list);
- se->notify_ctr = 1;
fuse_mutex_init(&se->lock);
memcpy(&se->op, op, op_size);
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index 8d8909b35d..12a84b460f 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -1084,21 +1084,6 @@ struct fuse_lowlevel_ops {
void (*write_buf)(fuse_req_t req, fuse_ino_t ino, struct fuse_bufvec *bufv,
off_t off, struct fuse_file_info *fi);
- /**
- * Callback function for the retrieve request
- *
- * Valid replies:
- * fuse_reply_none
- *
- * @param req request handle
- * @param cookie user data supplied to fuse_lowlevel_notify_retrieve()
- * @param ino the inode number supplied to fuse_lowlevel_notify_retrieve()
- * @param offset the offset supplied to fuse_lowlevel_notify_retrieve()
- * @param bufv the buffer containing the returned data
- */
- void (*retrieve_reply)(fuse_req_t req, void *cookie, fuse_ino_t ino,
- off_t offset, struct fuse_bufvec *bufv);
-
/**
* Forget about multiple inodes
*
@@ -1726,38 +1711,6 @@ int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
off_t offset, struct fuse_bufvec *bufv,
enum fuse_buf_copy_flags flags);
-/**
- * Retrieve data from the kernel buffers
- *
- * Retrieve data in the kernel buffers belonging to the given inode.
- * If successful then the retrieve_reply() method will be called with
- * the returned data.
- *
- * Only present pages are returned in the retrieve reply. Retrieving
- * stops when it finds a non-present page and only data prior to that
- * is returned.
- *
- * If this function returns an error, then the retrieve will not be
- * completed and no reply will be sent.
- *
- * This function doesn't change the dirty state of pages in the kernel
- * buffer. For dirty pages the write() method will be called
- * regardless of having been retrieved previously.
- *
- * Added in FUSE protocol version 7.15. If the kernel does not support
- * this (or a newer) version, the function will return -ENOSYS and do
- * nothing.
- *
- * @param se the session object
- * @param ino the inode number
- * @param size the number of bytes to retrieve
- * @param offset the starting offset into the file to retrieve from
- * @param cookie user data to supply to the reply callback
- * @return zero for success, -errno for failure
- */
-int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
- size_t size, off_t offset, void *cookie);
-
/*
* Utility functions
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 010/108] virtiofsd: Remove unused enum fuse_buf_copy_flags
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (8 preceding siblings ...)
2020-01-23 16:44 ` [PULL 009/108] virtiofsd: remove unused notify reply support Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 011/108] virtiofsd: Fix fuse_daemonize ignored return values Dr. David Alan Gilbert (git)
` (99 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Xiao Yang <yangx.jy@cn.fujitsu.com>
Signed-off-by: Xiao Yang <yangx.jy@cn.fujitsu.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/buffer.c | 7 +++--
tools/virtiofsd/fuse_common.h | 46 +-------------------------------
tools/virtiofsd/fuse_lowlevel.c | 13 ++++-----
tools/virtiofsd/fuse_lowlevel.h | 35 ++----------------------
tools/virtiofsd/passthrough_ll.c | 4 +--
5 files changed, 13 insertions(+), 92 deletions(-)
diff --git a/tools/virtiofsd/buffer.c b/tools/virtiofsd/buffer.c
index 5df946c82c..4d507f3302 100644
--- a/tools/virtiofsd/buffer.c
+++ b/tools/virtiofsd/buffer.c
@@ -171,7 +171,7 @@ static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,
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)
+ size_t len)
{
int src_is_fd = src->flags & FUSE_BUF_IS_FD;
int dst_is_fd = dst->flags & FUSE_BUF_IS_FD;
@@ -224,8 +224,7 @@ static int fuse_bufvec_advance(struct fuse_bufvec *bufv, size_t len)
return 1;
}
-ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv,
- enum fuse_buf_copy_flags flags)
+ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv)
{
size_t copied = 0;
@@ -249,7 +248,7 @@ ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv,
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);
+ res = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len);
if (res < 0) {
if (!copied) {
return res;
diff --git a/tools/virtiofsd/fuse_common.h b/tools/virtiofsd/fuse_common.h
index bd9bf861f0..0cb33acc2f 100644
--- a/tools/virtiofsd/fuse_common.h
+++ b/tools/virtiofsd/fuse_common.h
@@ -604,48 +604,6 @@ enum fuse_buf_flags {
FUSE_BUF_FD_RETRY = (1 << 3),
};
-/**
- * Buffer copy flags
- */
-enum fuse_buf_copy_flags {
- /**
- * Don't use splice(2)
- *
- * Always fall back to using read and write instead of
- * splice(2) to copy data from one file descriptor to another.
- *
- * If this flag is not set, then only fall back if splice is
- * unavailable.
- */
- FUSE_BUF_NO_SPLICE = (1 << 1),
-
- /**
- * Force splice
- *
- * Always use splice(2) to copy data from one file descriptor
- * to another. If splice is not available, return -EINVAL.
- */
- FUSE_BUF_FORCE_SPLICE = (1 << 2),
-
- /**
- * Try to move data with splice.
- *
- * If splice is used, try to move pages from the source to the
- * destination instead of copying. See documentation of
- * SPLICE_F_MOVE in splice(2) man page.
- */
- FUSE_BUF_SPLICE_MOVE = (1 << 3),
-
- /**
- * Don't block on the pipe when copying data with splice
- *
- * Makes the operations on the pipe non-blocking (if the pipe
- * is full or empty). See SPLICE_F_NONBLOCK in the splice(2)
- * man page.
- */
- FUSE_BUF_SPLICE_NONBLOCK = (1 << 4),
-};
-
/**
* Single data buffer
*
@@ -741,11 +699,9 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv);
*
* @param dst destination buffer vector
* @param src source buffer vector
- * @param flags flags controlling the copy
* @return actual number of bytes copied or -errno on error
*/
-ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
- enum fuse_buf_copy_flags flags);
+ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src);
/*
* Signal handling
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index eb0ec49d38..3da80de233 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -490,16 +490,14 @@ static int fuse_send_data_iov_fallback(struct fuse_session *se,
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)
+ struct fuse_bufvec *buf)
{
size_t len = fuse_buf_size(buf);
- (void)flags;
return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
}
-int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
- enum fuse_buf_copy_flags flags)
+int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv)
{
struct iovec iov[2];
struct fuse_out_header out;
@@ -511,7 +509,7 @@ int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
out.unique = req->unique;
out.error = 0;
- res = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv, flags);
+ res = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv);
if (res <= 0) {
fuse_free_req(req);
return res;
@@ -1969,8 +1967,7 @@ int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
}
int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
- off_t offset, struct fuse_bufvec *bufv,
- enum fuse_buf_copy_flags flags)
+ off_t offset, struct fuse_bufvec *bufv)
{
struct fuse_out_header out;
struct fuse_notify_store_out outarg;
@@ -1999,7 +1996,7 @@ int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
iov[1].iov_base = &outarg;
iov[1].iov_len = sizeof(outarg);
- res = fuse_send_data_iov(se, NULL, iov, 2, bufv, flags);
+ res = fuse_send_data_iov(se, NULL, iov, 2, bufv);
if (res > 0) {
res = -res;
}
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index 12a84b460f..2fa225d40b 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -1363,33 +1363,6 @@ int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
/**
* Reply with data copied/moved from buffer(s)
*
- * Zero copy data transfer ("splicing") will be used under
- * the following circumstances:
- *
- * 1. FUSE_CAP_SPLICE_WRITE is set in fuse_conn_info.want, and
- * 2. the kernel supports splicing from the fuse device
- * (FUSE_CAP_SPLICE_WRITE is set in fuse_conn_info.capable), and
- * 3. *flags* does not contain FUSE_BUF_NO_SPLICE
- * 4. The amount of data that is provided in file-descriptor backed
- * buffers (i.e., buffers for which bufv[n].flags == FUSE_BUF_FD)
- * is at least twice the page size.
- *
- * In order for SPLICE_F_MOVE to be used, the following additional
- * conditions have to be fulfilled:
- *
- * 1. FUSE_CAP_SPLICE_MOVE is set in fuse_conn_info.want, and
- * 2. the kernel supports it (i.e, FUSE_CAP_SPLICE_MOVE is set in
- fuse_conn_info.capable), and
- * 3. *flags* contains FUSE_BUF_SPLICE_MOVE
- *
- * Note that, if splice is used, the data is actually spliced twice:
- * once into a temporary pipe (to prepend header data), and then again
- * into the kernel. If some of the provided buffers are memory-backed,
- * the data in them is copied in step one and spliced in step two.
- *
- * The FUSE_BUF_SPLICE_FORCE_SPLICE and FUSE_BUF_SPLICE_NONBLOCK flags
- * are silently ignored.
- *
* Possible requests:
* read, readdir, getxattr, listxattr
*
@@ -1400,11 +1373,9 @@ int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
*
* @param req request handle
* @param bufv buffer vector
- * @param flags flags controlling the copy
* @return zero for success, -errno for failure to send reply
*/
-int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
- enum fuse_buf_copy_flags flags);
+int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv);
/**
* Reply with data vector
@@ -1705,12 +1676,10 @@ int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
* @param ino the inode number
* @param offset the starting offset into the file to store to
* @param bufv buffer vector
- * @param flags flags controlling the copy
* @return zero for success, -errno for failure
*/
int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
- off_t offset, struct fuse_bufvec *bufv,
- enum fuse_buf_copy_flags flags);
+ off_t offset, struct fuse_bufvec *bufv);
/*
* Utility functions
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 9377718d9d..126a56ccbd 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -931,7 +931,7 @@ static void lo_read(fuse_req_t req, fuse_ino_t ino, size_t size, off_t offset,
buf.buf[0].fd = fi->fh;
buf.buf[0].pos = offset;
- fuse_reply_data(req, &buf, FUSE_BUF_SPLICE_MOVE);
+ fuse_reply_data(req, &buf);
}
static void lo_write_buf(fuse_req_t req, fuse_ino_t ino,
@@ -952,7 +952,7 @@ static void lo_write_buf(fuse_req_t req, fuse_ino_t ino,
out_buf.buf[0].size, (unsigned long)off);
}
- res = fuse_buf_copy(&out_buf, in_buf, 0);
+ res = fuse_buf_copy(&out_buf, in_buf);
if (res < 0) {
fuse_reply_err(req, -res);
} else {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 011/108] virtiofsd: Fix fuse_daemonize ignored return values
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (9 preceding siblings ...)
2020-01-23 16:44 ` [PULL 010/108] virtiofsd: Remove unused enum fuse_buf_copy_flags Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 012/108] virtiofsd: Fix common header and define for QEMU builds Dr. David Alan Gilbert (git)
` (98 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
QEMU's compiler enables warnings/errors for ignored values
and the (void) trick used in the fuse code isn't enough.
Turn all the return values into a return value on the function.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/helper.c | 33 ++++++++++++++++++++++-----------
1 file changed, 22 insertions(+), 11 deletions(-)
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 5e6f2051a7..d9227d7367 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -10,12 +10,10 @@
* See the file COPYING.LIB.
*/
-#include "config.h"
#include "fuse_i.h"
#include "fuse_lowlevel.h"
#include "fuse_misc.h"
#include "fuse_opt.h"
-#include "mount_util.h"
#include <errno.h>
#include <limits.h>
@@ -171,6 +169,7 @@ int fuse_parse_cmdline(struct fuse_args *args, struct fuse_cmdline_opts *opts)
int fuse_daemonize(int foreground)
{
+ int ret = 0, rett;
if (!foreground) {
int nullfd;
int waiter[2];
@@ -192,8 +191,8 @@ int fuse_daemonize(int foreground)
case 0:
break;
default:
- (void)read(waiter[0], &completed, sizeof(completed));
- _exit(0);
+ _exit(read(waiter[0], &completed,
+ sizeof(completed) != sizeof(completed)));
}
if (setsid() == -1) {
@@ -201,13 +200,22 @@ int fuse_daemonize(int foreground)
return -1;
}
- (void)chdir("/");
+ ret = chdir("/");
nullfd = open("/dev/null", O_RDWR, 0);
if (nullfd != -1) {
- (void)dup2(nullfd, 0);
- (void)dup2(nullfd, 1);
- (void)dup2(nullfd, 2);
+ rett = dup2(nullfd, 0);
+ if (!ret) {
+ ret = rett;
+ }
+ rett = dup2(nullfd, 1);
+ if (!ret) {
+ ret = rett;
+ }
+ rett = dup2(nullfd, 2);
+ if (!ret) {
+ ret = rett;
+ }
if (nullfd > 2) {
close(nullfd);
}
@@ -215,13 +223,16 @@ int fuse_daemonize(int foreground)
/* Propagate completion of daemon initialization */
completed = 1;
- (void)write(waiter[1], &completed, sizeof(completed));
+ rett = write(waiter[1], &completed, sizeof(completed));
+ if (!ret) {
+ ret = rett;
+ }
close(waiter[0]);
close(waiter[1]);
} else {
- (void)chdir("/");
+ ret = chdir("/");
}
- return 0;
+ return ret;
}
void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts,
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 012/108] virtiofsd: Fix common header and define for QEMU builds
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (10 preceding siblings ...)
2020-01-23 16:44 ` [PULL 011/108] virtiofsd: Fix fuse_daemonize ignored return values Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 013/108] virtiofsd: Trim out compatibility code Dr. David Alan Gilbert (git)
` (97 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
All of the fuse files include config.h and define GNU_SOURCE
where we don't have either under our build - remove them.
Fixup path to the kernel's fuse.h in the QEMUs world.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/buffer.c | 4 +---
tools/virtiofsd/fuse_i.h | 3 +++
tools/virtiofsd/fuse_log.c | 1 +
tools/virtiofsd/fuse_lowlevel.c | 6 ++----
tools/virtiofsd/fuse_opt.c | 2 +-
tools/virtiofsd/fuse_signals.c | 2 +-
tools/virtiofsd/helper.c | 1 +
tools/virtiofsd/passthrough_ll.c | 8 ++------
8 files changed, 12 insertions(+), 15 deletions(-)
diff --git a/tools/virtiofsd/buffer.c b/tools/virtiofsd/buffer.c
index 4d507f3302..772efa922d 100644
--- a/tools/virtiofsd/buffer.c
+++ b/tools/virtiofsd/buffer.c
@@ -9,9 +9,7 @@
* See the file COPYING.LIB
*/
-#define _GNU_SOURCE
-
-#include "config.h"
+#include "qemu/osdep.h"
#include "fuse_i.h"
#include "fuse_lowlevel.h"
#include <assert.h>
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index e63cb58388..bae06992e0 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -6,6 +6,9 @@
* See the file COPYING.LIB
*/
+#define FUSE_USE_VERSION 31
+
+
#include "fuse.h"
#include "fuse_lowlevel.h"
diff --git a/tools/virtiofsd/fuse_log.c b/tools/virtiofsd/fuse_log.c
index 11345f9ec8..c301ff6da1 100644
--- a/tools/virtiofsd/fuse_log.c
+++ b/tools/virtiofsd/fuse_log.c
@@ -8,6 +8,7 @@
* See the file COPYING.LIB
*/
+#include "qemu/osdep.h"
#include "fuse_log.h"
#include <stdarg.h>
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 3da80de233..07fb8a6095 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -9,11 +9,9 @@
* See the file COPYING.LIB
*/
-#define _GNU_SOURCE
-
-#include "config.h"
+#include "qemu/osdep.h"
#include "fuse_i.h"
-#include "fuse_kernel.h"
+#include "standard-headers/linux/fuse.h"
#include "fuse_misc.h"
#include "fuse_opt.h"
diff --git a/tools/virtiofsd/fuse_opt.c b/tools/virtiofsd/fuse_opt.c
index edd36f4a3b..28922361a2 100644
--- a/tools/virtiofsd/fuse_opt.c
+++ b/tools/virtiofsd/fuse_opt.c
@@ -9,8 +9,8 @@
* See the file COPYING.LIB
*/
+#include "qemu/osdep.h"
#include "fuse_opt.h"
-#include "config.h"
#include "fuse_i.h"
#include "fuse_misc.h"
diff --git a/tools/virtiofsd/fuse_signals.c b/tools/virtiofsd/fuse_signals.c
index 19d6791cb9..dc7c8ac025 100644
--- a/tools/virtiofsd/fuse_signals.c
+++ b/tools/virtiofsd/fuse_signals.c
@@ -8,7 +8,7 @@
* See the file COPYING.LIB
*/
-#include "config.h"
+#include "qemu/osdep.h"
#include "fuse_i.h"
#include "fuse_lowlevel.h"
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index d9227d7367..9333691525 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -10,6 +10,7 @@
* See the file COPYING.LIB.
*/
+#include "qemu/osdep.h"
#include "fuse_i.h"
#include "fuse_lowlevel.h"
#include "fuse_misc.h"
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 126a56ccbd..322a889cdf 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -35,15 +35,11 @@
* \include passthrough_ll.c
*/
-#define _GNU_SOURCE
-#define FUSE_USE_VERSION 31
-
-#include "config.h"
-
+#include "qemu/osdep.h"
+#include "fuse_lowlevel.h"
#include <assert.h>
#include <dirent.h>
#include <errno.h>
-#include <fuse_lowlevel.h>
#include <inttypes.h>
#include <limits.h>
#include <pthread.h>
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 013/108] virtiofsd: Trim out compatibility code
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (11 preceding siblings ...)
2020-01-23 16:44 ` [PULL 012/108] virtiofsd: Fix common header and define for QEMU builds Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 014/108] vitriofsd/passthrough_ll: fix fallocate() ifdefs Dr. David Alan Gilbert (git)
` (96 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
virtiofsd only supports major=7, minor>=31; trim out a lot of
old compatibility code.
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>
---
tools/virtiofsd/fuse_lowlevel.c | 330 ++++++++++++--------------------
1 file changed, 119 insertions(+), 211 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 07fb8a6095..514d79cb24 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -387,16 +387,7 @@ static void fill_open(struct fuse_open_out *arg, const struct fuse_file_info *f)
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);
- }
+ size_t size = sizeof(arg);
memset(&arg, 0, sizeof(arg));
fill_entry(&arg, e);
@@ -407,9 +398,7 @@ 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);
+ size_t entrysize = 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);
@@ -423,8 +412,7 @@ 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);
+ size_t size = sizeof(arg);
memset(&arg, 0, sizeof(arg));
arg.attr_valid = calc_timeout_sec(attr_timeout);
@@ -519,8 +507,7 @@ int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv)
int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
{
struct fuse_statfs_out arg;
- size_t size =
- req->se->conn.proto_minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(arg);
+ size_t size = sizeof(arg);
memset(&arg, 0, sizeof(arg));
convert_statfs(stbuf, &arg.st);
@@ -604,45 +591,31 @@ int fuse_reply_ioctl_retry(fuse_req_t req, const struct iovec *in_iov,
iov[count].iov_len = sizeof(arg);
count++;
- if (req->se->conn.proto_minor < 16) {
- if (in_count) {
- iov[count].iov_base = (void *)in_iov;
- iov[count].iov_len = sizeof(in_iov[0]) * in_count;
- count++;
- }
+ /* Can't handle non-compat 64bit ioctls on 32bit */
+ if (sizeof(void *) == 4 && req->ioctl_64bit) {
+ res = fuse_reply_err(req, EINVAL);
+ goto out;
+ }
- if (out_count) {
- iov[count].iov_base = (void *)out_iov;
- iov[count].iov_len = sizeof(out_iov[0]) * out_count;
- count++;
+ if (in_count) {
+ in_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);
+ if (!in_fiov) {
+ goto enomem;
}
- } else {
- /* Can't handle non-compat 64bit ioctls on 32bit */
- if (sizeof(void *) == 4 && req->ioctl_64bit) {
- res = fuse_reply_err(req, EINVAL);
- goto out;
- }
-
- if (in_count) {
- in_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);
- if (!in_fiov) {
- goto enomem;
- }
- iov[count].iov_base = (void *)in_fiov;
- iov[count].iov_len = sizeof(in_fiov[0]) * in_count;
- count++;
+ iov[count].iov_base = (void *)in_fiov;
+ iov[count].iov_len = sizeof(in_fiov[0]) * in_count;
+ count++;
+ }
+ if (out_count) {
+ out_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);
+ if (!out_fiov) {
+ goto enomem;
}
- if (out_count) {
- out_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);
- if (!out_fiov) {
- goto enomem;
- }
- iov[count].iov_base = (void *)out_fiov;
- iov[count].iov_len = sizeof(out_fiov[0]) * out_count;
- count++;
- }
+ iov[count].iov_base = (void *)out_fiov;
+ iov[count].iov_len = sizeof(out_fiov[0]) * out_count;
+ count++;
}
res = send_reply_iov(req, 0, iov, count);
@@ -784,14 +757,12 @@ static void do_getattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
struct fuse_file_info *fip = NULL;
struct fuse_file_info fi;
- if (req->se->conn.proto_minor >= 9) {
- struct fuse_getattr_in *arg = (struct fuse_getattr_in *)inarg;
+ struct fuse_getattr_in *arg = (struct fuse_getattr_in *)inarg;
- if (arg->getattr_flags & FUSE_GETATTR_FH) {
- memset(&fi, 0, sizeof(fi));
- fi.fh = arg->fh;
- fip = &fi;
- }
+ if (arg->getattr_flags & FUSE_GETATTR_FH) {
+ memset(&fi, 0, sizeof(fi));
+ fi.fh = arg->fh;
+ fip = &fi;
}
if (req->se->op.getattr) {
@@ -856,11 +827,7 @@ static void do_mknod(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
struct fuse_mknod_in *arg = (struct fuse_mknod_in *)inarg;
char *name = PARAM(arg);
- if (req->se->conn.proto_minor >= 12) {
- req->ctx.umask = arg->umask;
- } else {
- name = (char *)inarg + FUSE_COMPAT_MKNOD_IN_SIZE;
- }
+ req->ctx.umask = arg->umask;
if (req->se->op.mknod) {
req->se->op.mknod(req, nodeid, name, arg->mode, arg->rdev);
@@ -873,9 +840,7 @@ static void do_mkdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
{
struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *)inarg;
- if (req->se->conn.proto_minor >= 12) {
- req->ctx.umask = arg->umask;
- }
+ req->ctx.umask = arg->umask;
if (req->se->op.mkdir) {
req->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
@@ -967,11 +932,7 @@ static void do_create(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
memset(&fi, 0, sizeof(fi));
fi.flags = arg->flags;
- if (req->se->conn.proto_minor >= 12) {
- req->ctx.umask = arg->umask;
- } else {
- name = (char *)inarg + sizeof(struct fuse_open_in);
- }
+ req->ctx.umask = arg->umask;
req->se->op.create(req, nodeid, name, arg->mode, &fi);
} else {
@@ -1003,10 +964,8 @@ static void do_read(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
- if (req->se->conn.proto_minor >= 9) {
- fi.lock_owner = arg->lock_owner;
- fi.flags = arg->flags;
- }
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
req->se->op.read(req, nodeid, arg->size, arg->offset, &fi);
} else {
fuse_reply_err(req, ENOSYS);
@@ -1023,13 +982,9 @@ static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
fi.fh = arg->fh;
fi.writepage = (arg->write_flags & FUSE_WRITE_CACHE) != 0;
- if (req->se->conn.proto_minor < 9) {
- param = ((char *)arg) + FUSE_COMPAT_WRITE_IN_SIZE;
- } else {
- fi.lock_owner = arg->lock_owner;
- fi.flags = arg->flags;
- param = PARAM(arg);
- }
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ param = PARAM(arg);
if (req->se->op.write) {
req->se->op.write(req, nodeid, param, arg->size, arg->offset, &fi);
@@ -1053,21 +1008,14 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
fi.fh = arg->fh;
fi.writepage = arg->write_flags & FUSE_WRITE_CACHE;
- if (se->conn.proto_minor < 9) {
- bufv.buf[0].mem = ((char *)arg) + FUSE_COMPAT_WRITE_IN_SIZE;
- bufv.buf[0].size -=
- sizeof(struct fuse_in_header) + FUSE_COMPAT_WRITE_IN_SIZE;
- assert(!(bufv.buf[0].flags & FUSE_BUF_IS_FD));
- } else {
- fi.lock_owner = arg->lock_owner;
- fi.flags = arg->flags;
- if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD)) {
- bufv.buf[0].mem = PARAM(arg);
- }
-
- bufv.buf[0].size -=
- sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in);
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD)) {
+ bufv.buf[0].mem = PARAM(arg);
}
+
+ bufv.buf[0].size -=
+ sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in);
if (bufv.buf[0].size < arg->size) {
fuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");
fuse_reply_err(req, EIO);
@@ -1086,9 +1034,7 @@ static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
fi.flush = 1;
- if (req->se->conn.proto_minor >= 7) {
- fi.lock_owner = arg->lock_owner;
- }
+ fi.lock_owner = arg->lock_owner;
if (req->se->op.flush) {
req->se->op.flush(req, nodeid, &fi);
@@ -1105,10 +1051,8 @@ static void do_release(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
memset(&fi, 0, sizeof(fi));
fi.flags = arg->flags;
fi.fh = arg->fh;
- if (req->se->conn.proto_minor >= 8) {
- fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
- fi.lock_owner = arg->lock_owner;
- }
+ fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
+ fi.lock_owner = arg->lock_owner;
if (arg->release_flags & FUSE_RELEASE_FLOCK_UNLOCK) {
fi.flock_release = 1;
fi.lock_owner = arg->lock_owner;
@@ -1477,8 +1421,7 @@ static void do_ioctl(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
- if (sizeof(void *) == 4 && req->se->conn.proto_minor >= 16 &&
- !(flags & FUSE_IOCTL_32BIT)) {
+ if (sizeof(void *) == 4 && !(flags & FUSE_IOCTL_32BIT)) {
req->ioctl_64bit = 1;
}
@@ -1603,7 +1546,7 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
outarg.major = FUSE_KERNEL_VERSION;
outarg.minor = FUSE_KERNEL_MINOR_VERSION;
- if (arg->major < 7) {
+ if (arg->major < 7 || (arg->major == 7 && arg->minor < 31)) {
fuse_log(FUSE_LOG_ERR, "fuse: unsupported protocol version: %u.%u\n",
arg->major, arg->minor);
fuse_reply_err(req, EPROTO);
@@ -1616,81 +1559,71 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
return;
}
- if (arg->minor >= 6) {
- if (arg->max_readahead < se->conn.max_readahead) {
- se->conn.max_readahead = arg->max_readahead;
- }
- if (arg->flags & FUSE_ASYNC_READ) {
- se->conn.capable |= FUSE_CAP_ASYNC_READ;
- }
- if (arg->flags & FUSE_POSIX_LOCKS) {
- se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
- }
- if (arg->flags & FUSE_ATOMIC_O_TRUNC) {
- se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
- }
- if (arg->flags & FUSE_EXPORT_SUPPORT) {
- se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
- }
- if (arg->flags & FUSE_DONT_MASK) {
- se->conn.capable |= FUSE_CAP_DONT_MASK;
- }
- if (arg->flags & FUSE_FLOCK_LOCKS) {
- se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
- }
- if (arg->flags & FUSE_AUTO_INVAL_DATA) {
- se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
- }
- if (arg->flags & FUSE_DO_READDIRPLUS) {
- se->conn.capable |= FUSE_CAP_READDIRPLUS;
- }
- if (arg->flags & FUSE_READDIRPLUS_AUTO) {
- se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
- }
- if (arg->flags & FUSE_ASYNC_DIO) {
- se->conn.capable |= FUSE_CAP_ASYNC_DIO;
- }
- if (arg->flags & FUSE_WRITEBACK_CACHE) {
- se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
- }
- if (arg->flags & FUSE_NO_OPEN_SUPPORT) {
- se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
- }
- if (arg->flags & FUSE_PARALLEL_DIROPS) {
- se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
- }
- if (arg->flags & FUSE_POSIX_ACL) {
- se->conn.capable |= FUSE_CAP_POSIX_ACL;
- }
- if (arg->flags & FUSE_HANDLE_KILLPRIV) {
- se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
- }
- if (arg->flags & FUSE_NO_OPENDIR_SUPPORT) {
- se->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;
- }
- if (!(arg->flags & FUSE_MAX_PAGES)) {
- size_t max_bufsize =
- FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize() +
- FUSE_BUFFER_HEADER_SIZE;
- if (bufsize > max_bufsize) {
- bufsize = max_bufsize;
- }
+ if (arg->max_readahead < se->conn.max_readahead) {
+ se->conn.max_readahead = arg->max_readahead;
+ }
+ if (arg->flags & FUSE_ASYNC_READ) {
+ se->conn.capable |= FUSE_CAP_ASYNC_READ;
+ }
+ if (arg->flags & FUSE_POSIX_LOCKS) {
+ se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
+ }
+ if (arg->flags & FUSE_ATOMIC_O_TRUNC) {
+ se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
+ }
+ if (arg->flags & FUSE_EXPORT_SUPPORT) {
+ se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
+ }
+ if (arg->flags & FUSE_DONT_MASK) {
+ se->conn.capable |= FUSE_CAP_DONT_MASK;
+ }
+ if (arg->flags & FUSE_FLOCK_LOCKS) {
+ se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
+ }
+ if (arg->flags & FUSE_AUTO_INVAL_DATA) {
+ se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
+ }
+ if (arg->flags & FUSE_DO_READDIRPLUS) {
+ se->conn.capable |= FUSE_CAP_READDIRPLUS;
+ }
+ if (arg->flags & FUSE_READDIRPLUS_AUTO) {
+ se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
+ }
+ if (arg->flags & FUSE_ASYNC_DIO) {
+ se->conn.capable |= FUSE_CAP_ASYNC_DIO;
+ }
+ if (arg->flags & FUSE_WRITEBACK_CACHE) {
+ se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
+ }
+ if (arg->flags & FUSE_NO_OPEN_SUPPORT) {
+ se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
+ }
+ if (arg->flags & FUSE_PARALLEL_DIROPS) {
+ se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
+ }
+ if (arg->flags & FUSE_POSIX_ACL) {
+ se->conn.capable |= FUSE_CAP_POSIX_ACL;
+ }
+ if (arg->flags & FUSE_HANDLE_KILLPRIV) {
+ se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
+ }
+ if (arg->flags & FUSE_NO_OPENDIR_SUPPORT) {
+ se->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;
+ }
+ if (!(arg->flags & FUSE_MAX_PAGES)) {
+ size_t max_bufsize = FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize() +
+ FUSE_BUFFER_HEADER_SIZE;
+ if (bufsize > max_bufsize) {
+ bufsize = max_bufsize;
}
- } else {
- se->conn.max_readahead = 0;
}
-
- if (se->conn.proto_minor >= 14) {
#ifdef HAVE_SPLICE
#ifdef HAVE_VMSPLICE
- se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
+ se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
#endif
- se->conn.capable |= FUSE_CAP_SPLICE_READ;
+ se->conn.capable |= FUSE_CAP_SPLICE_READ;
#endif
- }
- if (se->conn.proto_minor >= 18) {
- se->conn.capable |= FUSE_CAP_IOCTL_DIR;
- }
+ se->conn.capable |= FUSE_CAP_IOCTL_DIR;
/*
* Default settings for modern filesystems.
@@ -1797,24 +1730,20 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
outarg.max_readahead = se->conn.max_readahead;
outarg.max_write = se->conn.max_write;
- if (se->conn.proto_minor >= 13) {
- if (se->conn.max_background >= (1 << 16)) {
- se->conn.max_background = (1 << 16) - 1;
- }
- if (se->conn.congestion_threshold > se->conn.max_background) {
- se->conn.congestion_threshold = se->conn.max_background;
- }
- if (!se->conn.congestion_threshold) {
- se->conn.congestion_threshold = se->conn.max_background * 3 / 4;
- }
-
- outarg.max_background = se->conn.max_background;
- outarg.congestion_threshold = se->conn.congestion_threshold;
+ if (se->conn.max_background >= (1 << 16)) {
+ se->conn.max_background = (1 << 16) - 1;
+ }
+ if (se->conn.congestion_threshold > se->conn.max_background) {
+ se->conn.congestion_threshold = se->conn.max_background;
}
- if (se->conn.proto_minor >= 23) {
- outarg.time_gran = se->conn.time_gran;
+ if (!se->conn.congestion_threshold) {
+ se->conn.congestion_threshold = se->conn.max_background * 3 / 4;
}
+ outarg.max_background = se->conn.max_background;
+ outarg.congestion_threshold = se->conn.congestion_threshold;
+ outarg.time_gran = se->conn.time_gran;
+
if (se->debug) {
fuse_log(FUSE_LOG_DEBUG, " INIT: %u.%u\n", outarg.major,
outarg.minor);
@@ -1828,11 +1757,6 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
outarg.congestion_threshold);
fuse_log(FUSE_LOG_DEBUG, " time_gran=%u\n", outarg.time_gran);
}
- if (arg->minor < 5) {
- outargsize = FUSE_COMPAT_INIT_OUT_SIZE;
- } else if (arg->minor < 23) {
- outargsize = FUSE_COMPAT_22_INIT_OUT_SIZE;
- }
send_reply_ok(req, &outarg, outargsize);
}
@@ -1896,10 +1820,6 @@ int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
return -EINVAL;
}
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 12) {
- return -ENOSYS;
- }
-
outarg.ino = ino;
outarg.off = off;
outarg.len = len;
@@ -1920,10 +1840,6 @@ int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
return -EINVAL;
}
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 12) {
- return -ENOSYS;
- }
-
outarg.parent = parent;
outarg.namelen = namelen;
outarg.padding = 0;
@@ -1947,10 +1863,6 @@ int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
return -EINVAL;
}
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 18) {
- return -ENOSYS;
- }
-
outarg.parent = parent;
outarg.child = child;
outarg.namelen = namelen;
@@ -1977,10 +1889,6 @@ int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
return -EINVAL;
}
- if (se->conn.proto_major < 6 || se->conn.proto_minor < 15) {
- return -ENOSYS;
- }
-
out.unique = 0;
out.error = FUSE_NOTIFY_STORE;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 014/108] vitriofsd/passthrough_ll: fix fallocate() ifdefs
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (12 preceding siblings ...)
2020-01-23 16:44 ` [PULL 013/108] virtiofsd: Trim out compatibility code Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 015/108] virtiofsd: Make fsync work even if only inode is passed in Dr. David Alan Gilbert (git)
` (95 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Xiao Yang <yangx.jy@cn.fujitsu.com>
1) Use correct CONFIG_FALLOCATE macro to check if fallocate() is supported.(i.e configure
script sets CONFIG_FALLOCATE intead of HAVE_FALLOCATE if fallocate() is supported)
2) Replace HAVE_POSIX_FALLOCATE with CONFIG_POSIX_FALLOCATE.
Signed-off-by: Xiao Yang <yangx.jy@cn.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Merged from two of Xiao Yang's patches
---
tools/virtiofsd/passthrough_ll.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 322a889cdf..6c4da18075 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -975,13 +975,13 @@ static void lo_fallocate(fuse_req_t req, fuse_ino_t ino, int mode, off_t offset,
int err = EOPNOTSUPP;
(void)ino;
-#ifdef HAVE_FALLOCATE
+#ifdef CONFIG_FALLOCATE
err = fallocate(fi->fh, mode, offset, length);
if (err < 0) {
err = errno;
}
-#elif defined(HAVE_POSIX_FALLOCATE)
+#elif defined(CONFIG_POSIX_FALLOCATE)
if (mode) {
fuse_reply_err(req, EOPNOTSUPP);
return;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 015/108] virtiofsd: Make fsync work even if only inode is passed in
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (13 preceding siblings ...)
2020-01-23 16:44 ` [PULL 014/108] vitriofsd/passthrough_ll: fix fallocate() ifdefs Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 016/108] virtiofsd: Add options for virtio Dr. David Alan Gilbert (git)
` (94 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Vivek Goyal <vgoyal@redhat.com>
If caller has not sent file handle in request, then using inode, retrieve
the fd opened using O_PATH and use that to open file again and issue
fsync. This will be needed when dax_flush() calls fsync. At that time
we only have inode information (and not file).
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 6 +++++-
tools/virtiofsd/passthrough_ll.c | 28 ++++++++++++++++++++++++++--
2 files changed, 31 insertions(+), 3 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 514d79cb24..8552cfb8af 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -1075,7 +1075,11 @@ static void do_fsync(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
fi.fh = arg->fh;
if (req->se->op.fsync) {
- req->se->op.fsync(req, nodeid, datasync, &fi);
+ if (fi.fh == (uint64_t)-1) {
+ req->se->op.fsync(req, nodeid, datasync, NULL);
+ } else {
+ req->se->op.fsync(req, nodeid, datasync, &fi);
+ }
} else {
fuse_reply_err(req, ENOSYS);
}
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 6c4da18075..26ac87013b 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -903,10 +903,34 @@ static void lo_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
{
int res;
(void)ino;
+ int fd;
+ char *buf;
+
+ fuse_log(FUSE_LOG_DEBUG, "lo_fsync(ino=%" PRIu64 ", fi=0x%p)\n", ino,
+ (void *)fi);
+
+ if (!fi) {
+ res = asprintf(&buf, "/proc/self/fd/%i", lo_fd(req, ino));
+ if (res == -1) {
+ return (void)fuse_reply_err(req, errno);
+ }
+
+ fd = open(buf, O_RDWR);
+ free(buf);
+ if (fd == -1) {
+ return (void)fuse_reply_err(req, errno);
+ }
+ } else {
+ fd = fi->fh;
+ }
+
if (datasync) {
- res = fdatasync(fi->fh);
+ res = fdatasync(fd);
} else {
- res = fsync(fi->fh);
+ res = fsync(fd);
+ }
+ if (!fi) {
+ close(fd);
}
fuse_reply_err(req, res == -1 ? errno : 0);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 016/108] virtiofsd: Add options for virtio
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (14 preceding siblings ...)
2020-01-23 16:44 ` [PULL 015/108] virtiofsd: Make fsync work even if only inode is passed in Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:44 ` [PULL 017/108] virtiofsd: add -o source=PATH to help output Dr. David Alan Gilbert (git)
` (93 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Add options to specify parameters for virtio-fs paths, i.e.
./virtiofsd -o vhost_user_socket=/tmp/vhostqemu
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_i.h | 1 +
tools/virtiofsd/fuse_lowlevel.c | 11 ++++++++---
tools/virtiofsd/helper.c | 14 +++++++-------
3 files changed, 16 insertions(+), 10 deletions(-)
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index bae06992e0..26b1a7da88 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -63,6 +63,7 @@ struct fuse_session {
struct fuse_notify_req notify_list;
size_t bufsize;
int error;
+ char *vu_socket_path;
};
struct fuse_chan {
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 8552cfb8af..17e8718283 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2115,8 +2115,11 @@ reply_err:
}
static const struct fuse_opt fuse_ll_opts[] = {
- LL_OPTION("debug", debug, 1), LL_OPTION("-d", debug, 1),
- LL_OPTION("--debug", debug, 1), LL_OPTION("allow_root", deny_others, 1),
+ LL_OPTION("debug", debug, 1),
+ LL_OPTION("-d", debug, 1),
+ LL_OPTION("--debug", debug, 1),
+ LL_OPTION("allow_root", deny_others, 1),
+ LL_OPTION("--socket-path=%s", vu_socket_path, 0),
FUSE_OPT_END
};
@@ -2132,7 +2135,9 @@ void fuse_lowlevel_help(void)
* These are not all options, but the ones that are
* potentially of interest to an end-user
*/
- printf(" -o allow_root allow access by root\n");
+ printf(
+ " -o allow_root allow access by root\n"
+ " --socket-path=PATH path for the vhost-user socket\n");
}
void fuse_session_destroy(struct fuse_session *se)
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 9333691525..676032e71f 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -127,13 +127,13 @@ static const struct fuse_opt conn_info_opt_spec[] = {
void fuse_cmdline_help(void)
{
- printf(
- " -h --help print help\n"
- " -V --version print version\n"
- " -d -o debug enable debug output (implies -f)\n"
- " -f foreground operation\n"
- " -o max_idle_threads the maximum number of idle worker threads\n"
- " allowed (default: 10)\n");
+ printf(" -h --help print help\n"
+ " -V --version print version\n"
+ " -d -o debug enable debug output (implies -f)\n"
+ " -f foreground operation\n"
+ " -o max_idle_threads the maximum number of idle worker "
+ "threads\n"
+ " allowed (default: 10)\n");
}
static int fuse_helper_opt_proc(void *data, const char *arg, int key,
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 017/108] virtiofsd: add -o source=PATH to help output
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (15 preceding siblings ...)
2020-01-23 16:44 ` [PULL 016/108] virtiofsd: Add options for virtio Dr. David Alan Gilbert (git)
@ 2020-01-23 16:44 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 018/108] virtiofsd: Open vhost connection instead of mounting Dr. David Alan Gilbert (git)
` (92 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:44 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
The -o source=PATH option will be used by most command-line invocations.
Let's document it!
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 26ac87013b..fc9b264d56 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1319,6 +1319,7 @@ int main(int argc, char *argv[])
if (opts.show_help) {
printf("usage: %s [options]\n\n", argv[0]);
fuse_cmdline_help();
+ printf(" -o source=PATH shared directory tree\n");
fuse_lowlevel_help();
ret = 0;
goto err_out1;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 018/108] virtiofsd: Open vhost connection instead of mounting
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (16 preceding siblings ...)
2020-01-23 16:44 ` [PULL 017/108] virtiofsd: add -o source=PATH to help output Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 019/108] virtiofsd: Start wiring up vhost-user Dr. David Alan Gilbert (git)
` (91 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
When run with vhost-user options we conect to the QEMU instead
via a socket. Start this off by creating the socket.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_i.h | 7 ++-
tools/virtiofsd/fuse_lowlevel.c | 55 +++--------------------
tools/virtiofsd/fuse_virtio.c | 79 +++++++++++++++++++++++++++++++++
tools/virtiofsd/fuse_virtio.h | 23 ++++++++++
4 files changed, 114 insertions(+), 50 deletions(-)
create mode 100644 tools/virtiofsd/fuse_virtio.c
create mode 100644 tools/virtiofsd/fuse_virtio.h
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index 26b1a7da88..82d6ac7115 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -6,9 +6,10 @@
* See the file COPYING.LIB
*/
-#define FUSE_USE_VERSION 31
-
+#ifndef FUSE_I_H
+#define FUSE_I_H
+#define FUSE_USE_VERSION 31
#include "fuse.h"
#include "fuse_lowlevel.h"
@@ -101,3 +102,5 @@ void fuse_session_process_buf_int(struct fuse_session *se,
/* room needed in buffer to accommodate header */
#define FUSE_BUFFER_HEADER_SIZE 0x1000
+
+#endif
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 17e8718283..5df124e64b 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -14,6 +14,7 @@
#include "standard-headers/linux/fuse.h"
#include "fuse_misc.h"
#include "fuse_opt.h"
+#include "fuse_virtio.h"
#include <assert.h>
#include <errno.h>
@@ -2202,6 +2203,11 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
goto out4;
}
+ if (!se->vu_socket_path) {
+ fprintf(stderr, "fuse: missing -o vhost_user_socket option\n");
+ goto out4;
+ }
+
se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() + FUSE_BUFFER_HEADER_SIZE;
list_init_req(&se->list);
@@ -2224,54 +2230,7 @@ out1:
int fuse_session_mount(struct fuse_session *se)
{
- int fd;
-
- /*
- * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
- * would ensue.
- */
- do {
- fd = open("/dev/null", O_RDWR);
- if (fd > 2) {
- close(fd);
- }
- } while (fd >= 0 && fd <= 2);
-
- /*
- * To allow FUSE daemons to run without privileges, the caller may open
- * /dev/fuse before launching the file system and pass on the file
- * descriptor by specifying /dev/fd/N as the mount point. Note that the
- * parent process takes care of performing the mount in this case.
- */
- fd = fuse_mnt_parse_fuse_fd(mountpoint);
- if (fd != -1) {
- if (fcntl(fd, F_GETFD) == -1) {
- fuse_log(FUSE_LOG_ERR, "fuse: Invalid file descriptor /dev/fd/%u\n",
- fd);
- return -1;
- }
- se->fd = fd;
- return 0;
- }
-
- /* Open channel */
- fd = fuse_kern_mount(mountpoint, se->mo);
- if (fd == -1) {
- return -1;
- }
- se->fd = fd;
-
- /* Save mountpoint */
- se->mountpoint = strdup(mountpoint);
- if (se->mountpoint == NULL) {
- goto error_out;
- }
-
- return 0;
-
-error_out:
- fuse_kern_unmount(mountpoint, fd);
- return -1;
+ return virtio_session_mount(se);
}
int fuse_session_fd(struct fuse_session *se)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
new file mode 100644
index 0000000000..cbef6ffdda
--- /dev/null
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -0,0 +1,79 @@
+/*
+ * virtio-fs glue for FUSE
+ * Copyright (C) 2018 Red Hat, Inc. and/or its affiliates
+ *
+ * Authors:
+ * Dave Gilbert <dgilbert@redhat.com>
+ *
+ * Implements the glue between libfuse and libvhost-user
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB
+ */
+
+#include "fuse_i.h"
+#include "standard-headers/linux/fuse.h"
+#include "fuse_misc.h"
+#include "fuse_opt.h"
+#include "fuse_virtio.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+/* From spec */
+struct virtio_fs_config {
+ char tag[36];
+ uint32_t num_queues;
+};
+
+int virtio_session_mount(struct fuse_session *se)
+{
+ struct sockaddr_un un;
+ mode_t old_umask;
+
+ if (strlen(se->vu_socket_path) >= sizeof(un.sun_path)) {
+ fuse_log(FUSE_LOG_ERR, "Socket path too long\n");
+ return -1;
+ }
+
+ se->fd = -1;
+
+ /*
+ * Create the Unix socket to communicate with qemu
+ * based on QEMU's vhost-user-bridge
+ */
+ unlink(se->vu_socket_path);
+ strcpy(un.sun_path, se->vu_socket_path);
+ size_t addr_len = sizeof(un);
+
+ int listen_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (listen_sock == -1) {
+ fuse_log(FUSE_LOG_ERR, "vhost socket creation: %m\n");
+ return -1;
+ }
+ un.sun_family = AF_UNIX;
+
+ /*
+ * Unfortunately bind doesn't let you set the mask on the socket,
+ * so set umask to 077 and restore it later.
+ */
+ old_umask = umask(0077);
+ if (bind(listen_sock, (struct sockaddr *)&un, addr_len) == -1) {
+ fuse_log(FUSE_LOG_ERR, "vhost socket bind: %m\n");
+ umask(old_umask);
+ return -1;
+ }
+ umask(old_umask);
+
+ if (listen(listen_sock, 1) == -1) {
+ fuse_log(FUSE_LOG_ERR, "vhost socket listen: %m\n");
+ return -1;
+ }
+
+ return -1;
+}
diff --git a/tools/virtiofsd/fuse_virtio.h b/tools/virtiofsd/fuse_virtio.h
new file mode 100644
index 0000000000..8f2edb69ca
--- /dev/null
+++ b/tools/virtiofsd/fuse_virtio.h
@@ -0,0 +1,23 @@
+/*
+ * virtio-fs glue for FUSE
+ * Copyright (C) 2018 Red Hat, Inc. and/or its affiliates
+ *
+ * Authors:
+ * Dave Gilbert <dgilbert@redhat.com>
+ *
+ * Implements the glue between libfuse and libvhost-user
+ *
+ * This program can be distributed under the terms of the GNU LGPLv2.
+ * See the file COPYING.LIB
+ */
+
+#ifndef FUSE_VIRTIO_H
+#define FUSE_VIRTIO_H
+
+#include "fuse_i.h"
+
+struct fuse_session;
+
+int virtio_session_mount(struct fuse_session *se);
+
+#endif
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 019/108] virtiofsd: Start wiring up vhost-user
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (17 preceding siblings ...)
2020-01-23 16:45 ` [PULL 018/108] virtiofsd: Open vhost connection instead of mounting Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 020/108] virtiofsd: Add main virtio loop Dr. David Alan Gilbert (git)
` (90 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Listen on our unix socket for the connection from QEMU, when we get it
initialise vhost-user and dive into our own loop variant (currently
dummy).
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>
---
tools/virtiofsd/fuse_i.h | 4 ++
tools/virtiofsd/fuse_lowlevel.c | 5 ++
tools/virtiofsd/fuse_lowlevel.h | 7 +++
tools/virtiofsd/fuse_virtio.c | 87 +++++++++++++++++++++++++++++++-
tools/virtiofsd/fuse_virtio.h | 2 +
tools/virtiofsd/passthrough_ll.c | 7 +--
6 files changed, 106 insertions(+), 6 deletions(-)
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index 82d6ac7115..ec04449069 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -13,6 +13,8 @@
#include "fuse.h"
#include "fuse_lowlevel.h"
+struct fv_VuDev;
+
struct fuse_req {
struct fuse_session *se;
uint64_t unique;
@@ -65,6 +67,8 @@ struct fuse_session {
size_t bufsize;
int error;
char *vu_socket_path;
+ int vu_socketfd;
+ struct fv_VuDev *virtio_dev;
};
struct fuse_chan {
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 5df124e64b..af09fa2b94 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2242,6 +2242,11 @@ void fuse_session_unmount(struct fuse_session *se)
{
}
+int fuse_lowlevel_is_virtio(struct fuse_session *se)
+{
+ return se->vu_socket_path != NULL;
+}
+
#ifdef linux
int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
{
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index 2fa225d40b..f6b34700af 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -1755,6 +1755,13 @@ void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
*/
int fuse_req_interrupted(fuse_req_t req);
+/**
+ * Check if the session is connected via virtio
+ *
+ * @param se session object
+ * @return 1 if the session is a virtio session
+ */
+int fuse_lowlevel_is_virtio(struct fuse_session *se);
/*
* Inquiry functions
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index cbef6ffdda..2ae3c764dd 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -19,18 +19,78 @@
#include <stdint.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <unistd.h>
+#include "contrib/libvhost-user/libvhost-user.h"
+
+/*
+ * We pass the dev element into libvhost-user
+ * and then use it to get back to the outer
+ * container for other data.
+ */
+struct fv_VuDev {
+ VuDev dev;
+ struct fuse_session *se;
+};
+
/* From spec */
struct virtio_fs_config {
char tag[36];
uint32_t num_queues;
};
+/*
+ * Callback from libvhost-user if there's a new fd we're supposed to listen
+ * to, typically a queue kick?
+ */
+static void fv_set_watch(VuDev *dev, int fd, int condition, vu_watch_cb cb,
+ void *data)
+{
+ fuse_log(FUSE_LOG_WARNING, "%s: TODO! fd=%d\n", __func__, fd);
+}
+
+/*
+ * Callback from libvhost-user if we're no longer supposed to listen on an fd
+ */
+static void fv_remove_watch(VuDev *dev, int fd)
+{
+ fuse_log(FUSE_LOG_WARNING, "%s: TODO! fd=%d\n", __func__, fd);
+}
+
+/* Callback from libvhost-user to panic */
+static void fv_panic(VuDev *dev, const char *err)
+{
+ fuse_log(FUSE_LOG_ERR, "%s: libvhost-user: %s\n", __func__, err);
+ /* TODO: Allow reconnects?? */
+ exit(EXIT_FAILURE);
+}
+
+static bool fv_queue_order(VuDev *dev, int qidx)
+{
+ return false;
+}
+
+static const VuDevIface fv_iface = {
+ /* TODO: Add other callbacks */
+ .queue_is_processed_in_order = fv_queue_order,
+};
+
+int virtio_loop(struct fuse_session *se)
+{
+ fuse_log(FUSE_LOG_INFO, "%s: Entry\n", __func__);
+
+ while (1) {
+ /* TODO: Add stuffing */
+ }
+
+ fuse_log(FUSE_LOG_INFO, "%s: Exit\n", __func__);
+}
+
int virtio_session_mount(struct fuse_session *se)
{
struct sockaddr_un un;
@@ -75,5 +135,30 @@ int virtio_session_mount(struct fuse_session *se)
return -1;
}
- return -1;
+ fuse_log(FUSE_LOG_INFO, "%s: Waiting for vhost-user socket connection...\n",
+ __func__);
+ int data_sock = accept(listen_sock, NULL, NULL);
+ if (data_sock == -1) {
+ fuse_log(FUSE_LOG_ERR, "vhost socket accept: %m\n");
+ close(listen_sock);
+ return -1;
+ }
+ close(listen_sock);
+ fuse_log(FUSE_LOG_INFO, "%s: Received vhost-user socket connection\n",
+ __func__);
+
+ /* TODO: Some cleanup/deallocation! */
+ se->virtio_dev = calloc(sizeof(struct fv_VuDev), 1);
+ if (!se->virtio_dev) {
+ fuse_log(FUSE_LOG_ERR, "%s: virtio_dev calloc failed\n", __func__);
+ close(data_sock);
+ return -1;
+ }
+
+ se->vu_socketfd = data_sock;
+ se->virtio_dev->se = se;
+ vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, fv_set_watch,
+ fv_remove_watch, &fv_iface);
+
+ return 0;
}
diff --git a/tools/virtiofsd/fuse_virtio.h b/tools/virtiofsd/fuse_virtio.h
index 8f2edb69ca..23026d6e4c 100644
--- a/tools/virtiofsd/fuse_virtio.h
+++ b/tools/virtiofsd/fuse_virtio.h
@@ -20,4 +20,6 @@ struct fuse_session;
int virtio_session_mount(struct fuse_session *se);
+int virtio_loop(struct fuse_session *se);
+
#endif
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index fc9b264d56..037c5d7b26 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -36,6 +36,7 @@
*/
#include "qemu/osdep.h"
+#include "fuse_virtio.h"
#include "fuse_lowlevel.h"
#include <assert.h>
#include <dirent.h>
@@ -1395,11 +1396,7 @@ int main(int argc, char *argv[])
fuse_daemonize(opts.foreground);
/* Block until ctrl+c or fusermount -u */
- if (opts.singlethread) {
- ret = fuse_session_loop(se);
- } else {
- ret = fuse_session_loop_mt(se, opts.clone_fd);
- }
+ ret = virtio_loop(se);
fuse_session_unmount(se);
err_out3:
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 020/108] virtiofsd: Add main virtio loop
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (18 preceding siblings ...)
2020-01-23 16:45 ` [PULL 019/108] virtiofsd: Start wiring up vhost-user Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 021/108] virtiofsd: get/set features callbacks Dr. David Alan Gilbert (git)
` (89 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Processes incoming requests on the vhost-user fd.
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>
---
tools/virtiofsd/fuse_virtio.c | 42 ++++++++++++++++++++++++++++++++---
1 file changed, 39 insertions(+), 3 deletions(-)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 2ae3c764dd..1928a2025c 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -11,12 +11,14 @@
* See the file COPYING.LIB
*/
+#include "fuse_virtio.h"
#include "fuse_i.h"
#include "standard-headers/linux/fuse.h"
#include "fuse_misc.h"
#include "fuse_opt.h"
-#include "fuse_virtio.h"
+#include <assert.h>
+#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
@@ -80,15 +82,49 @@ static const VuDevIface fv_iface = {
.queue_is_processed_in_order = fv_queue_order,
};
+/*
+ * Main loop; this mostly deals with events on the vhost-user
+ * socket itself, and not actual fuse data.
+ */
int virtio_loop(struct fuse_session *se)
{
fuse_log(FUSE_LOG_INFO, "%s: Entry\n", __func__);
- while (1) {
- /* TODO: Add stuffing */
+ while (!fuse_session_exited(se)) {
+ struct pollfd pf[1];
+ pf[0].fd = se->vu_socketfd;
+ pf[0].events = POLLIN;
+ pf[0].revents = 0;
+
+ fuse_log(FUSE_LOG_DEBUG, "%s: Waiting for VU event\n", __func__);
+ int poll_res = ppoll(pf, 1, NULL, NULL);
+
+ if (poll_res == -1) {
+ if (errno == EINTR) {
+ fuse_log(FUSE_LOG_INFO, "%s: ppoll interrupted, going around\n",
+ __func__);
+ continue;
+ }
+ fuse_log(FUSE_LOG_ERR, "virtio_loop ppoll: %m\n");
+ break;
+ }
+ assert(poll_res == 1);
+ if (pf[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
+ fuse_log(FUSE_LOG_ERR, "%s: Unexpected poll revents %x\n", __func__,
+ pf[0].revents);
+ break;
+ }
+ assert(pf[0].revents & POLLIN);
+ fuse_log(FUSE_LOG_DEBUG, "%s: Got VU event\n", __func__);
+ if (!vu_dispatch(&se->virtio_dev->dev)) {
+ fuse_log(FUSE_LOG_ERR, "%s: vu_dispatch failed\n", __func__);
+ break;
+ }
}
fuse_log(FUSE_LOG_INFO, "%s: Exit\n", __func__);
+
+ return 0;
}
int virtio_session_mount(struct fuse_session *se)
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 021/108] virtiofsd: get/set features callbacks
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (19 preceding siblings ...)
2020-01-23 16:45 ` [PULL 020/108] virtiofsd: Add main virtio loop Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 022/108] virtiofsd: Start queue threads Dr. David Alan Gilbert (git)
` (88 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Add the get/set features callbacks.
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>
---
tools/virtiofsd/fuse_virtio.c | 15 ++++++++++++++-
1 file changed, 14 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 1928a2025c..4819e56568 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -46,6 +46,17 @@ struct virtio_fs_config {
uint32_t num_queues;
};
+/* Callback from libvhost-user */
+static uint64_t fv_get_features(VuDev *dev)
+{
+ return 1ULL << VIRTIO_F_VERSION_1;
+}
+
+/* Callback from libvhost-user */
+static void fv_set_features(VuDev *dev, uint64_t features)
+{
+}
+
/*
* Callback from libvhost-user if there's a new fd we're supposed to listen
* to, typically a queue kick?
@@ -78,7 +89,9 @@ static bool fv_queue_order(VuDev *dev, int qidx)
}
static const VuDevIface fv_iface = {
- /* TODO: Add other callbacks */
+ .get_features = fv_get_features,
+ .set_features = fv_set_features,
+
.queue_is_processed_in_order = fv_queue_order,
};
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 022/108] virtiofsd: Start queue threads
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (20 preceding siblings ...)
2020-01-23 16:45 ` [PULL 021/108] virtiofsd: get/set features callbacks Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 023/108] virtiofsd: Poll kick_fd for queue Dr. David Alan Gilbert (git)
` (87 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Start a thread for each queue when we get notified it's been started.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
fix by:
Signed-off-by: Jun Piao <piaojun@huawei.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_virtio.c | 89 +++++++++++++++++++++++++++++++++++
1 file changed, 89 insertions(+)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 4819e56568..2a94bb3cca 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -11,6 +11,7 @@
* See the file COPYING.LIB
*/
+#include "qemu/osdep.h"
#include "fuse_virtio.h"
#include "fuse_i.h"
#include "standard-headers/linux/fuse.h"
@@ -30,6 +31,15 @@
#include "contrib/libvhost-user/libvhost-user.h"
+struct fv_QueueInfo {
+ pthread_t thread;
+ struct fv_VuDev *virtio_dev;
+
+ /* Our queue index, corresponds to array position */
+ int qidx;
+ int kick_fd;
+};
+
/*
* We pass the dev element into libvhost-user
* and then use it to get back to the outer
@@ -38,6 +48,13 @@
struct fv_VuDev {
VuDev dev;
struct fuse_session *se;
+
+ /*
+ * The following pair of fields are only accessed in the main
+ * virtio_loop
+ */
+ size_t nqueues;
+ struct fv_QueueInfo **qi;
};
/* From spec */
@@ -83,6 +100,75 @@ static void fv_panic(VuDev *dev, const char *err)
exit(EXIT_FAILURE);
}
+static void *fv_queue_thread(void *opaque)
+{
+ struct fv_QueueInfo *qi = opaque;
+ fuse_log(FUSE_LOG_INFO, "%s: Start for queue %d kick_fd %d\n", __func__,
+ qi->qidx, qi->kick_fd);
+ while (1) {
+ /* TODO */
+ }
+
+ return NULL;
+}
+
+/* Callback from libvhost-user on start or stop of a queue */
+static void fv_queue_set_started(VuDev *dev, int qidx, bool started)
+{
+ struct fv_VuDev *vud = container_of(dev, struct fv_VuDev, dev);
+ struct fv_QueueInfo *ourqi;
+
+ fuse_log(FUSE_LOG_INFO, "%s: qidx=%d started=%d\n", __func__, qidx,
+ started);
+ assert(qidx >= 0);
+
+ /*
+ * Ignore additional request queues for now. passthrough_ll.c must be
+ * audited for thread-safety issues first. It was written with a
+ * well-behaved client in mind and may not protect against all types of
+ * races yet.
+ */
+ if (qidx > 1) {
+ fuse_log(FUSE_LOG_ERR,
+ "%s: multiple request queues not yet implemented, please only "
+ "configure 1 request queue\n",
+ __func__);
+ exit(EXIT_FAILURE);
+ }
+
+ if (started) {
+ /* Fire up a thread to watch this queue */
+ if (qidx >= vud->nqueues) {
+ vud->qi = realloc(vud->qi, (qidx + 1) * sizeof(vud->qi[0]));
+ assert(vud->qi);
+ memset(vud->qi + vud->nqueues, 0,
+ sizeof(vud->qi[0]) * (1 + (qidx - vud->nqueues)));
+ vud->nqueues = qidx + 1;
+ }
+ if (!vud->qi[qidx]) {
+ vud->qi[qidx] = calloc(sizeof(struct fv_QueueInfo), 1);
+ assert(vud->qi[qidx]);
+ vud->qi[qidx]->virtio_dev = vud;
+ vud->qi[qidx]->qidx = qidx;
+ } else {
+ /* Shouldn't have been started */
+ assert(vud->qi[qidx]->kick_fd == -1);
+ }
+ ourqi = vud->qi[qidx];
+ ourqi->kick_fd = dev->vq[qidx].kick_fd;
+ if (pthread_create(&ourqi->thread, NULL, fv_queue_thread, ourqi)) {
+ fuse_log(FUSE_LOG_ERR, "%s: Failed to create thread for queue %d\n",
+ __func__, qidx);
+ assert(0);
+ }
+ } else {
+ /* TODO: Kill the thread */
+ assert(qidx < vud->nqueues);
+ ourqi = vud->qi[qidx];
+ ourqi->kick_fd = -1;
+ }
+}
+
static bool fv_queue_order(VuDev *dev, int qidx)
{
return false;
@@ -92,6 +178,9 @@ static const VuDevIface fv_iface = {
.get_features = fv_get_features,
.set_features = fv_set_features,
+ /* Don't need process message, we've not got any at vhost-user level */
+ .queue_set_started = fv_queue_set_started,
+
.queue_is_processed_in_order = fv_queue_order,
};
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 023/108] virtiofsd: Poll kick_fd for queue
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (21 preceding siblings ...)
2020-01-23 16:45 ` [PULL 022/108] virtiofsd: Start queue threads Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 024/108] virtiofsd: Start reading commands from queue Dr. David Alan Gilbert (git)
` (86 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
In the queue thread poll the kick_fd we're passed.
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>
---
tools/virtiofsd/fuse_virtio.c | 40 ++++++++++++++++++++++++++++++++++-
1 file changed, 39 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 2a94bb3cca..05e7258712 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -24,6 +24,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/eventfd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
@@ -100,13 +101,50 @@ static void fv_panic(VuDev *dev, const char *err)
exit(EXIT_FAILURE);
}
+/* Thread function for individual queues, created when a queue is 'started' */
static void *fv_queue_thread(void *opaque)
{
struct fv_QueueInfo *qi = opaque;
fuse_log(FUSE_LOG_INFO, "%s: Start for queue %d kick_fd %d\n", __func__,
qi->qidx, qi->kick_fd);
while (1) {
- /* TODO */
+ struct pollfd pf[1];
+ pf[0].fd = qi->kick_fd;
+ pf[0].events = POLLIN;
+ pf[0].revents = 0;
+
+ fuse_log(FUSE_LOG_DEBUG, "%s: Waiting for Queue %d event\n", __func__,
+ qi->qidx);
+ int poll_res = ppoll(pf, 1, NULL, NULL);
+
+ if (poll_res == -1) {
+ if (errno == EINTR) {
+ fuse_log(FUSE_LOG_INFO, "%s: ppoll interrupted, going around\n",
+ __func__);
+ continue;
+ }
+ fuse_log(FUSE_LOG_ERR, "fv_queue_thread ppoll: %m\n");
+ break;
+ }
+ assert(poll_res == 1);
+ if (pf[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
+ fuse_log(FUSE_LOG_ERR, "%s: Unexpected poll revents %x Queue %d\n",
+ __func__, pf[0].revents, qi->qidx);
+ break;
+ }
+ assert(pf[0].revents & POLLIN);
+ fuse_log(FUSE_LOG_DEBUG, "%s: Got queue event on Queue %d\n", __func__,
+ qi->qidx);
+
+ eventfd_t evalue;
+ if (eventfd_read(qi->kick_fd, &evalue)) {
+ fuse_log(FUSE_LOG_ERR, "Eventfd_read for queue: %m\n");
+ break;
+ }
+ if (qi->virtio_dev->se->debug) {
+ fprintf(stderr, "%s: Queue %d gave evalue: %zx\n", __func__,
+ qi->qidx, (size_t)evalue);
+ }
}
return NULL;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 024/108] virtiofsd: Start reading commands from queue
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (22 preceding siblings ...)
2020-01-23 16:45 ` [PULL 023/108] virtiofsd: Poll kick_fd for queue Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 025/108] virtiofsd: Send replies to messages Dr. David Alan Gilbert (git)
` (85 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Pop queue elements off queues, copy the data from them and
pass that to fuse.
Note: 'out' in a VuVirtqElement is from QEMU
'in' in libfuse is into the daemon
So we read from the out iov's to get a fuse_in_header
When we get a kick we've got to read all the elements until the queue
is empty.
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>
---
tools/virtiofsd/fuse_i.h | 2 +
tools/virtiofsd/fuse_virtio.c | 99 +++++++++++++++++++++++++++++++++--
2 files changed, 98 insertions(+), 3 deletions(-)
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index ec04449069..1126723d18 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -14,6 +14,7 @@
#include "fuse_lowlevel.h"
struct fv_VuDev;
+struct fv_QueueInfo;
struct fuse_req {
struct fuse_session *se;
@@ -75,6 +76,7 @@ struct fuse_chan {
pthread_mutex_t lock;
int ctr;
int fd;
+ struct fv_QueueInfo *qi;
};
/**
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 05e7258712..3841b20129 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -12,6 +12,7 @@
*/
#include "qemu/osdep.h"
+#include "qemu/iov.h"
#include "fuse_virtio.h"
#include "fuse_i.h"
#include "standard-headers/linux/fuse.h"
@@ -32,6 +33,7 @@
#include "contrib/libvhost-user/libvhost-user.h"
+struct fv_VuDev;
struct fv_QueueInfo {
pthread_t thread;
struct fv_VuDev *virtio_dev;
@@ -101,10 +103,41 @@ static void fv_panic(VuDev *dev, const char *err)
exit(EXIT_FAILURE);
}
+/*
+ * Copy from an iovec into a fuse_buf (memory only)
+ * Caller must ensure there is space
+ */
+static void copy_from_iov(struct fuse_buf *buf, size_t out_num,
+ const struct iovec *out_sg)
+{
+ void *dest = buf->mem;
+
+ while (out_num) {
+ size_t onelen = out_sg->iov_len;
+ memcpy(dest, out_sg->iov_base, onelen);
+ dest += onelen;
+ out_sg++;
+ out_num--;
+ }
+}
+
/* Thread function for individual queues, created when a queue is 'started' */
static void *fv_queue_thread(void *opaque)
{
struct fv_QueueInfo *qi = opaque;
+ struct VuDev *dev = &qi->virtio_dev->dev;
+ struct VuVirtq *q = vu_get_queue(dev, qi->qidx);
+ struct fuse_session *se = qi->virtio_dev->se;
+ struct fuse_chan ch;
+ struct fuse_buf fbuf;
+
+ fbuf.mem = NULL;
+ fbuf.flags = 0;
+
+ fuse_mutex_init(&ch.lock);
+ ch.fd = (int)0xdaff0d111;
+ ch.qi = qi;
+
fuse_log(FUSE_LOG_INFO, "%s: Start for queue %d kick_fd %d\n", __func__,
qi->qidx, qi->kick_fd);
while (1) {
@@ -141,11 +174,71 @@ static void *fv_queue_thread(void *opaque)
fuse_log(FUSE_LOG_ERR, "Eventfd_read for queue: %m\n");
break;
}
- if (qi->virtio_dev->se->debug) {
- fprintf(stderr, "%s: Queue %d gave evalue: %zx\n", __func__,
- qi->qidx, (size_t)evalue);
+ /* out is from guest, in is too guest */
+ unsigned int in_bytes, out_bytes;
+ vu_queue_get_avail_bytes(dev, q, &in_bytes, &out_bytes, ~0, ~0);
+
+ fuse_log(FUSE_LOG_DEBUG,
+ "%s: Queue %d gave evalue: %zx available: in: %u out: %u\n",
+ __func__, qi->qidx, (size_t)evalue, in_bytes, out_bytes);
+
+ while (1) {
+ /*
+ * An element contains one request and the space to send our
+ * response They're spread over multiple descriptors in a
+ * scatter/gather set and we can't trust the guest to keep them
+ * still; so copy in/out.
+ */
+ VuVirtqElement *elem = vu_queue_pop(dev, q, sizeof(VuVirtqElement));
+ if (!elem) {
+ break;
+ }
+
+ if (!fbuf.mem) {
+ fbuf.mem = malloc(se->bufsize);
+ assert(fbuf.mem);
+ assert(se->bufsize > sizeof(struct fuse_in_header));
+ }
+ /* The 'out' part of the elem is from qemu */
+ unsigned int out_num = elem->out_num;
+ struct iovec *out_sg = elem->out_sg;
+ size_t out_len = iov_size(out_sg, out_num);
+ fuse_log(FUSE_LOG_DEBUG,
+ "%s: elem %d: with %d out desc of length %zd\n", __func__,
+ elem->index, out_num, out_len);
+
+ /*
+ * The elem should contain a 'fuse_in_header' (in to fuse)
+ * plus the data based on the len in the header.
+ */
+ if (out_len < sizeof(struct fuse_in_header)) {
+ fuse_log(FUSE_LOG_ERR, "%s: elem %d too short for in_header\n",
+ __func__, elem->index);
+ assert(0); /* TODO */
+ }
+ if (out_len > se->bufsize) {
+ fuse_log(FUSE_LOG_ERR, "%s: elem %d too large for buffer\n",
+ __func__, elem->index);
+ assert(0); /* TODO */
+ }
+ copy_from_iov(&fbuf, out_num, out_sg);
+ fbuf.size = out_len;
+
+ /* TODO! Endianness of header */
+
+ /* TODO: Fixup fuse_send_msg */
+ /* TODO: Add checks for fuse_session_exited */
+ fuse_session_process_buf_int(se, &fbuf, &ch);
+
+ /* TODO: vu_queue_push(dev, q, elem, qi->write_count); */
+ vu_queue_notify(dev, q);
+
+ free(elem);
+ elem = NULL;
}
}
+ pthread_mutex_destroy(&ch.lock);
+ free(fbuf.mem);
return NULL;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 025/108] virtiofsd: Send replies to messages
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (23 preceding siblings ...)
2020-01-23 16:45 ` [PULL 024/108] virtiofsd: Start reading commands from queue Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 026/108] virtiofsd: Keep track of replies Dr. David Alan Gilbert (git)
` (84 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Route fuse out messages back through the same queue elements
that had the command that triggered the request.
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>
---
tools/virtiofsd/fuse_lowlevel.c | 4 ++
tools/virtiofsd/fuse_virtio.c | 107 ++++++++++++++++++++++++++++++--
tools/virtiofsd/fuse_virtio.h | 4 ++
3 files changed, 111 insertions(+), 4 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index af09fa2b94..380d93bd01 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -171,6 +171,10 @@ static int fuse_send_msg(struct fuse_session *se, struct fuse_chan *ch,
}
}
+ if (fuse_lowlevel_is_virtio(se)) {
+ return virtio_send_msg(se, ch, iov, count);
+ }
+
abort(); /* virtio should have taken it before here */
return 0;
}
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 3841b20129..05d0e29f12 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -41,6 +41,9 @@ struct fv_QueueInfo {
/* Our queue index, corresponds to array position */
int qidx;
int kick_fd;
+
+ /* The element for the command currently being processed */
+ VuVirtqElement *qe;
};
/*
@@ -121,6 +124,105 @@ static void copy_from_iov(struct fuse_buf *buf, size_t out_num,
}
}
+/*
+ * Copy from one iov to another, the given number of bytes
+ * The caller must have checked sizes.
+ */
+static void copy_iov(struct iovec *src_iov, int src_count,
+ struct iovec *dst_iov, int dst_count, size_t to_copy)
+{
+ size_t dst_offset = 0;
+ /* Outer loop copies 'src' elements */
+ while (to_copy) {
+ assert(src_count);
+ size_t src_len = src_iov[0].iov_len;
+ size_t src_offset = 0;
+
+ if (src_len > to_copy) {
+ src_len = to_copy;
+ }
+ /* Inner loop copies contents of one 'src' to maybe multiple dst. */
+ while (src_len) {
+ assert(dst_count);
+ size_t dst_len = dst_iov[0].iov_len - dst_offset;
+ if (dst_len > src_len) {
+ dst_len = src_len;
+ }
+
+ memcpy(dst_iov[0].iov_base + dst_offset,
+ src_iov[0].iov_base + src_offset, dst_len);
+ src_len -= dst_len;
+ to_copy -= dst_len;
+ src_offset += dst_len;
+ dst_offset += dst_len;
+
+ assert(dst_offset <= dst_iov[0].iov_len);
+ if (dst_offset == dst_iov[0].iov_len) {
+ dst_offset = 0;
+ dst_iov++;
+ dst_count--;
+ }
+ }
+ src_iov++;
+ src_count--;
+ }
+}
+
+/*
+ * Called back by ll whenever it wants to send a reply/message back
+ * The 1st element of the iov starts with the fuse_out_header
+ * 'unique'==0 means it's a notify message.
+ */
+int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
+ struct iovec *iov, int count)
+{
+ VuVirtqElement *elem;
+ VuVirtq *q;
+
+ assert(count >= 1);
+ assert(iov[0].iov_len >= sizeof(struct fuse_out_header));
+
+ struct fuse_out_header *out = iov[0].iov_base;
+ /* TODO: Endianness! */
+
+ size_t tosend_len = iov_size(iov, count);
+
+ /* unique == 0 is notification, which we don't support */
+ assert(out->unique);
+ /* For virtio we always have ch */
+ assert(ch);
+ elem = ch->qi->qe;
+ q = &ch->qi->virtio_dev->dev.vq[ch->qi->qidx];
+
+ /* The 'in' part of the elem is to qemu */
+ unsigned int in_num = elem->in_num;
+ struct iovec *in_sg = elem->in_sg;
+ size_t in_len = iov_size(in_sg, in_num);
+ fuse_log(FUSE_LOG_DEBUG, "%s: elem %d: with %d in desc of length %zd\n",
+ __func__, elem->index, in_num, in_len);
+
+ /*
+ * The elem should have room for a 'fuse_out_header' (out from fuse)
+ * plus the data based on the len in the header.
+ */
+ if (in_len < sizeof(struct fuse_out_header)) {
+ fuse_log(FUSE_LOG_ERR, "%s: elem %d too short for out_header\n",
+ __func__, elem->index);
+ return -E2BIG;
+ }
+ if (in_len < tosend_len) {
+ fuse_log(FUSE_LOG_ERR, "%s: elem %d too small for data len %zd\n",
+ __func__, elem->index, tosend_len);
+ return -E2BIG;
+ }
+
+ copy_iov(iov, count, in_sg, in_num, tosend_len);
+ vu_queue_push(&se->virtio_dev->dev, q, elem, tosend_len);
+ vu_queue_notify(&se->virtio_dev->dev, q);
+
+ return 0;
+}
+
/* Thread function for individual queues, created when a queue is 'started' */
static void *fv_queue_thread(void *opaque)
{
@@ -226,13 +328,10 @@ static void *fv_queue_thread(void *opaque)
/* TODO! Endianness of header */
- /* TODO: Fixup fuse_send_msg */
/* TODO: Add checks for fuse_session_exited */
fuse_session_process_buf_int(se, &fbuf, &ch);
- /* TODO: vu_queue_push(dev, q, elem, qi->write_count); */
- vu_queue_notify(dev, q);
-
+ qi->qe = NULL;
free(elem);
elem = NULL;
}
diff --git a/tools/virtiofsd/fuse_virtio.h b/tools/virtiofsd/fuse_virtio.h
index 23026d6e4c..135a14875a 100644
--- a/tools/virtiofsd/fuse_virtio.h
+++ b/tools/virtiofsd/fuse_virtio.h
@@ -22,4 +22,8 @@ int virtio_session_mount(struct fuse_session *se);
int virtio_loop(struct fuse_session *se);
+
+int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
+ struct iovec *iov, int count);
+
#endif
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 026/108] virtiofsd: Keep track of replies
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (24 preceding siblings ...)
2020-01-23 16:45 ` [PULL 025/108] virtiofsd: Send replies to messages Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 027/108] virtiofsd: Add Makefile wiring for virtiofsd contrib Dr. David Alan Gilbert (git)
` (83 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Keep track of whether we sent a reply to a request; this is a bit
paranoid but it means:
a) We should always recycle an element even if there was an error
in the request
b) Never try and send two replies on one queue element
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>
---
tools/virtiofsd/fuse_virtio.c | 23 ++++++++++++++++++++---
1 file changed, 20 insertions(+), 3 deletions(-)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 05d0e29f12..f1adeb6345 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -44,6 +44,7 @@ struct fv_QueueInfo {
/* The element for the command currently being processed */
VuVirtqElement *qe;
+ bool reply_sent;
};
/*
@@ -178,6 +179,7 @@ int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
{
VuVirtqElement *elem;
VuVirtq *q;
+ int ret = 0;
assert(count >= 1);
assert(iov[0].iov_len >= sizeof(struct fuse_out_header));
@@ -191,6 +193,7 @@ int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
assert(out->unique);
/* For virtio we always have ch */
assert(ch);
+ assert(!ch->qi->reply_sent);
elem = ch->qi->qe;
q = &ch->qi->virtio_dev->dev.vq[ch->qi->qidx];
@@ -208,19 +211,23 @@ int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
if (in_len < sizeof(struct fuse_out_header)) {
fuse_log(FUSE_LOG_ERR, "%s: elem %d too short for out_header\n",
__func__, elem->index);
- return -E2BIG;
+ ret = -E2BIG;
+ goto err;
}
if (in_len < tosend_len) {
fuse_log(FUSE_LOG_ERR, "%s: elem %d too small for data len %zd\n",
__func__, elem->index, tosend_len);
- return -E2BIG;
+ ret = -E2BIG;
+ goto err;
}
copy_iov(iov, count, in_sg, in_num, tosend_len);
vu_queue_push(&se->virtio_dev->dev, q, elem, tosend_len);
vu_queue_notify(&se->virtio_dev->dev, q);
+ ch->qi->reply_sent = true;
- return 0;
+err:
+ return ret;
}
/* Thread function for individual queues, created when a queue is 'started' */
@@ -296,6 +303,9 @@ static void *fv_queue_thread(void *opaque)
break;
}
+ qi->qe = elem;
+ qi->reply_sent = false;
+
if (!fbuf.mem) {
fbuf.mem = malloc(se->bufsize);
assert(fbuf.mem);
@@ -331,6 +341,13 @@ static void *fv_queue_thread(void *opaque)
/* TODO: Add checks for fuse_session_exited */
fuse_session_process_buf_int(se, &fbuf, &ch);
+ if (!qi->reply_sent) {
+ fuse_log(FUSE_LOG_DEBUG, "%s: elem %d no reply sent\n",
+ __func__, elem->index);
+ /* I think we've still got to recycle the element */
+ vu_queue_push(dev, q, elem, 0);
+ vu_queue_notify(dev, q);
+ }
qi->qe = NULL;
free(elem);
elem = NULL;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 027/108] virtiofsd: Add Makefile wiring for virtiofsd contrib
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (25 preceding siblings ...)
2020-01-23 16:45 ` [PULL 026/108] virtiofsd: Keep track of replies Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 028/108] virtiofsd: Fast path for virtio read Dr. David Alan Gilbert (git)
` (82 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Wire up the building of the virtiofsd in tools.
virtiofsd relies on Linux-specific system calls and seccomp. Anyone
wishing to port it to other host operating systems should do so
carefully and without reducing security.
Only allow building on Linux hosts.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Liam Merwick <liam.merwick@oracle.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
Makefile | 10 ++++++++++
Makefile.objs | 1 +
tools/virtiofsd/Makefile.objs | 9 +++++++++
3 files changed, 20 insertions(+)
create mode 100644 tools/virtiofsd/Makefile.objs
diff --git a/Makefile b/Makefile
index 6562b0dc97..ef1e2155a7 100644
--- a/Makefile
+++ b/Makefile
@@ -327,6 +327,10 @@ HELPERS-y += vhost-user-gpu$(EXESUF)
vhost-user-json-y += contrib/vhost-user-gpu/50-qemu-gpu.json
endif
+ifdef CONFIG_LINUX
+HELPERS-y += virtiofsd$(EXESUF)
+endif
+
# Sphinx does not allow building manuals into the same directory as
# the source files, so if we're doing an in-tree QEMU build we must
# build the manuals into a subdirectory (and then install them from
@@ -429,6 +433,7 @@ dummy := $(call unnest-vars,, \
elf2dmp-obj-y \
ivshmem-client-obj-y \
ivshmem-server-obj-y \
+ virtiofsd-obj-y \
rdmacm-mux-obj-y \
libvhost-user-obj-y \
vhost-user-scsi-obj-y \
@@ -668,6 +673,11 @@ rdmacm-mux$(EXESUF): LIBS += "-libumad"
rdmacm-mux$(EXESUF): $(rdmacm-mux-obj-y) $(COMMON_LDADDS)
$(call LINK, $^)
+ifdef CONFIG_LINUX # relies on Linux-specific syscalls
+virtiofsd$(EXESUF): $(virtiofsd-obj-y) libvhost-user.a $(COMMON_LDADDS)
+ $(call LINK, $^)
+endif
+
vhost-user-gpu$(EXESUF): $(vhost-user-gpu-obj-y) $(libvhost-user-obj-y) libqemuutil.a libqemustub.a
$(call LINK, $^)
diff --git a/Makefile.objs b/Makefile.objs
index 7c1e50f9d6..ff396b9209 100644
--- a/Makefile.objs
+++ b/Makefile.objs
@@ -123,6 +123,7 @@ vhost-user-blk-obj-y = contrib/vhost-user-blk/
rdmacm-mux-obj-y = contrib/rdmacm-mux/
vhost-user-input-obj-y = contrib/vhost-user-input/
vhost-user-gpu-obj-y = contrib/vhost-user-gpu/
+virtiofsd-obj-y = tools/virtiofsd/
######################################################################
trace-events-subdirs =
diff --git a/tools/virtiofsd/Makefile.objs b/tools/virtiofsd/Makefile.objs
new file mode 100644
index 0000000000..45a807500d
--- /dev/null
+++ b/tools/virtiofsd/Makefile.objs
@@ -0,0 +1,9 @@
+virtiofsd-obj-y = buffer.o \
+ fuse_opt.o \
+ fuse_log.o \
+ fuse_lowlevel.o \
+ fuse_signals.o \
+ fuse_virtio.o \
+ helper.o \
+ passthrough_ll.o
+
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 028/108] virtiofsd: Fast path for virtio read
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (26 preceding siblings ...)
2020-01-23 16:45 ` [PULL 027/108] virtiofsd: Add Makefile wiring for virtiofsd contrib Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 029/108] virtiofsd: add --fd=FDNUM fd passing option Dr. David Alan Gilbert (git)
` (81 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Readv the data straight into the guests buffer.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
With fix by:
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 5 +
tools/virtiofsd/fuse_virtio.c | 162 ++++++++++++++++++++++++++++++++
tools/virtiofsd/fuse_virtio.h | 4 +
3 files changed, 171 insertions(+)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 380d93bd01..4f4684d942 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -475,6 +475,11 @@ static int fuse_send_data_iov_fallback(struct fuse_session *se,
return fuse_send_msg(se, ch, iov, iov_count);
}
+ if (fuse_lowlevel_is_virtio(se) && buf->count == 1 &&
+ buf->buf[0].flags == (FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK)) {
+ return virtio_send_data_iov(se, ch, iov, iov_count, buf, len);
+ }
+
abort(); /* Will have taken vhost path */
return 0;
}
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index f1adeb6345..7e2711b504 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -230,6 +230,168 @@ err:
return ret;
}
+/*
+ * Callback from fuse_send_data_iov_* when it's virtio and the buffer
+ * is a single FD with FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK
+ * We need send the iov and then the buffer.
+ * Return 0 on success
+ */
+int virtio_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
+ struct iovec *iov, int count, struct fuse_bufvec *buf,
+ size_t len)
+{
+ int ret = 0;
+ VuVirtqElement *elem;
+ VuVirtq *q;
+
+ assert(count >= 1);
+ assert(iov[0].iov_len >= sizeof(struct fuse_out_header));
+
+ struct fuse_out_header *out = iov[0].iov_base;
+ /* TODO: Endianness! */
+
+ size_t iov_len = iov_size(iov, count);
+ size_t tosend_len = iov_len + len;
+
+ out->len = tosend_len;
+
+ fuse_log(FUSE_LOG_DEBUG, "%s: count=%d len=%zd iov_len=%zd\n", __func__,
+ count, len, iov_len);
+
+ /* unique == 0 is notification which we don't support */
+ assert(out->unique);
+
+ /* For virtio we always have ch */
+ assert(ch);
+ assert(!ch->qi->reply_sent);
+ elem = ch->qi->qe;
+ q = &ch->qi->virtio_dev->dev.vq[ch->qi->qidx];
+
+ /* The 'in' part of the elem is to qemu */
+ unsigned int in_num = elem->in_num;
+ struct iovec *in_sg = elem->in_sg;
+ size_t in_len = iov_size(in_sg, in_num);
+ fuse_log(FUSE_LOG_DEBUG, "%s: elem %d: with %d in desc of length %zd\n",
+ __func__, elem->index, in_num, in_len);
+
+ /*
+ * The elem should have room for a 'fuse_out_header' (out from fuse)
+ * plus the data based on the len in the header.
+ */
+ if (in_len < sizeof(struct fuse_out_header)) {
+ fuse_log(FUSE_LOG_ERR, "%s: elem %d too short for out_header\n",
+ __func__, elem->index);
+ ret = E2BIG;
+ goto err;
+ }
+ if (in_len < tosend_len) {
+ fuse_log(FUSE_LOG_ERR, "%s: elem %d too small for data len %zd\n",
+ __func__, elem->index, tosend_len);
+ ret = E2BIG;
+ goto err;
+ }
+
+ /* TODO: Limit to 'len' */
+
+ /* First copy the header data from iov->in_sg */
+ copy_iov(iov, count, in_sg, in_num, iov_len);
+
+ /*
+ * Build a copy of the the in_sg iov so we can skip bits in it,
+ * including changing the offsets
+ */
+ struct iovec *in_sg_cpy = calloc(sizeof(struct iovec), in_num);
+ assert(in_sg_cpy);
+ memcpy(in_sg_cpy, in_sg, sizeof(struct iovec) * in_num);
+ /* These get updated as we skip */
+ struct iovec *in_sg_ptr = in_sg_cpy;
+ int in_sg_cpy_count = in_num;
+
+ /* skip over parts of in_sg that contained the header iov */
+ size_t skip_size = iov_len;
+
+ size_t in_sg_left = 0;
+ do {
+ while (skip_size != 0 && in_sg_cpy_count) {
+ if (skip_size >= in_sg_ptr[0].iov_len) {
+ skip_size -= in_sg_ptr[0].iov_len;
+ in_sg_ptr++;
+ in_sg_cpy_count--;
+ } else {
+ in_sg_ptr[0].iov_len -= skip_size;
+ in_sg_ptr[0].iov_base += skip_size;
+ break;
+ }
+ }
+
+ int i;
+ for (i = 0, in_sg_left = 0; i < in_sg_cpy_count; i++) {
+ in_sg_left += in_sg_ptr[i].iov_len;
+ }
+ fuse_log(FUSE_LOG_DEBUG,
+ "%s: after skip skip_size=%zd in_sg_cpy_count=%d "
+ "in_sg_left=%zd\n",
+ __func__, skip_size, in_sg_cpy_count, in_sg_left);
+ ret = preadv(buf->buf[0].fd, in_sg_ptr, in_sg_cpy_count,
+ buf->buf[0].pos);
+
+ if (ret == -1) {
+ ret = errno;
+ fuse_log(FUSE_LOG_DEBUG, "%s: preadv failed (%m) len=%zd\n",
+ __func__, len);
+ free(in_sg_cpy);
+ goto err;
+ }
+ fuse_log(FUSE_LOG_DEBUG, "%s: preadv ret=%d len=%zd\n", __func__,
+ ret, len);
+ if (ret < len && ret) {
+ fuse_log(FUSE_LOG_DEBUG, "%s: ret < len\n", __func__);
+ /* Skip over this much next time around */
+ skip_size = ret;
+ buf->buf[0].pos += ret;
+ len -= ret;
+
+ /* Lets do another read */
+ continue;
+ }
+ if (!ret) {
+ /* EOF case? */
+ fuse_log(FUSE_LOG_DEBUG, "%s: !ret in_sg_left=%zd\n", __func__,
+ in_sg_left);
+ break;
+ }
+ if (ret != len) {
+ fuse_log(FUSE_LOG_DEBUG, "%s: ret!=len\n", __func__);
+ ret = EIO;
+ free(in_sg_cpy);
+ goto err;
+ }
+ in_sg_left -= ret;
+ len -= ret;
+ } while (in_sg_left);
+ free(in_sg_cpy);
+
+ /* Need to fix out->len on EOF */
+ if (len) {
+ struct fuse_out_header *out_sg = in_sg[0].iov_base;
+
+ tosend_len -= len;
+ out_sg->len = tosend_len;
+ }
+
+ ret = 0;
+
+ vu_queue_push(&se->virtio_dev->dev, q, elem, tosend_len);
+ vu_queue_notify(&se->virtio_dev->dev, q);
+
+err:
+ if (ret == 0) {
+ ch->qi->reply_sent = true;
+ }
+
+ return ret;
+}
+
/* Thread function for individual queues, created when a queue is 'started' */
static void *fv_queue_thread(void *opaque)
{
diff --git a/tools/virtiofsd/fuse_virtio.h b/tools/virtiofsd/fuse_virtio.h
index 135a14875a..cc676b9193 100644
--- a/tools/virtiofsd/fuse_virtio.h
+++ b/tools/virtiofsd/fuse_virtio.h
@@ -26,4 +26,8 @@ int virtio_loop(struct fuse_session *se);
int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
struct iovec *iov, int count);
+int virtio_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
+ struct iovec *iov, int count,
+ struct fuse_bufvec *buf, size_t len);
+
#endif
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 029/108] virtiofsd: add --fd=FDNUM fd passing option
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (27 preceding siblings ...)
2020-01-23 16:45 ` [PULL 028/108] virtiofsd: Fast path for virtio read Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 030/108] virtiofsd: make -f (foreground) the default Dr. David Alan Gilbert (git)
` (80 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Although --socket-path=PATH is useful for manual invocations, management
tools typically create the UNIX domain socket themselves and pass it to
the vhost-user device backend. This way QEMU can be launched
immediately with a valid socket. No waiting for the vhost-user device
backend is required when fd passing is used.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_i.h | 1 +
tools/virtiofsd/fuse_lowlevel.c | 16 ++++++++++++----
tools/virtiofsd/fuse_virtio.c | 31 +++++++++++++++++++++++++------
3 files changed, 38 insertions(+), 10 deletions(-)
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index 1126723d18..45995f3246 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -68,6 +68,7 @@ struct fuse_session {
size_t bufsize;
int error;
char *vu_socket_path;
+ int vu_listen_fd;
int vu_socketfd;
struct fv_VuDev *virtio_dev;
};
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 4f4684d942..95f4db8fcf 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2130,6 +2130,7 @@ static const struct fuse_opt fuse_ll_opts[] = {
LL_OPTION("--debug", debug, 1),
LL_OPTION("allow_root", deny_others, 1),
LL_OPTION("--socket-path=%s", vu_socket_path, 0),
+ LL_OPTION("--fd=%d", vu_listen_fd, 0),
FUSE_OPT_END
};
@@ -2147,7 +2148,8 @@ void fuse_lowlevel_help(void)
*/
printf(
" -o allow_root allow access by root\n"
- " --socket-path=PATH path for the vhost-user socket\n");
+ " --socket-path=PATH path for the vhost-user socket\n"
+ " --fd=FDNUM fd number of vhost-user socket\n");
}
void fuse_session_destroy(struct fuse_session *se)
@@ -2191,6 +2193,7 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
goto out1;
}
se->fd = -1;
+ se->vu_listen_fd = -1;
se->conn.max_write = UINT_MAX;
se->conn.max_readahead = UINT_MAX;
@@ -2212,8 +2215,13 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
goto out4;
}
- if (!se->vu_socket_path) {
- fprintf(stderr, "fuse: missing -o vhost_user_socket option\n");
+ if (!se->vu_socket_path && se->vu_listen_fd < 0) {
+ fuse_log(FUSE_LOG_ERR, "fuse: missing --socket-path or --fd option\n");
+ goto out4;
+ }
+ if (se->vu_socket_path && se->vu_listen_fd >= 0) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: --socket-path and --fd cannot be given together\n");
goto out4;
}
@@ -2253,7 +2261,7 @@ void fuse_session_unmount(struct fuse_session *se)
int fuse_lowlevel_is_virtio(struct fuse_session *se)
{
- return se->vu_socket_path != NULL;
+ return !!se->virtio_dev;
}
#ifdef linux
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 7e2711b504..635f87756a 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -638,18 +638,21 @@ int virtio_loop(struct fuse_session *se)
return 0;
}
-int virtio_session_mount(struct fuse_session *se)
+static int fv_create_listen_socket(struct fuse_session *se)
{
struct sockaddr_un un;
mode_t old_umask;
+ /* Nothing to do if fd is already initialized */
+ if (se->vu_listen_fd >= 0) {
+ return 0;
+ }
+
if (strlen(se->vu_socket_path) >= sizeof(un.sun_path)) {
fuse_log(FUSE_LOG_ERR, "Socket path too long\n");
return -1;
}
- se->fd = -1;
-
/*
* Create the Unix socket to communicate with qemu
* based on QEMU's vhost-user-bridge
@@ -682,15 +685,31 @@ int virtio_session_mount(struct fuse_session *se)
return -1;
}
+ se->vu_listen_fd = listen_sock;
+ return 0;
+}
+
+int virtio_session_mount(struct fuse_session *se)
+{
+ int ret;
+
+ ret = fv_create_listen_socket(se);
+ if (ret < 0) {
+ return ret;
+ }
+
+ se->fd = -1;
+
fuse_log(FUSE_LOG_INFO, "%s: Waiting for vhost-user socket connection...\n",
__func__);
- int data_sock = accept(listen_sock, NULL, NULL);
+ int data_sock = accept(se->vu_listen_fd, NULL, NULL);
if (data_sock == -1) {
fuse_log(FUSE_LOG_ERR, "vhost socket accept: %m\n");
- close(listen_sock);
+ close(se->vu_listen_fd);
return -1;
}
- close(listen_sock);
+ close(se->vu_listen_fd);
+ se->vu_listen_fd = -1;
fuse_log(FUSE_LOG_INFO, "%s: Received vhost-user socket connection\n",
__func__);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 030/108] virtiofsd: make -f (foreground) the default
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (28 preceding siblings ...)
2020-01-23 16:45 ` [PULL 029/108] virtiofsd: add --fd=FDNUM fd passing option Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 031/108] virtiofsd: add vhost-user.json file Dr. David Alan Gilbert (git)
` (79 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
According to vhost-user.rst "Backend program conventions", backend
programs should run in the foregound by default. Follow the
conventions so libvirt and other management tools can control virtiofsd
in a standard way.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/helper.c | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 676032e71f..a3645fc807 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -29,6 +29,11 @@
{ \
t, offsetof(struct fuse_cmdline_opts, p), 1 \
}
+#define FUSE_HELPER_OPT_VALUE(t, p, v) \
+ { \
+ t, offsetof(struct fuse_cmdline_opts, p), v \
+ }
+
static const struct fuse_opt fuse_helper_opts[] = {
FUSE_HELPER_OPT("-h", show_help),
@@ -42,6 +47,7 @@ static const struct fuse_opt fuse_helper_opts[] = {
FUSE_OPT_KEY("-d", FUSE_OPT_KEY_KEEP),
FUSE_OPT_KEY("debug", FUSE_OPT_KEY_KEEP),
FUSE_HELPER_OPT("-f", foreground),
+ FUSE_HELPER_OPT_VALUE("--daemonize", foreground, 0),
FUSE_HELPER_OPT("fsname=", nodefault_subtype),
FUSE_OPT_KEY("fsname=", FUSE_OPT_KEY_KEEP),
FUSE_HELPER_OPT("subtype=", nodefault_subtype),
@@ -131,6 +137,7 @@ void fuse_cmdline_help(void)
" -V --version print version\n"
" -d -o debug enable debug output (implies -f)\n"
" -f foreground operation\n"
+ " --daemonize run in background\n"
" -o max_idle_threads the maximum number of idle worker "
"threads\n"
" allowed (default: 10)\n");
@@ -158,6 +165,7 @@ int fuse_parse_cmdline(struct fuse_args *args, struct fuse_cmdline_opts *opts)
memset(opts, 0, sizeof(struct fuse_cmdline_opts));
opts->max_idle_threads = 10;
+ opts->foreground = 1;
if (fuse_opt_parse(args, opts, fuse_helper_opts, fuse_helper_opt_proc) ==
-1) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 031/108] virtiofsd: add vhost-user.json file
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (29 preceding siblings ...)
2020-01-23 16:45 ` [PULL 030/108] virtiofsd: make -f (foreground) the default Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 032/108] virtiofsd: add --print-capabilities option Dr. David Alan Gilbert (git)
` (78 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Install a vhost-user.json file describing virtiofsd. This allows
libvirt and other management tools to enumerate vhost-user backend
programs.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
.gitignore | 1 +
Makefile | 1 +
tools/virtiofsd/50-qemu-virtiofsd.json.in | 5 +++++
3 files changed, 7 insertions(+)
create mode 100644 tools/virtiofsd/50-qemu-virtiofsd.json.in
diff --git a/.gitignore b/.gitignore
index efad605e1a..bc0a035f9c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@
/config-target.*
/config.status
/config-temp
+/tools/virtiofsd/50-qemu-virtiofsd.json
/elf2dmp
/trace-events-all
/trace/generated-events.h
diff --git a/Makefile b/Makefile
index ef1e2155a7..2f81271ee7 100644
--- a/Makefile
+++ b/Makefile
@@ -329,6 +329,7 @@ endif
ifdef CONFIG_LINUX
HELPERS-y += virtiofsd$(EXESUF)
+vhost-user-json-y += tools/virtiofsd/50-qemu-virtiofsd.json
endif
# Sphinx does not allow building manuals into the same directory as
diff --git a/tools/virtiofsd/50-qemu-virtiofsd.json.in b/tools/virtiofsd/50-qemu-virtiofsd.json.in
new file mode 100644
index 0000000000..9bcd86f8dc
--- /dev/null
+++ b/tools/virtiofsd/50-qemu-virtiofsd.json.in
@@ -0,0 +1,5 @@
+{
+ "description": "QEMU virtiofsd vhost-user-fs",
+ "type": "fs",
+ "binary": "@libexecdir@/virtiofsd"
+}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 032/108] virtiofsd: add --print-capabilities option
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (30 preceding siblings ...)
2020-01-23 16:45 ` [PULL 031/108] virtiofsd: add vhost-user.json file Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 033/108] virtiofs: Add maintainers entry Dr. David Alan Gilbert (git)
` (77 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Add the --print-capabilities option as per vhost-user.rst "Backend
programs conventions". Currently there are no advertised features.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
docs/interop/vhost-user.json | 4 +++-
tools/virtiofsd/fuse_lowlevel.h | 1 +
tools/virtiofsd/helper.c | 2 ++
tools/virtiofsd/passthrough_ll.c | 12 ++++++++++++
4 files changed, 18 insertions(+), 1 deletion(-)
diff --git a/docs/interop/vhost-user.json b/docs/interop/vhost-user.json
index ce0ef74db5..ef8ac5941f 100644
--- a/docs/interop/vhost-user.json
+++ b/docs/interop/vhost-user.json
@@ -31,6 +31,7 @@
# @rproc-serial: virtio remoteproc serial link
# @scsi: virtio scsi
# @vsock: virtio vsock transport
+# @fs: virtio fs (since 4.2)
#
# Since: 4.0
##
@@ -50,7 +51,8 @@
'rpmsg',
'rproc-serial',
'scsi',
- 'vsock'
+ 'vsock',
+ 'fs'
]
}
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index f6b34700af..0d61df8110 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -1794,6 +1794,7 @@ struct fuse_cmdline_opts {
int nodefault_subtype;
int show_version;
int show_help;
+ int print_capabilities;
unsigned int max_idle_threads;
};
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index a3645fc807..b8ec5ac8dc 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -40,6 +40,7 @@ static const struct fuse_opt fuse_helper_opts[] = {
FUSE_HELPER_OPT("--help", show_help),
FUSE_HELPER_OPT("-V", show_version),
FUSE_HELPER_OPT("--version", show_version),
+ FUSE_HELPER_OPT("--print-capabilities", print_capabilities),
FUSE_HELPER_OPT("-d", debug),
FUSE_HELPER_OPT("debug", debug),
FUSE_HELPER_OPT("-d", foreground),
@@ -135,6 +136,7 @@ void fuse_cmdline_help(void)
{
printf(" -h --help print help\n"
" -V --version print version\n"
+ " --print-capabilities print vhost-user.json\n"
" -d -o debug enable debug output (implies -f)\n"
" -f foreground operation\n"
" --daemonize run in background\n"
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 037c5d7b26..cd27c09f59 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1298,6 +1298,14 @@ static struct fuse_lowlevel_ops lo_oper = {
.lseek = lo_lseek,
};
+/* Print vhost-user.json backend program capabilities */
+static void print_capabilities(void)
+{
+ printf("{\n");
+ printf(" \"type\": \"fs\"\n");
+ printf("}\n");
+}
+
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
@@ -1328,6 +1336,10 @@ int main(int argc, char *argv[])
fuse_lowlevel_version();
ret = 0;
goto err_out1;
+ } else if (opts.print_capabilities) {
+ print_capabilities();
+ ret = 0;
+ goto err_out1;
}
if (fuse_opt_parse(&args, &lo, lo_opts, NULL) == -1) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 033/108] virtiofs: Add maintainers entry
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (31 preceding siblings ...)
2020-01-23 16:45 ` [PULL 032/108] virtiofsd: add --print-capabilities option Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 034/108] virtiofsd: passthrough_ll: create new files in caller's context Dr. David Alan Gilbert (git)
` (76 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
MAINTAINERS | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/MAINTAINERS b/MAINTAINERS
index 2c768ed3d8..075fdab372 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1595,6 +1595,14 @@ T: git https://github.com/cohuck/qemu.git s390-next
T: git https://github.com/borntraeger/qemu.git s390-next
L: qemu-s390x@nongnu.org
+virtiofs
+M: Dr. David Alan Gilbert <dgilbert@redhat.com>
+M: Stefan Hajnoczi <stefanha@redhat.com>
+S: Supported
+F: tools/virtiofsd/*
+F: hw/virtio/vhost-user-fs*
+F: include/hw/virtio/vhost-user-fs.h
+
virtio-input
M: Gerd Hoffmann <kraxel@redhat.com>
S: Maintained
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 034/108] virtiofsd: passthrough_ll: create new files in caller's context
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (32 preceding siblings ...)
2020-01-23 16:45 ` [PULL 033/108] virtiofs: Add maintainers entry Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 035/108] virtiofsd: passthrough_ll: add lo_map for ino/fh indirection Dr. David Alan Gilbert (git)
` (75 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Vivek Goyal <vgoyal@redhat.com>
We need to create files in the caller's context. Otherwise after
creating a file, the caller might not be able to do file operations on
that file.
Changed effective uid/gid to caller's uid/gid, create file and then
switch back to uid/gid 0.
Use syscall(setresuid, ...) otherwise glibc does some magic to change EUID
in all threads, which is not what we want.
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 96 ++++++++++++++++++++++++++++++--
1 file changed, 91 insertions(+), 5 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index cd27c09f59..5e061797d4 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -50,6 +50,7 @@
#include <stdlib.h>
#include <string.h>
#include <sys/file.h>
+#include <sys/syscall.h>
#include <sys/xattr.h>
#include <unistd.h>
@@ -83,6 +84,11 @@ struct lo_inode {
uint64_t refcount; /* protected by lo->mutex */
};
+struct lo_cred {
+ uid_t euid;
+ gid_t egid;
+};
+
enum {
CACHE_NEVER,
CACHE_NORMAL,
@@ -383,6 +389,69 @@ static void lo_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
}
}
+/*
+ * On some archs, setres*id is limited to 2^16 but they
+ * provide setres*id32 variants that allow 2^32.
+ * Others just let setres*id do 2^32 anyway.
+ */
+#ifdef SYS_setresgid32
+#define OURSYS_setresgid SYS_setresgid32
+#else
+#define OURSYS_setresgid SYS_setresgid
+#endif
+
+#ifdef SYS_setresuid32
+#define OURSYS_setresuid SYS_setresuid32
+#else
+#define OURSYS_setresuid SYS_setresuid
+#endif
+
+/*
+ * Change to uid/gid of caller so that file is created with
+ * ownership of caller.
+ * TODO: What about selinux context?
+ */
+static int lo_change_cred(fuse_req_t req, struct lo_cred *old)
+{
+ int res;
+
+ old->euid = geteuid();
+ old->egid = getegid();
+
+ res = syscall(OURSYS_setresgid, -1, fuse_req_ctx(req)->gid, -1);
+ if (res == -1) {
+ return errno;
+ }
+
+ res = syscall(OURSYS_setresuid, -1, fuse_req_ctx(req)->uid, -1);
+ if (res == -1) {
+ int errno_save = errno;
+
+ syscall(OURSYS_setresgid, -1, old->egid, -1);
+ return errno_save;
+ }
+
+ return 0;
+}
+
+/* Regain Privileges */
+static void lo_restore_cred(struct lo_cred *old)
+{
+ int res;
+
+ res = syscall(OURSYS_setresuid, -1, old->euid, -1);
+ if (res == -1) {
+ fuse_log(FUSE_LOG_ERR, "seteuid(%u): %m\n", old->euid);
+ exit(1);
+ }
+
+ res = syscall(OURSYS_setresgid, -1, old->egid, -1);
+ if (res == -1) {
+ fuse_log(FUSE_LOG_ERR, "setegid(%u): %m\n", old->egid);
+ exit(1);
+ }
+}
+
static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
const char *name, mode_t mode, dev_t rdev,
const char *link)
@@ -391,12 +460,21 @@ static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
int saverr;
struct lo_inode *dir = lo_inode(req, parent);
struct fuse_entry_param e;
+ struct lo_cred old = {};
saverr = ENOMEM;
+ saverr = lo_change_cred(req, &old);
+ if (saverr) {
+ goto out;
+ }
+
res = mknod_wrapper(dir->fd, name, link, mode, rdev);
saverr = errno;
+
+ lo_restore_cred(&old);
+
if (res == -1) {
goto out;
}
@@ -794,26 +872,34 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
struct lo_data *lo = lo_data(req);
struct fuse_entry_param e;
int err;
+ struct lo_cred old = {};
if (lo_debug(req)) {
fuse_log(FUSE_LOG_DEBUG, "lo_create(parent=%" PRIu64 ", name=%s)\n",
parent, name);
}
+ err = lo_change_cred(req, &old);
+ if (err) {
+ goto out;
+ }
+
fd = openat(lo_fd(req, parent), name, (fi->flags | O_CREAT) & ~O_NOFOLLOW,
mode);
- if (fd == -1) {
- return (void)fuse_reply_err(req, errno);
- }
+ err = fd == -1 ? errno : 0;
+ lo_restore_cred(&old);
- fi->fh = fd;
+ if (!err) {
+ fi->fh = fd;
+ err = lo_do_lookup(req, parent, name, &e);
+ }
if (lo->cache == CACHE_NEVER) {
fi->direct_io = 1;
} else if (lo->cache == CACHE_ALWAYS) {
fi->keep_cache = 1;
}
- err = lo_do_lookup(req, parent, name, &e);
+out:
if (err) {
fuse_reply_err(req, err);
} else {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 035/108] virtiofsd: passthrough_ll: add lo_map for ino/fh indirection
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (33 preceding siblings ...)
2020-01-23 16:45 ` [PULL 034/108] virtiofsd: passthrough_ll: create new files in caller's context Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 036/108] virtiofsd: passthrough_ll: add ino_map to hide lo_inode pointers Dr. David Alan Gilbert (git)
` (74 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
A layer of indirection is needed because passthrough_ll cannot expose
pointers or file descriptor numbers to untrusted clients. Malicious
clients could send invalid pointers or file descriptors in order to
crash or exploit the file system daemon.
lo_map provides an integer key->value mapping. This will be used for
ino and fh fields in the patches that follow.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 124 +++++++++++++++++++++++++++++++
1 file changed, 124 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 5e061797d4..e83a976587 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -74,6 +74,21 @@ struct _uintptr_to_must_hold_fuse_ino_t_dummy_struct {
};
#endif
+struct lo_map_elem {
+ union {
+ /* Element values will go here... */
+ ssize_t freelist;
+ };
+ bool in_use;
+};
+
+/* Maps FUSE fh or ino values to internal objects */
+struct lo_map {
+ struct lo_map_elem *elems;
+ size_t nelems;
+ ssize_t freelist;
+};
+
struct lo_inode {
struct lo_inode *next; /* protected by lo->mutex */
struct lo_inode *prev; /* protected by lo->mutex */
@@ -130,6 +145,115 @@ static struct lo_data *lo_data(fuse_req_t req)
return (struct lo_data *)fuse_req_userdata(req);
}
+__attribute__((unused)) static void lo_map_init(struct lo_map *map)
+{
+ map->elems = NULL;
+ map->nelems = 0;
+ map->freelist = -1;
+}
+
+__attribute__((unused)) static void lo_map_destroy(struct lo_map *map)
+{
+ free(map->elems);
+}
+
+static int lo_map_grow(struct lo_map *map, size_t new_nelems)
+{
+ struct lo_map_elem *new_elems;
+ size_t i;
+
+ if (new_nelems <= map->nelems) {
+ return 1;
+ }
+
+ new_elems = realloc(map->elems, sizeof(map->elems[0]) * new_nelems);
+ if (!new_elems) {
+ return 0;
+ }
+
+ for (i = map->nelems; i < new_nelems; i++) {
+ new_elems[i].freelist = i + 1;
+ new_elems[i].in_use = false;
+ }
+ new_elems[new_nelems - 1].freelist = -1;
+
+ map->elems = new_elems;
+ map->freelist = map->nelems;
+ map->nelems = new_nelems;
+ return 1;
+}
+
+__attribute__((unused)) static struct lo_map_elem *
+lo_map_alloc_elem(struct lo_map *map)
+{
+ struct lo_map_elem *elem;
+
+ if (map->freelist == -1 && !lo_map_grow(map, map->nelems + 256)) {
+ return NULL;
+ }
+
+ elem = &map->elems[map->freelist];
+ map->freelist = elem->freelist;
+
+ elem->in_use = true;
+
+ return elem;
+}
+
+__attribute__((unused)) static struct lo_map_elem *
+lo_map_reserve(struct lo_map *map, size_t key)
+{
+ ssize_t *prev;
+
+ if (!lo_map_grow(map, key + 1)) {
+ return NULL;
+ }
+
+ for (prev = &map->freelist; *prev != -1;
+ prev = &map->elems[*prev].freelist) {
+ if (*prev == key) {
+ struct lo_map_elem *elem = &map->elems[key];
+
+ *prev = elem->freelist;
+ elem->in_use = true;
+ return elem;
+ }
+ }
+ return NULL;
+}
+
+__attribute__((unused)) static struct lo_map_elem *
+lo_map_get(struct lo_map *map, size_t key)
+{
+ if (key >= map->nelems) {
+ return NULL;
+ }
+ if (!map->elems[key].in_use) {
+ return NULL;
+ }
+ return &map->elems[key];
+}
+
+__attribute__((unused)) static void lo_map_remove(struct lo_map *map,
+ size_t key)
+{
+ struct lo_map_elem *elem;
+
+ if (key >= map->nelems) {
+ return;
+ }
+
+ elem = &map->elems[key];
+ if (!elem->in_use) {
+ return;
+ }
+
+ elem->in_use = false;
+
+ elem->freelist = map->freelist;
+ map->freelist = key;
+}
+
static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino)
{
if (ino == FUSE_ROOT_ID) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 036/108] virtiofsd: passthrough_ll: add ino_map to hide lo_inode pointers
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (34 preceding siblings ...)
2020-01-23 16:45 ` [PULL 035/108] virtiofsd: passthrough_ll: add lo_map for ino/fh indirection Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 037/108] virtiofsd: passthrough_ll: add dirp_map to hide lo_dirp pointers Dr. David Alan Gilbert (git)
` (73 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Do not expose lo_inode pointers to clients.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 144 ++++++++++++++++++++++++-------
1 file changed, 114 insertions(+), 30 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index e83a976587..a3ebf74eab 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -57,8 +57,8 @@
#include "passthrough_helpers.h"
/*
- * We are re-using pointers to our `struct lo_inode` and `struct
- * lo_dirp` elements as inodes. This means that we must be able to
+ * We are re-using pointers to our `struct lo_inode`
+ * elements as inodes. This means that we must be able to
* store uintptr_t values in a fuse_ino_t variable. The following
* incantation checks this condition at compile time.
*/
@@ -76,7 +76,7 @@ struct _uintptr_to_must_hold_fuse_ino_t_dummy_struct {
struct lo_map_elem {
union {
- /* Element values will go here... */
+ struct lo_inode *inode;
ssize_t freelist;
};
bool in_use;
@@ -97,6 +97,7 @@ struct lo_inode {
ino_t ino;
dev_t dev;
uint64_t refcount; /* protected by lo->mutex */
+ fuse_ino_t fuse_ino;
};
struct lo_cred {
@@ -121,6 +122,7 @@ struct lo_data {
int cache;
int timeout_set;
struct lo_inode root; /* protected by lo->mutex */
+ struct lo_map ino_map; /* protected by lo->mutex */
};
static const struct fuse_opt lo_opts[] = {
@@ -145,14 +147,14 @@ static struct lo_data *lo_data(fuse_req_t req)
return (struct lo_data *)fuse_req_userdata(req);
}
-__attribute__((unused)) static void lo_map_init(struct lo_map *map)
+static void lo_map_init(struct lo_map *map)
{
map->elems = NULL;
map->nelems = 0;
map->freelist = -1;
}
-__attribute__((unused)) static void lo_map_destroy(struct lo_map *map)
+static void lo_map_destroy(struct lo_map *map)
{
free(map->elems);
}
@@ -183,8 +185,7 @@ static int lo_map_grow(struct lo_map *map, size_t new_nelems)
return 1;
}
-__attribute__((unused)) static struct lo_map_elem *
-lo_map_alloc_elem(struct lo_map *map)
+static struct lo_map_elem *lo_map_alloc_elem(struct lo_map *map)
{
struct lo_map_elem *elem;
@@ -200,8 +201,7 @@ lo_map_alloc_elem(struct lo_map *map)
return elem;
}
-__attribute__((unused)) static struct lo_map_elem *
-lo_map_reserve(struct lo_map *map, size_t key)
+static struct lo_map_elem *lo_map_reserve(struct lo_map *map, size_t key)
{
ssize_t *prev;
@@ -222,8 +222,7 @@ lo_map_reserve(struct lo_map *map, size_t key)
return NULL;
}
-__attribute__((unused)) static struct lo_map_elem *
-lo_map_get(struct lo_map *map, size_t key)
+static struct lo_map_elem *lo_map_get(struct lo_map *map, size_t key)
{
if (key >= map->nelems) {
return NULL;
@@ -234,8 +233,7 @@ lo_map_get(struct lo_map *map, size_t key)
return &map->elems[key];
}
-__attribute__((unused)) static void lo_map_remove(struct lo_map *map,
- size_t key)
+static void lo_map_remove(struct lo_map *map, size_t key)
{
struct lo_map_elem *elem;
@@ -254,18 +252,40 @@ __attribute__((unused)) static void lo_map_remove(struct lo_map *map,
map->freelist = key;
}
+/* Assumes lo->mutex is held */
+static ssize_t lo_add_inode_mapping(fuse_req_t req, struct lo_inode *inode)
+{
+ struct lo_map_elem *elem;
+
+ elem = lo_map_alloc_elem(&lo_data(req)->ino_map);
+ if (!elem) {
+ return -1;
+ }
+
+ elem->inode = inode;
+ return elem - lo_data(req)->ino_map.elems;
+}
+
static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino)
{
- if (ino == FUSE_ROOT_ID) {
- return &lo_data(req)->root;
- } else {
- return (struct lo_inode *)(uintptr_t)ino;
+ struct lo_data *lo = lo_data(req);
+ struct lo_map_elem *elem;
+
+ pthread_mutex_lock(&lo->mutex);
+ elem = lo_map_get(&lo->ino_map, ino);
+ pthread_mutex_unlock(&lo->mutex);
+
+ if (!elem) {
+ return NULL;
}
+
+ return elem->inode;
}
static int lo_fd(fuse_req_t req, fuse_ino_t ino)
{
- return lo_inode(req, ino)->fd;
+ struct lo_inode *inode = lo_inode(req, ino);
+ return inode ? inode->fd : -1;
}
static bool lo_debug(fuse_req_t req)
@@ -337,10 +357,18 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
{
int saverr;
char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
- int ifd = inode->fd;
+ struct lo_inode *inode;
+ int ifd;
int res;
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
+ ifd = inode->fd;
+
if (valid & FUSE_SET_ATTR_MODE) {
if (fi) {
res = fchmod(fi->fh, attr->st_mode);
@@ -470,6 +498,7 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
inode->dev = e->attr.st_dev;
pthread_mutex_lock(&lo->mutex);
+ inode->fuse_ino = lo_add_inode_mapping(req, inode);
prev = &lo->root;
next = prev->next;
next->prev = inode;
@@ -478,7 +507,7 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
prev->next = inode;
pthread_mutex_unlock(&lo->mutex);
}
- e->ino = (uintptr_t)inode;
+ e->ino = inode->fuse_ino;
if (lo_debug(req)) {
fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
@@ -582,10 +611,16 @@ static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
{
int res;
int saverr;
- struct lo_inode *dir = lo_inode(req, parent);
+ struct lo_inode *dir;
struct fuse_entry_param e;
struct lo_cred old = {};
+ dir = lo_inode(req, parent);
+ if (!dir) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
saverr = ENOMEM;
saverr = lo_change_cred(req, &old);
@@ -663,10 +698,16 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
{
int res;
struct lo_data *lo = lo_data(req);
- struct lo_inode *inode = lo_inode(req, ino);
+ struct lo_inode *inode;
struct fuse_entry_param e;
int saverr;
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
memset(&e, 0, sizeof(struct fuse_entry_param));
e.attr_timeout = lo->timeout;
e.entry_timeout = lo->timeout;
@@ -684,7 +725,7 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
pthread_mutex_lock(&lo->mutex);
inode->refcount++;
pthread_mutex_unlock(&lo->mutex);
- e.ino = (uintptr_t)inode;
+ e.ino = inode->fuse_ino;
if (lo_debug(req)) {
fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
@@ -750,10 +791,10 @@ static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n)
next->prev = prev;
prev->next = next;
+ lo_map_remove(&lo->ino_map, inode->fuse_ino);
pthread_mutex_unlock(&lo->mutex);
close(inode->fd);
free(inode);
-
} else {
pthread_mutex_unlock(&lo->mutex);
}
@@ -762,7 +803,12 @@ static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n)
static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{
struct lo_data *lo = lo_data(req);
- struct lo_inode *inode = lo_inode(req, ino);
+ struct lo_inode *inode;
+
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ return;
+ }
if (lo_debug(req)) {
fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",
@@ -1244,10 +1290,16 @@ static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
{
char *value = NULL;
char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
+ struct lo_inode *inode;
ssize_t ret;
int saverr;
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
saverr = ENOSYS;
if (!lo_data(req)->xattr) {
goto out;
@@ -1306,10 +1358,16 @@ static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
{
char *value = NULL;
char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
+ struct lo_inode *inode;
ssize_t ret;
int saverr;
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
saverr = ENOSYS;
if (!lo_data(req)->xattr) {
goto out;
@@ -1367,10 +1425,16 @@ static void lo_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
const char *value, size_t size, int flags)
{
char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
+ struct lo_inode *inode;
ssize_t ret;
int saverr;
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
saverr = ENOSYS;
if (!lo_data(req)->xattr) {
goto out;
@@ -1400,10 +1464,16 @@ out:
static void lo_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name)
{
char procname[64];
- struct lo_inode *inode = lo_inode(req, ino);
+ struct lo_inode *inode;
ssize_t ret;
int saverr;
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
saverr = ENOSYS;
if (!lo_data(req)->xattr) {
goto out;
@@ -1522,6 +1592,7 @@ int main(int argc, char *argv[])
struct fuse_session *se;
struct fuse_cmdline_opts opts;
struct lo_data lo = { .debug = 0, .writeback = 0 };
+ struct lo_map_elem *root_elem;
int ret = -1;
/* Don't mask creation mode, kernel already did that */
@@ -1530,8 +1601,19 @@ int main(int argc, char *argv[])
pthread_mutex_init(&lo.mutex, NULL);
lo.root.next = lo.root.prev = &lo.root;
lo.root.fd = -1;
+ lo.root.fuse_ino = FUSE_ROOT_ID;
lo.cache = CACHE_NORMAL;
+ /*
+ * Set up the ino map like this:
+ * [0] Reserved (will not be used)
+ * [1] Root inode
+ */
+ lo_map_init(&lo.ino_map);
+ lo_map_reserve(&lo.ino_map, 0)->in_use = false;
+ root_elem = lo_map_reserve(&lo.ino_map, lo.root.fuse_ino);
+ root_elem->inode = &lo.root;
+
if (fuse_parse_cmdline(&args, &opts) != 0) {
return 1;
}
@@ -1628,6 +1710,8 @@ err_out2:
err_out1:
fuse_opt_free_args(&args);
+ lo_map_destroy(&lo.ino_map);
+
if (lo.root.fd >= 0) {
close(lo.root.fd);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 037/108] virtiofsd: passthrough_ll: add dirp_map to hide lo_dirp pointers
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (35 preceding siblings ...)
2020-01-23 16:45 ` [PULL 036/108] virtiofsd: passthrough_ll: add ino_map to hide lo_inode pointers Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-03-20 13:38 ` Peter Maydell
2020-01-23 16:45 ` [PULL 038/108] virtiofsd: passthrough_ll: add fd_map to hide file descriptors Dr. David Alan Gilbert (git)
` (72 subsequent siblings)
109 siblings, 1 reply; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Do not expose lo_dirp pointers to clients.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 103 +++++++++++++++++++++++--------
1 file changed, 76 insertions(+), 27 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index a3ebf74eab..5f5a72fdbb 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -56,27 +56,10 @@
#include "passthrough_helpers.h"
-/*
- * We are re-using pointers to our `struct lo_inode`
- * elements as inodes. This means that we must be able to
- * store uintptr_t values in a fuse_ino_t variable. The following
- * incantation checks this condition at compile time.
- */
-#if defined(__GNUC__) && \
- (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && \
- !defined __cplusplus
-_Static_assert(sizeof(fuse_ino_t) >= sizeof(uintptr_t),
- "fuse_ino_t too small to hold uintptr_t values!");
-#else
-struct _uintptr_to_must_hold_fuse_ino_t_dummy_struct {
- unsigned _uintptr_to_must_hold_fuse_ino_t
- : ((sizeof(fuse_ino_t) >= sizeof(uintptr_t)) ? 1 : -1);
-};
-#endif
-
struct lo_map_elem {
union {
struct lo_inode *inode;
+ struct lo_dirp *dirp;
ssize_t freelist;
};
bool in_use;
@@ -123,6 +106,7 @@ struct lo_data {
int timeout_set;
struct lo_inode root; /* protected by lo->mutex */
struct lo_map ino_map; /* protected by lo->mutex */
+ struct lo_map dirp_map; /* protected by lo->mutex */
};
static const struct fuse_opt lo_opts[] = {
@@ -252,6 +236,20 @@ static void lo_map_remove(struct lo_map *map, size_t key)
map->freelist = key;
}
+/* Assumes lo->mutex is held */
+static ssize_t lo_add_dirp_mapping(fuse_req_t req, struct lo_dirp *dirp)
+{
+ struct lo_map_elem *elem;
+
+ elem = lo_map_alloc_elem(&lo_data(req)->dirp_map);
+ if (!elem) {
+ return -1;
+ }
+
+ elem->dirp = dirp;
+ return elem - lo_data(req)->dirp_map.elems;
+}
+
/* Assumes lo->mutex is held */
static ssize_t lo_add_inode_mapping(fuse_req_t req, struct lo_inode *inode)
{
@@ -861,9 +859,19 @@ struct lo_dirp {
off_t offset;
};
-static struct lo_dirp *lo_dirp(struct fuse_file_info *fi)
+static struct lo_dirp *lo_dirp(fuse_req_t req, struct fuse_file_info *fi)
{
- return (struct lo_dirp *)(uintptr_t)fi->fh;
+ struct lo_data *lo = lo_data(req);
+ struct lo_map_elem *elem;
+
+ pthread_mutex_lock(&lo->mutex);
+ elem = lo_map_get(&lo->dirp_map, fi->fh);
+ pthread_mutex_unlock(&lo->mutex);
+ if (!elem) {
+ return NULL;
+ }
+
+ return elem->dirp;
}
static void lo_opendir(fuse_req_t req, fuse_ino_t ino,
@@ -873,6 +881,7 @@ static void lo_opendir(fuse_req_t req, fuse_ino_t ino,
struct lo_data *lo = lo_data(req);
struct lo_dirp *d;
int fd;
+ ssize_t fh;
d = calloc(1, sizeof(struct lo_dirp));
if (d == NULL) {
@@ -892,7 +901,14 @@ static void lo_opendir(fuse_req_t req, fuse_ino_t ino,
d->offset = 0;
d->entry = NULL;
- fi->fh = (uintptr_t)d;
+ pthread_mutex_lock(&lo->mutex);
+ fh = lo_add_dirp_mapping(req, d);
+ pthread_mutex_unlock(&lo->mutex);
+ if (fh == -1) {
+ goto out_err;
+ }
+
+ fi->fh = fh;
if (lo->cache == CACHE_ALWAYS) {
fi->keep_cache = 1;
}
@@ -903,6 +919,9 @@ out_errno:
error = errno;
out_err:
if (d) {
+ if (d->dp) {
+ closedir(d->dp);
+ }
if (fd != -1) {
close(fd);
}
@@ -920,17 +939,21 @@ static int is_dot_or_dotdot(const char *name)
static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
off_t offset, struct fuse_file_info *fi, int plus)
{
- struct lo_dirp *d = lo_dirp(fi);
- char *buf;
+ struct lo_dirp *d;
+ char *buf = NULL;
char *p;
size_t rem = size;
- int err;
+ int err = ENOMEM;
(void)ino;
+ d = lo_dirp(req, fi);
+ if (!d) {
+ goto error;
+ }
+
buf = calloc(1, size);
if (!buf) {
- err = ENOMEM;
goto error;
}
p = buf;
@@ -1028,8 +1051,21 @@ static void lo_readdirplus(fuse_req_t req, fuse_ino_t ino, size_t size,
static void lo_releasedir(fuse_req_t req, fuse_ino_t ino,
struct fuse_file_info *fi)
{
- struct lo_dirp *d = lo_dirp(fi);
+ struct lo_data *lo = lo_data(req);
+ struct lo_dirp *d;
+
(void)ino;
+
+ d = lo_dirp(req, fi);
+ if (!d) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
+ pthread_mutex_lock(&lo->mutex);
+ lo_map_remove(&lo->dirp_map, fi->fh);
+ pthread_mutex_unlock(&lo->mutex);
+
closedir(d->dp);
free(d);
fuse_reply_err(req, 0);
@@ -1081,8 +1117,18 @@ static void lo_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync,
struct fuse_file_info *fi)
{
int res;
- int fd = dirfd(lo_dirp(fi)->dp);
+ struct lo_dirp *d;
+ int fd;
+
(void)ino;
+
+ d = lo_dirp(req, fi);
+ if (!d) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
+ fd = dirfd(d->dp);
if (datasync) {
res = fdatasync(fd);
} else {
@@ -1614,6 +1660,8 @@ int main(int argc, char *argv[])
root_elem = lo_map_reserve(&lo.ino_map, lo.root.fuse_ino);
root_elem->inode = &lo.root;
+ lo_map_init(&lo.dirp_map);
+
if (fuse_parse_cmdline(&args, &opts) != 0) {
return 1;
}
@@ -1710,6 +1758,7 @@ err_out2:
err_out1:
fuse_opt_free_args(&args);
+ lo_map_destroy(&lo.dirp_map);
lo_map_destroy(&lo.ino_map);
if (lo.root.fd >= 0) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* Re: [PULL 037/108] virtiofsd: passthrough_ll: add dirp_map to hide lo_dirp pointers
2020-01-23 16:45 ` [PULL 037/108] virtiofsd: passthrough_ll: add dirp_map to hide lo_dirp pointers Dr. David Alan Gilbert (git)
@ 2020-03-20 13:38 ` Peter Maydell
0 siblings, 0 replies; 113+ messages in thread
From: Peter Maydell @ 2020-03-20 13:38 UTC (permalink / raw)
To: Dr. David Alan Gilbert (git); +Cc: QEMU Developers, Stefan Hajnoczi
On Thu, 23 Jan 2020 at 19:41, Dr. David Alan Gilbert (git)
<dgilbert@redhat.com> wrote:
>
> From: Stefan Hajnoczi <stefanha@redhat.com>
>
> Do not expose lo_dirp pointers to clients.
>
> Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
> Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
> Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
> ---
> tools/virtiofsd/passthrough_ll.c | 103 +++++++++++++++++++++++--------
> 1 file changed, 76 insertions(+), 27 deletions(-)
Hi; Coverity reports (CID 1421933) an issue introduced
by this patch:
> @@ -873,6 +881,7 @@ static void lo_opendir(fuse_req_t req, fuse_ino_t ino,
> struct lo_data *lo = lo_data(req);
> struct lo_dirp *d;
> int fd;
> + ssize_t fh;
>
> d = calloc(1, sizeof(struct lo_dirp));
> if (d == NULL) {
> @@ -892,7 +901,14 @@ static void lo_opendir(fuse_req_t req, fuse_ino_t ino,
> d->offset = 0;
> d->entry = NULL;
>
> - fi->fh = (uintptr_t)d;
> + pthread_mutex_lock(&lo->mutex);
> + fh = lo_add_dirp_mapping(req, d);
> + pthread_mutex_unlock(&lo->mutex);
> + if (fh == -1) {
> + goto out_err;
> + }
This change introduces a new code path which
leads to out_err that can be taken after the
call to fdopendir(fd) succeeds...
> +
> + fi->fh = fh;
> if (lo->cache == CACHE_ALWAYS) {
> fi->keep_cache = 1;
> }
> @@ -903,6 +919,9 @@ out_errno:
> error = errno;
> out_err:
> if (d) {
> + if (d->dp) {
> + closedir(d->dp);
> + }
> if (fd != -1) {
> close(fd);
> }
...but here we close(fd), which is an error if
fdopendir() succeeded, because that function takes
over ownership of the fd it is passed and we should
make no more calls on it.
An easy fix would be to add 'fd = -1;' after the call
to fdopendir() has succeeded (but that would probably
deserve a comment explaining why it's being done); or
you might prefer to separate out the error flows so
we only call close() for error paths before the fdopendir()
succeeds and only call closedir() afterwards. Or
you could make the error path
if (d->dp) {
closedir(d->dp);
} else if (fd != -1) {
close(fd);
}
thanks
-- PMM
^ permalink raw reply [flat|nested] 113+ messages in thread
* [PULL 038/108] virtiofsd: passthrough_ll: add fd_map to hide file descriptors
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (36 preceding siblings ...)
2020-01-23 16:45 ` [PULL 037/108] virtiofsd: passthrough_ll: add dirp_map to hide lo_dirp pointers Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 039/108] virtiofsd: passthrough_ll: add fallback for racy ops Dr. David Alan Gilbert (git)
` (71 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Do not expose file descriptor numbers to clients. This prevents the
abuse of internal file descriptors (like stdin/stdout).
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Fix from:
Signed-off-by: Xiao Yang <yangx.jy@cn.fujitsu.com>
dgilbert:
Added lseek
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 116 +++++++++++++++++++++++++------
1 file changed, 94 insertions(+), 22 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 5f5a72fdbb..9815bfa5c5 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -60,6 +60,7 @@ struct lo_map_elem {
union {
struct lo_inode *inode;
struct lo_dirp *dirp;
+ int fd;
ssize_t freelist;
};
bool in_use;
@@ -107,6 +108,7 @@ struct lo_data {
struct lo_inode root; /* protected by lo->mutex */
struct lo_map ino_map; /* protected by lo->mutex */
struct lo_map dirp_map; /* protected by lo->mutex */
+ struct lo_map fd_map; /* protected by lo->mutex */
};
static const struct fuse_opt lo_opts[] = {
@@ -236,6 +238,20 @@ static void lo_map_remove(struct lo_map *map, size_t key)
map->freelist = key;
}
+/* Assumes lo->mutex is held */
+static ssize_t lo_add_fd_mapping(fuse_req_t req, int fd)
+{
+ struct lo_map_elem *elem;
+
+ elem = lo_map_alloc_elem(&lo_data(req)->fd_map);
+ if (!elem) {
+ return -1;
+ }
+
+ elem->fd = fd;
+ return elem - lo_data(req)->fd_map.elems;
+}
+
/* Assumes lo->mutex is held */
static ssize_t lo_add_dirp_mapping(fuse_req_t req, struct lo_dirp *dirp)
{
@@ -350,6 +366,22 @@ static int utimensat_empty_nofollow(struct lo_inode *inode,
return utimensat(AT_FDCWD, procname, tv, 0);
}
+static int lo_fi_fd(fuse_req_t req, struct fuse_file_info *fi)
+{
+ struct lo_data *lo = lo_data(req);
+ struct lo_map_elem *elem;
+
+ pthread_mutex_lock(&lo->mutex);
+ elem = lo_map_get(&lo->fd_map, fi->fh);
+ pthread_mutex_unlock(&lo->mutex);
+
+ if (!elem) {
+ return -1;
+ }
+
+ return elem->fd;
+}
+
static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
int valid, struct fuse_file_info *fi)
{
@@ -358,6 +390,7 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
struct lo_inode *inode;
int ifd;
int res;
+ int fd;
inode = lo_inode(req, ino);
if (!inode) {
@@ -367,9 +400,14 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
ifd = inode->fd;
+ /* If fi->fh is invalid we'll report EBADF later */
+ if (fi) {
+ fd = lo_fi_fd(req, fi);
+ }
+
if (valid & FUSE_SET_ATTR_MODE) {
if (fi) {
- res = fchmod(fi->fh, attr->st_mode);
+ res = fchmod(fd, attr->st_mode);
} else {
sprintf(procname, "/proc/self/fd/%i", ifd);
res = chmod(procname, attr->st_mode);
@@ -389,7 +427,7 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
}
if (valid & FUSE_SET_ATTR_SIZE) {
if (fi) {
- res = ftruncate(fi->fh, attr->st_size);
+ res = ftruncate(fd, attr->st_size);
} else {
sprintf(procname, "/proc/self/fd/%i", ifd);
res = truncate(procname, attr->st_size);
@@ -419,7 +457,7 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
}
if (fi) {
- res = futimens(fi->fh, tv);
+ res = futimens(fd, tv);
} else {
res = utimensat_empty_nofollow(inode, tv);
}
@@ -1096,7 +1134,18 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
lo_restore_cred(&old);
if (!err) {
- fi->fh = fd;
+ ssize_t fh;
+
+ pthread_mutex_lock(&lo->mutex);
+ fh = lo_add_fd_mapping(req, fd);
+ pthread_mutex_unlock(&lo->mutex);
+ if (fh == -1) {
+ close(fd);
+ fuse_reply_err(req, ENOMEM);
+ return;
+ }
+
+ fi->fh = fh;
err = lo_do_lookup(req, parent, name, &e);
}
if (lo->cache == CACHE_NEVER) {
@@ -1140,6 +1189,7 @@ static void lo_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync,
static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
int fd;
+ ssize_t fh;
char buf[64];
struct lo_data *lo = lo_data(req);
@@ -1175,7 +1225,16 @@ static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
return (void)fuse_reply_err(req, errno);
}
- fi->fh = fd;
+ pthread_mutex_lock(&lo->mutex);
+ fh = lo_add_fd_mapping(req, fd);
+ pthread_mutex_unlock(&lo->mutex);
+ if (fh == -1) {
+ close(fd);
+ fuse_reply_err(req, ENOMEM);
+ return;
+ }
+
+ fi->fh = fh;
if (lo->cache == CACHE_NEVER) {
fi->direct_io = 1;
} else if (lo->cache == CACHE_ALWAYS) {
@@ -1187,9 +1246,18 @@ static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
static void lo_release(fuse_req_t req, fuse_ino_t ino,
struct fuse_file_info *fi)
{
+ struct lo_data *lo = lo_data(req);
+ int fd;
+
(void)ino;
- close(fi->fh);
+ fd = lo_fi_fd(req, fi);
+
+ pthread_mutex_lock(&lo->mutex);
+ lo_map_remove(&lo->fd_map, fi->fh);
+ pthread_mutex_unlock(&lo->mutex);
+
+ close(fd);
fuse_reply_err(req, 0);
}
@@ -1197,7 +1265,7 @@ static void lo_flush(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
int res;
(void)ino;
- res = close(dup(fi->fh));
+ res = close(dup(lo_fi_fd(req, fi)));
fuse_reply_err(req, res == -1 ? errno : 0);
}
@@ -1224,7 +1292,7 @@ static void lo_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
return (void)fuse_reply_err(req, errno);
}
} else {
- fd = fi->fh;
+ fd = lo_fi_fd(req, fi);
}
if (datasync) {
@@ -1251,7 +1319,7 @@ static void lo_read(fuse_req_t req, fuse_ino_t ino, size_t size, off_t offset,
}
buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
- buf.buf[0].fd = fi->fh;
+ buf.buf[0].fd = lo_fi_fd(req, fi);
buf.buf[0].pos = offset;
fuse_reply_data(req, &buf);
@@ -1266,7 +1334,7 @@ static void lo_write_buf(fuse_req_t req, fuse_ino_t ino,
struct fuse_bufvec out_buf = FUSE_BUFVEC_INIT(fuse_buf_size(in_buf));
out_buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
- out_buf.buf[0].fd = fi->fh;
+ out_buf.buf[0].fd = lo_fi_fd(req, fi);
out_buf.buf[0].pos = off;
if (lo_debug(req)) {
@@ -1303,7 +1371,7 @@ static void lo_fallocate(fuse_req_t req, fuse_ino_t ino, int mode, off_t offset,
(void)ino;
#ifdef CONFIG_FALLOCATE
- err = fallocate(fi->fh, mode, offset, length);
+ err = fallocate(lo_fi_fd(req, fi), mode, offset, length);
if (err < 0) {
err = errno;
}
@@ -1314,7 +1382,7 @@ static void lo_fallocate(fuse_req_t req, fuse_ino_t ino, int mode, off_t offset,
return;
}
- err = posix_fallocate(fi->fh, offset, length);
+ err = posix_fallocate(lo_fi_fd(req, fi), offset, length);
#endif
fuse_reply_err(req, err);
@@ -1326,7 +1394,7 @@ static void lo_flock(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
int res;
(void)ino;
- res = flock(fi->fh, op);
+ res = flock(lo_fi_fd(req, fi), op);
fuse_reply_err(req, res == -1 ? errno : 0);
}
@@ -1551,17 +1619,19 @@ static void lo_copy_file_range(fuse_req_t req, fuse_ino_t ino_in, off_t off_in,
off_t off_out, struct fuse_file_info *fi_out,
size_t len, int flags)
{
+ int in_fd, out_fd;
ssize_t res;
- if (lo_debug(req))
- fuse_log(FUSE_LOG_DEBUG,
- "lo_copy_file_range(ino=%" PRIu64 "/fd=%lu, "
- "off=%lu, ino=%" PRIu64 "/fd=%lu, "
- "off=%lu, size=%zd, flags=0x%x)\n",
- ino_in, fi_in->fh, off_in, ino_out, fi_out->fh, off_out, len,
- flags);
+ in_fd = lo_fi_fd(req, fi_in);
+ out_fd = lo_fi_fd(req, fi_out);
+
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_copy_file_range(ino=%" PRIu64 "/fd=%d, "
+ "off=%lu, ino=%" PRIu64 "/fd=%d, "
+ "off=%lu, size=%zd, flags=0x%x)\n",
+ ino_in, in_fd, off_in, ino_out, out_fd, off_out, len, flags);
- res = copy_file_range(fi_in->fh, &off_in, fi_out->fh, &off_out, len, flags);
+ res = copy_file_range(in_fd, &off_in, out_fd, &off_out, len, flags);
if (res < 0) {
fuse_reply_err(req, -errno);
} else {
@@ -1576,7 +1646,7 @@ static void lo_lseek(fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
off_t res;
(void)ino;
- res = lseek(fi->fh, off, whence);
+ res = lseek(lo_fi_fd(req, fi), off, whence);
if (res != -1) {
fuse_reply_lseek(req, res);
} else {
@@ -1661,6 +1731,7 @@ int main(int argc, char *argv[])
root_elem->inode = &lo.root;
lo_map_init(&lo.dirp_map);
+ lo_map_init(&lo.fd_map);
if (fuse_parse_cmdline(&args, &opts) != 0) {
return 1;
@@ -1758,6 +1829,7 @@ err_out2:
err_out1:
fuse_opt_free_args(&args);
+ lo_map_destroy(&lo.fd_map);
lo_map_destroy(&lo.dirp_map);
lo_map_destroy(&lo.ino_map);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 039/108] virtiofsd: passthrough_ll: add fallback for racy ops
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (37 preceding siblings ...)
2020-01-23 16:45 ` [PULL 038/108] virtiofsd: passthrough_ll: add fd_map to hide file descriptors Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 040/108] virtiofsd: validate path components Dr. David Alan Gilbert (git)
` (70 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
We have two operations that cannot be done race-free on a symlink in
certain cases: utimes and link.
Add racy fallback for these if the race-free method doesn't work. We do
our best to avoid races even in this case:
- get absolute path by reading /proc/self/fd/NN symlink
- lookup parent directory: after this we are safe against renames in
ancestors
- lookup name in parent directory, and verify that we got to the original
inode, if not retry the whole thing
Both utimes(2) and link(2) hold i_lock on the inode across the operation,
so a racing rename/delete by this fuse instance is not possible, only from
other entities changing the filesystem.
If the "norace" option is given, then disable the racy fallbacks.
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/helper.c | 5 +-
tools/virtiofsd/passthrough_ll.c | 157 +++++++++++++++++++++++++++----
2 files changed, 145 insertions(+), 17 deletions(-)
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index b8ec5ac8dc..5531425223 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -142,7 +142,10 @@ void fuse_cmdline_help(void)
" --daemonize run in background\n"
" -o max_idle_threads the maximum number of idle worker "
"threads\n"
- " allowed (default: 10)\n");
+ " allowed (default: 10)\n"
+ " -o norace disable racy fallback\n"
+ " default: false\n"
+ );
}
static int fuse_helper_opt_proc(void *data, const char *arg, int key,
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 9815bfa5c5..ac380efcb1 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -98,6 +98,7 @@ enum {
struct lo_data {
pthread_mutex_t mutex;
int debug;
+ int norace;
int writeback;
int flock;
int xattr;
@@ -124,10 +125,15 @@ static const struct fuse_opt lo_opts[] = {
{ "cache=never", offsetof(struct lo_data, cache), CACHE_NEVER },
{ "cache=auto", offsetof(struct lo_data, cache), CACHE_NORMAL },
{ "cache=always", offsetof(struct lo_data, cache), CACHE_ALWAYS },
-
+ { "norace", offsetof(struct lo_data, norace), 1 },
FUSE_OPT_END
};
+static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n);
+
+static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st);
+
+
static struct lo_data *lo_data(fuse_req_t req)
{
return (struct lo_data *)fuse_req_userdata(req);
@@ -347,23 +353,127 @@ static void lo_getattr(fuse_req_t req, fuse_ino_t ino,
fuse_reply_attr(req, &buf, lo->timeout);
}
-static int utimensat_empty_nofollow(struct lo_inode *inode,
- const struct timespec *tv)
+static int lo_parent_and_name(struct lo_data *lo, struct lo_inode *inode,
+ char path[PATH_MAX], struct lo_inode **parent)
{
- int res;
char procname[64];
+ char *last;
+ struct stat stat;
+ struct lo_inode *p;
+ int retries = 2;
+ int res;
+
+retry:
+ sprintf(procname, "/proc/self/fd/%i", inode->fd);
+
+ res = readlink(procname, path, PATH_MAX);
+ if (res < 0) {
+ fuse_log(FUSE_LOG_WARNING, "%s: readlink failed: %m\n", __func__);
+ goto fail_noretry;
+ }
+
+ if (res >= PATH_MAX) {
+ fuse_log(FUSE_LOG_WARNING, "%s: readlink overflowed\n", __func__);
+ goto fail_noretry;
+ }
+ path[res] = '\0';
+
+ last = strrchr(path, '/');
+ if (last == NULL) {
+ /* Shouldn't happen */
+ fuse_log(
+ FUSE_LOG_WARNING,
+ "%s: INTERNAL ERROR: bad path read from proc\n", __func__);
+ goto fail_noretry;
+ }
+ if (last == path) {
+ p = &lo->root;
+ pthread_mutex_lock(&lo->mutex);
+ p->refcount++;
+ pthread_mutex_unlock(&lo->mutex);
+ } else {
+ *last = '\0';
+ res = fstatat(AT_FDCWD, last == path ? "/" : path, &stat, 0);
+ if (res == -1) {
+ if (!retries) {
+ fuse_log(FUSE_LOG_WARNING,
+ "%s: failed to stat parent: %m\n", __func__);
+ }
+ goto fail;
+ }
+ p = lo_find(lo, &stat);
+ if (p == NULL) {
+ if (!retries) {
+ fuse_log(FUSE_LOG_WARNING,
+ "%s: failed to find parent\n", __func__);
+ }
+ goto fail;
+ }
+ }
+ last++;
+ res = fstatat(p->fd, last, &stat, AT_SYMLINK_NOFOLLOW);
+ if (res == -1) {
+ if (!retries) {
+ fuse_log(FUSE_LOG_WARNING,
+ "%s: failed to stat last\n", __func__);
+ }
+ goto fail_unref;
+ }
+ if (stat.st_dev != inode->dev || stat.st_ino != inode->ino) {
+ if (!retries) {
+ fuse_log(FUSE_LOG_WARNING,
+ "%s: failed to match last\n", __func__);
+ }
+ goto fail_unref;
+ }
+ *parent = p;
+ memmove(path, last, strlen(last) + 1);
+
+ return 0;
+
+fail_unref:
+ unref_inode(lo, p, 1);
+fail:
+ if (retries) {
+ retries--;
+ goto retry;
+ }
+fail_noretry:
+ errno = EIO;
+ return -1;
+}
+
+static int utimensat_empty(struct lo_data *lo, struct lo_inode *inode,
+ const struct timespec *tv)
+{
+ int res;
+ struct lo_inode *parent;
+ char path[PATH_MAX];
if (inode->is_symlink) {
- res = utimensat(inode->fd, "", tv, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ res = utimensat(inode->fd, "", tv, AT_EMPTY_PATH);
if (res == -1 && errno == EINVAL) {
/* Sorry, no race free way to set times on symlink. */
- errno = EPERM;
+ if (lo->norace) {
+ errno = EPERM;
+ } else {
+ goto fallback;
+ }
}
return res;
}
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(path, "/proc/self/fd/%i", inode->fd);
- return utimensat(AT_FDCWD, procname, tv, 0);
+ return utimensat(AT_FDCWD, path, tv, 0);
+
+fallback:
+ res = lo_parent_and_name(lo, inode, path, &parent);
+ if (res != -1) {
+ res = utimensat(parent->fd, path, tv, AT_SYMLINK_NOFOLLOW);
+ unref_inode(lo, parent, 1);
+ }
+
+ return res;
}
static int lo_fi_fd(fuse_req_t req, struct fuse_file_info *fi)
@@ -387,6 +497,7 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
{
int saverr;
char procname[64];
+ struct lo_data *lo = lo_data(req);
struct lo_inode *inode;
int ifd;
int res;
@@ -459,7 +570,7 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
if (fi) {
res = futimens(fd, tv);
} else {
- res = utimensat_empty_nofollow(inode, tv);
+ res = utimensat_empty(lo, inode, tv);
}
if (res == -1) {
goto out_err;
@@ -709,24 +820,38 @@ static void lo_symlink(fuse_req_t req, const char *link, fuse_ino_t parent,
lo_mknod_symlink(req, parent, name, S_IFLNK, 0, link);
}
-static int linkat_empty_nofollow(struct lo_inode *inode, int dfd,
- const char *name)
+static int linkat_empty_nofollow(struct lo_data *lo, struct lo_inode *inode,
+ int dfd, const char *name)
{
int res;
- char procname[64];
+ struct lo_inode *parent;
+ char path[PATH_MAX];
if (inode->is_symlink) {
res = linkat(inode->fd, "", dfd, name, AT_EMPTY_PATH);
if (res == -1 && (errno == ENOENT || errno == EINVAL)) {
/* Sorry, no race free way to hard-link a symlink. */
- errno = EPERM;
+ if (lo->norace) {
+ errno = EPERM;
+ } else {
+ goto fallback;
+ }
}
return res;
}
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(path, "/proc/self/fd/%i", inode->fd);
+
+ return linkat(AT_FDCWD, path, dfd, name, AT_SYMLINK_FOLLOW);
+
+fallback:
+ res = lo_parent_and_name(lo, inode, path, &parent);
+ if (res != -1) {
+ res = linkat(parent->fd, path, dfd, name, 0);
+ unref_inode(lo, parent, 1);
+ }
- return linkat(AT_FDCWD, procname, dfd, name, AT_SYMLINK_FOLLOW);
+ return res;
}
static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
@@ -748,7 +873,7 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
e.attr_timeout = lo->timeout;
e.entry_timeout = lo->timeout;
- res = linkat_empty_nofollow(inode, lo_fd(req, parent), name);
+ res = linkat_empty_nofollow(lo, inode, lo_fd(req, parent), name);
if (res == -1) {
goto out_err;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 040/108] virtiofsd: validate path components
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (38 preceding siblings ...)
2020-01-23 16:45 ` [PULL 039/108] virtiofsd: passthrough_ll: add fallback for racy ops Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 041/108] virtiofsd: Plumb fuse_bufvec through to do_write_buf Dr. David Alan Gilbert (git)
` (69 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Several FUSE requests contain single path components. A correct FUSE
client sends well-formed path components but there is currently no input
validation in case something went wrong or the client is malicious.
Refuse ".", "..", and paths containing '/' when we expect a path
component.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 59 ++++++++++++++++++++++++++++----
1 file changed, 53 insertions(+), 6 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index ac380efcb1..e375406160 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -133,6 +133,21 @@ static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n);
static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st);
+static int is_dot_or_dotdot(const char *name)
+{
+ return name[0] == '.' &&
+ (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'));
+}
+
+/* Is `path` a single path component that is not "." or ".."? */
+static int is_safe_path_component(const char *path)
+{
+ if (strchr(path, '/')) {
+ return 0;
+ }
+
+ return !is_dot_or_dotdot(path);
+}
static struct lo_data *lo_data(fuse_req_t req)
{
@@ -681,6 +696,15 @@ static void lo_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
parent, name);
}
+ /*
+ * Don't use is_safe_path_component(), allow "." and ".." for NFS export
+ * support.
+ */
+ if (strchr(name, '/')) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
err = lo_do_lookup(req, parent, name, &e);
if (err) {
fuse_reply_err(req, err);
@@ -762,6 +786,11 @@ static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
struct fuse_entry_param e;
struct lo_cred old = {};
+ if (!is_safe_path_component(name)) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
dir = lo_inode(req, parent);
if (!dir) {
fuse_reply_err(req, EBADF);
@@ -863,6 +892,11 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
struct fuse_entry_param e;
int saverr;
+ if (!is_safe_path_component(name)) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
inode = lo_inode(req, ino);
if (!inode) {
fuse_reply_err(req, EBADF);
@@ -904,6 +938,10 @@ out_err:
static void lo_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
{
int res;
+ if (!is_safe_path_component(name)) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
res = unlinkat(lo_fd(req, parent), name, AT_REMOVEDIR);
@@ -916,6 +954,11 @@ static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
{
int res;
+ if (!is_safe_path_component(name) || !is_safe_path_component(newname)) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
if (flags) {
fuse_reply_err(req, EINVAL);
return;
@@ -930,6 +973,11 @@ static void lo_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
{
int res;
+ if (!is_safe_path_component(name)) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
res = unlinkat(lo_fd(req, parent), name, 0);
fuse_reply_err(req, res == -1 ? errno : 0);
@@ -1093,12 +1141,6 @@ out_err:
fuse_reply_err(req, error);
}
-static int is_dot_or_dotdot(const char *name)
-{
- return name[0] == '.' &&
- (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'));
-}
-
static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
off_t offset, struct fuse_file_info *fi, int plus)
{
@@ -1248,6 +1290,11 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
parent, name);
}
+ if (!is_safe_path_component(name)) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
err = lo_change_cred(req, &old);
if (err) {
goto out;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 041/108] virtiofsd: Plumb fuse_bufvec through to do_write_buf
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (39 preceding siblings ...)
2020-01-23 16:45 ` [PULL 040/108] virtiofsd: validate path components Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 042/108] virtiofsd: Pass write iov's all the way through Dr. David Alan Gilbert (git)
` (68 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Let fuse_session_process_buf_int take a fuse_bufvec * instead of a
fuse_buf; and then through to do_write_buf - where in the best
case it can pass that straight through to op.write_buf without copying
(other than skipping a header).
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_i.h | 2 +-
tools/virtiofsd/fuse_lowlevel.c | 61 ++++++++++++++++++++++-----------
tools/virtiofsd/fuse_virtio.c | 3 +-
3 files changed, 44 insertions(+), 22 deletions(-)
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index 45995f3246..a20854f1c4 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -100,7 +100,7 @@ int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
void fuse_free_req(fuse_req_t req);
void fuse_session_process_buf_int(struct fuse_session *se,
- const struct fuse_buf *buf,
+ struct fuse_bufvec *bufv,
struct fuse_chan *ch);
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 95f4db8fcf..7e10995adc 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -1004,11 +1004,12 @@ static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
- const struct fuse_buf *ibuf)
+ struct fuse_bufvec *ibufv)
{
struct fuse_session *se = req->se;
- struct fuse_bufvec bufv = {
- .buf[0] = *ibuf,
+ struct fuse_bufvec *pbufv = ibufv;
+ struct fuse_bufvec tmpbufv = {
+ .buf[0] = ibufv->buf[0],
.count = 1,
};
struct fuse_write_in *arg = (struct fuse_write_in *)inarg;
@@ -1018,22 +1019,31 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
fi.fh = arg->fh;
fi.writepage = arg->write_flags & FUSE_WRITE_CACHE;
- fi.lock_owner = arg->lock_owner;
- fi.flags = arg->flags;
- if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD)) {
- bufv.buf[0].mem = PARAM(arg);
- }
-
- bufv.buf[0].size -=
- sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in);
- if (bufv.buf[0].size < arg->size) {
- fuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");
- fuse_reply_err(req, EIO);
- return;
+ if (ibufv->count == 1) {
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
+ if (!(tmpbufv.buf[0].flags & FUSE_BUF_IS_FD)) {
+ tmpbufv.buf[0].mem = PARAM(arg);
+ }
+ tmpbufv.buf[0].size -=
+ sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in);
+ if (tmpbufv.buf[0].size < arg->size) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: do_write_buf: buffer size too small\n");
+ fuse_reply_err(req, EIO);
+ return;
+ }
+ tmpbufv.buf[0].size = arg->size;
+ pbufv = &tmpbufv;
+ } else {
+ /*
+ * Input bufv contains the headers in the first element
+ * and the data in the rest, we need to skip that first element
+ */
+ ibufv->buf[0].size = 0;
}
- bufv.buf[0].size = arg->size;
- se->op.write_buf(req, nodeid, &bufv, arg->offset, &fi);
+ se->op.write_buf(req, nodeid, pbufv, arg->offset, &fi);
}
static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
@@ -2024,13 +2034,24 @@ static const char *opname(enum fuse_opcode opcode)
void fuse_session_process_buf(struct fuse_session *se,
const struct fuse_buf *buf)
{
- fuse_session_process_buf_int(se, buf, NULL);
+ struct fuse_bufvec bufv = { .buf[0] = *buf, .count = 1 };
+ fuse_session_process_buf_int(se, &bufv, NULL);
}
+/*
+ * Restriction:
+ * bufv is normally a single entry buffer, except for a write
+ * where (if it's in memory) then the bufv may be multiple entries,
+ * where the first entry contains all headers and subsequent entries
+ * contain data
+ * bufv shall not use any offsets etc to make the data anything
+ * other than contiguous starting from 0.
+ */
void fuse_session_process_buf_int(struct fuse_session *se,
- const struct fuse_buf *buf,
+ struct fuse_bufvec *bufv,
struct fuse_chan *ch)
{
+ const struct fuse_buf *buf = bufv->buf;
struct fuse_in_header *in;
const void *inarg;
struct fuse_req *req;
@@ -2108,7 +2129,7 @@ void fuse_session_process_buf_int(struct fuse_session *se,
inarg = (void *)&in[1];
if (in->opcode == FUSE_WRITE && se->op.write_buf) {
- do_write_buf(req, in->nodeid, inarg, buf);
+ do_write_buf(req, in->nodeid, inarg, bufv);
} else {
fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
}
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 635f87756a..fd588a4829 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -501,7 +501,8 @@ static void *fv_queue_thread(void *opaque)
/* TODO! Endianness of header */
/* TODO: Add checks for fuse_session_exited */
- fuse_session_process_buf_int(se, &fbuf, &ch);
+ struct fuse_bufvec bufv = { .buf[0] = fbuf, .count = 1 };
+ fuse_session_process_buf_int(se, &bufv, &ch);
if (!qi->reply_sent) {
fuse_log(FUSE_LOG_DEBUG, "%s: elem %d no reply sent\n",
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 042/108] virtiofsd: Pass write iov's all the way through
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (40 preceding siblings ...)
2020-01-23 16:45 ` [PULL 041/108] virtiofsd: Plumb fuse_bufvec through to do_write_buf Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 043/108] virtiofsd: add fuse_mbuf_iter API Dr. David Alan Gilbert (git)
` (67 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Pass the write iov pointing to guest RAM all the way through rather
than copying the data.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Xiao Yang <yangx.jy@cn.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_virtio.c | 79 ++++++++++++++++++++++++++++++++---
1 file changed, 73 insertions(+), 6 deletions(-)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index fd588a4829..872968f2c8 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -454,6 +454,10 @@ static void *fv_queue_thread(void *opaque)
__func__, qi->qidx, (size_t)evalue, in_bytes, out_bytes);
while (1) {
+ bool allocated_bufv = false;
+ struct fuse_bufvec bufv;
+ struct fuse_bufvec *pbufv;
+
/*
* An element contains one request and the space to send our
* response They're spread over multiple descriptors in a
@@ -495,14 +499,76 @@ static void *fv_queue_thread(void *opaque)
__func__, elem->index);
assert(0); /* TODO */
}
- copy_from_iov(&fbuf, out_num, out_sg);
- fbuf.size = out_len;
+ /* Copy just the first element and look at it */
+ copy_from_iov(&fbuf, 1, out_sg);
+
+ if (out_num > 2 &&
+ out_sg[0].iov_len == sizeof(struct fuse_in_header) &&
+ ((struct fuse_in_header *)fbuf.mem)->opcode == FUSE_WRITE &&
+ out_sg[1].iov_len == sizeof(struct fuse_write_in)) {
+ /*
+ * For a write we don't actually need to copy the
+ * data, we can just do it straight out of guest memory
+ * but we must still copy the headers in case the guest
+ * was nasty and changed them while we were using them.
+ */
+ fuse_log(FUSE_LOG_DEBUG, "%s: Write special case\n", __func__);
+
+ /* copy the fuse_write_in header after the fuse_in_header */
+ fbuf.mem += out_sg->iov_len;
+ copy_from_iov(&fbuf, 1, out_sg + 1);
+ fbuf.mem -= out_sg->iov_len;
+ fbuf.size = out_sg[0].iov_len + out_sg[1].iov_len;
+
+ /* Allocate the bufv, with space for the rest of the iov */
+ allocated_bufv = true;
+ pbufv = malloc(sizeof(struct fuse_bufvec) +
+ sizeof(struct fuse_buf) * (out_num - 2));
+ if (!pbufv) {
+ vu_queue_unpop(dev, q, elem, 0);
+ free(elem);
+ fuse_log(FUSE_LOG_ERR, "%s: pbufv malloc failed\n",
+ __func__);
+ goto out;
+ }
+
+ pbufv->count = 1;
+ pbufv->buf[0] = fbuf;
+
+ size_t iovindex, pbufvindex;
+ iovindex = 2; /* 2 headers, separate iovs */
+ pbufvindex = 1; /* 2 headers, 1 fusebuf */
+
+ for (; iovindex < out_num; iovindex++, pbufvindex++) {
+ pbufv->count++;
+ pbufv->buf[pbufvindex].pos = ~0; /* Dummy */
+ pbufv->buf[pbufvindex].flags = 0;
+ pbufv->buf[pbufvindex].mem = out_sg[iovindex].iov_base;
+ pbufv->buf[pbufvindex].size = out_sg[iovindex].iov_len;
+ }
+ } else {
+ /* Normal (non fast write) path */
+
+ /* Copy the rest of the buffer */
+ fbuf.mem += out_sg->iov_len;
+ copy_from_iov(&fbuf, out_num - 1, out_sg + 1);
+ fbuf.mem -= out_sg->iov_len;
+ fbuf.size = out_len;
- /* TODO! Endianness of header */
+ /* TODO! Endianness of header */
- /* TODO: Add checks for fuse_session_exited */
- struct fuse_bufvec bufv = { .buf[0] = fbuf, .count = 1 };
- fuse_session_process_buf_int(se, &bufv, &ch);
+ /* TODO: Add checks for fuse_session_exited */
+ bufv.buf[0] = fbuf;
+ bufv.count = 1;
+ pbufv = &bufv;
+ }
+ pbufv->idx = 0;
+ pbufv->off = 0;
+ fuse_session_process_buf_int(se, pbufv, &ch);
+
+ if (allocated_bufv) {
+ free(pbufv);
+ }
if (!qi->reply_sent) {
fuse_log(FUSE_LOG_DEBUG, "%s: elem %d no reply sent\n",
@@ -516,6 +582,7 @@ static void *fv_queue_thread(void *opaque)
elem = NULL;
}
}
+out:
pthread_mutex_destroy(&ch.lock);
free(fbuf.mem);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 043/108] virtiofsd: add fuse_mbuf_iter API
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (41 preceding siblings ...)
2020-01-23 16:45 ` [PULL 042/108] virtiofsd: Pass write iov's all the way through Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 044/108] virtiofsd: validate input buffer sizes in do_write_buf() Dr. David Alan Gilbert (git)
` (66 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Introduce an API for consuming bytes from a buffer with size checks.
All FUSE operations will be converted to use this safe API instead of
void *inarg.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/buffer.c | 28 ++++++++++++++++++++
tools/virtiofsd/fuse_common.h | 49 ++++++++++++++++++++++++++++++++++-
2 files changed, 76 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/buffer.c b/tools/virtiofsd/buffer.c
index 772efa922d..42a608f6bd 100644
--- a/tools/virtiofsd/buffer.c
+++ b/tools/virtiofsd/buffer.c
@@ -267,3 +267,31 @@ ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv)
return copied;
}
+
+void *fuse_mbuf_iter_advance(struct fuse_mbuf_iter *iter, size_t len)
+{
+ void *ptr;
+
+ if (len > iter->size - iter->pos) {
+ return NULL;
+ }
+
+ ptr = iter->mem + iter->pos;
+ iter->pos += len;
+ return ptr;
+}
+
+const char *fuse_mbuf_iter_advance_str(struct fuse_mbuf_iter *iter)
+{
+ const char *str = iter->mem + iter->pos;
+ size_t remaining = iter->size - iter->pos;
+ size_t i;
+
+ for (i = 0; i < remaining; i++) {
+ if (str[i] == '\0') {
+ iter->pos += i + 1;
+ return str;
+ }
+ }
+ return NULL;
+}
diff --git a/tools/virtiofsd/fuse_common.h b/tools/virtiofsd/fuse_common.h
index 0cb33acc2f..f8f6433743 100644
--- a/tools/virtiofsd/fuse_common.h
+++ b/tools/virtiofsd/fuse_common.h
@@ -703,10 +703,57 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv);
*/
ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src);
+/**
+ * Memory buffer iterator
+ *
+ */
+struct fuse_mbuf_iter {
+ /**
+ * Data pointer
+ */
+ void *mem;
+
+ /**
+ * Total length, in bytes
+ */
+ size_t size;
+
+ /**
+ * Offset from start of buffer
+ */
+ size_t pos;
+};
+
+/* Initialize memory buffer iterator from a fuse_buf */
+#define FUSE_MBUF_ITER_INIT(fbuf) \
+ ((struct fuse_mbuf_iter){ \
+ .mem = fbuf->mem, \
+ .size = fbuf->size, \
+ .pos = 0, \
+ })
+
+/**
+ * Consume bytes from a memory buffer iterator
+ *
+ * @param iter memory buffer iterator
+ * @param len number of bytes to consume
+ * @return pointer to start of consumed bytes or
+ * NULL if advancing beyond end of buffer
+ */
+void *fuse_mbuf_iter_advance(struct fuse_mbuf_iter *iter, size_t len);
+
+/**
+ * Consume a NUL-terminated string from a memory buffer iterator
+ *
+ * @param iter memory buffer iterator
+ * @return pointer to the string or
+ * NULL if advancing beyond end of buffer or there is no NUL-terminator
+ */
+const char *fuse_mbuf_iter_advance_str(struct fuse_mbuf_iter *iter);
+
/*
* Signal handling
*/
-
/**
* Exit session on HUP, TERM and INT signals and ignore PIPE signal
*
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 044/108] virtiofsd: validate input buffer sizes in do_write_buf()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (42 preceding siblings ...)
2020-01-23 16:45 ` [PULL 043/108] virtiofsd: add fuse_mbuf_iter API Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 045/108] virtiofsd: check input buffer size in fuse_lowlevel.c ops Dr. David Alan Gilbert (git)
` (65 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
There is a small change in behavior: if fuse_write_in->size doesn't
match the input buffer size then the request is failed. Previously
write requests with 1 fuse_buf element would truncate to
fuse_write_in->size.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Sergio Lopez <slp@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 49 ++++++++++++++++++++-------------
1 file changed, 30 insertions(+), 19 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 7e10995adc..611e8b0354 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -1003,8 +1003,8 @@ static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
- struct fuse_bufvec *ibufv)
+static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter, struct fuse_bufvec *ibufv)
{
struct fuse_session *se = req->se;
struct fuse_bufvec *pbufv = ibufv;
@@ -1012,28 +1012,27 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
.buf[0] = ibufv->buf[0],
.count = 1,
};
- struct fuse_write_in *arg = (struct fuse_write_in *)inarg;
+ struct fuse_write_in *arg;
+ size_t arg_size = sizeof(*arg);
struct fuse_file_info fi;
memset(&fi, 0, sizeof(fi));
+
+ arg = fuse_mbuf_iter_advance(iter, arg_size);
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
+ fi.lock_owner = arg->lock_owner;
+ fi.flags = arg->flags;
fi.fh = arg->fh;
fi.writepage = arg->write_flags & FUSE_WRITE_CACHE;
if (ibufv->count == 1) {
- fi.lock_owner = arg->lock_owner;
- fi.flags = arg->flags;
- if (!(tmpbufv.buf[0].flags & FUSE_BUF_IS_FD)) {
- tmpbufv.buf[0].mem = PARAM(arg);
- }
- tmpbufv.buf[0].size -=
- sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in);
- if (tmpbufv.buf[0].size < arg->size) {
- fuse_log(FUSE_LOG_ERR,
- "fuse: do_write_buf: buffer size too small\n");
- fuse_reply_err(req, EIO);
- return;
- }
- tmpbufv.buf[0].size = arg->size;
+ assert(!(tmpbufv.buf[0].flags & FUSE_BUF_IS_FD));
+ tmpbufv.buf[0].mem = ((char *)arg) + arg_size;
+ tmpbufv.buf[0].size -= sizeof(struct fuse_in_header) + arg_size;
pbufv = &tmpbufv;
} else {
/*
@@ -1043,6 +1042,13 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
ibufv->buf[0].size = 0;
}
+ if (fuse_buf_size(pbufv) != arg->size) {
+ fuse_log(FUSE_LOG_ERR,
+ "fuse: do_write_buf: buffer size doesn't match arg->size\n");
+ fuse_reply_err(req, EIO);
+ return;
+ }
+
se->op.write_buf(req, nodeid, pbufv, arg->offset, &fi);
}
@@ -2052,12 +2058,17 @@ void fuse_session_process_buf_int(struct fuse_session *se,
struct fuse_chan *ch)
{
const struct fuse_buf *buf = bufv->buf;
+ struct fuse_mbuf_iter iter = FUSE_MBUF_ITER_INIT(buf);
struct fuse_in_header *in;
const void *inarg;
struct fuse_req *req;
int err;
- in = buf->mem;
+ /* The first buffer must be a memory buffer */
+ assert(!(buf->flags & FUSE_BUF_IS_FD));
+
+ in = fuse_mbuf_iter_advance(&iter, sizeof(*in));
+ assert(in); /* caller guarantees the input buffer is large enough */
if (se->debug) {
fuse_log(FUSE_LOG_DEBUG,
@@ -2129,7 +2140,7 @@ void fuse_session_process_buf_int(struct fuse_session *se,
inarg = (void *)&in[1];
if (in->opcode == FUSE_WRITE && se->op.write_buf) {
- do_write_buf(req, in->nodeid, inarg, bufv);
+ do_write_buf(req, in->nodeid, &iter, bufv);
} else {
fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 045/108] virtiofsd: check input buffer size in fuse_lowlevel.c ops
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (43 preceding siblings ...)
2020-01-23 16:45 ` [PULL 044/108] virtiofsd: validate input buffer sizes in do_write_buf() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 046/108] virtiofsd: prevent ".." escape in lo_do_lookup() Dr. David Alan Gilbert (git)
` (64 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Each FUSE operation involves parsing the input buffer. Currently the
code assumes the input buffer is large enough for the expected
arguments. This patch uses fuse_mbuf_iter to check the size.
Most operations are simple to convert. Some are more complicated due to
variable-length inputs or different sizes depending on the protocol
version.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Sergio Lopez <slp@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 581 +++++++++++++++++++++++++-------
1 file changed, 456 insertions(+), 125 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 611e8b0354..02e1d83038 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -19,6 +19,7 @@
#include <assert.h>
#include <errno.h>
#include <limits.h>
+#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
@@ -27,7 +28,6 @@
#include <unistd.h>
-#define PARAM(inarg) (((char *)(inarg)) + sizeof(*(inarg)))
#define OFFSET_MAX 0x7fffffffffffffffLL
struct fuse_pollhandle {
@@ -706,9 +706,14 @@ int fuse_reply_lseek(fuse_req_t req, off_t off)
return send_reply_ok(req, &arg, sizeof(arg));
}
-static void do_lookup(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_lookup(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- char *name = (char *)inarg;
+ const char *name = fuse_mbuf_iter_advance_str(iter);
+ if (!name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.lookup) {
req->se->op.lookup(req, nodeid, name);
@@ -717,9 +722,16 @@ static void do_lookup(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_forget(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_forget(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_forget_in *arg = (struct fuse_forget_in *)inarg;
+ struct fuse_forget_in *arg;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.forget) {
req->se->op.forget(req, nodeid, arg->nlookup);
@@ -729,20 +741,48 @@ static void do_forget(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
static void do_batch_forget(fuse_req_t req, fuse_ino_t nodeid,
- const void *inarg)
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_batch_forget_in *arg = (void *)inarg;
- struct fuse_forget_one *param = (void *)PARAM(arg);
- unsigned int i;
+ struct fuse_batch_forget_in *arg;
+ struct fuse_forget_data *forgets;
+ size_t scount;
(void)nodeid;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_none(req);
+ return;
+ }
+
+ /*
+ * Prevent integer overflow. The compiler emits the following warning
+ * unless we use the scount local variable:
+ *
+ * error: comparison is always false due to limited range of data type
+ * [-Werror=type-limits]
+ *
+ * This may be true on 64-bit hosts but we need this check for 32-bit
+ * hosts.
+ */
+ scount = arg->count;
+ if (scount > SIZE_MAX / sizeof(forgets[0])) {
+ fuse_reply_none(req);
+ return;
+ }
+
+ forgets = fuse_mbuf_iter_advance(iter, arg->count * sizeof(forgets[0]));
+ if (!forgets) {
+ fuse_reply_none(req);
+ return;
+ }
+
if (req->se->op.forget_multi) {
- req->se->op.forget_multi(req, arg->count,
- (struct fuse_forget_data *)param);
+ req->se->op.forget_multi(req, arg->count, forgets);
} else if (req->se->op.forget) {
+ unsigned int i;
+
for (i = 0; i < arg->count; i++) {
- struct fuse_forget_one *forget = ¶m[i];
struct fuse_req *dummy_req;
dummy_req = fuse_ll_alloc_req(req->se);
@@ -754,7 +794,7 @@ static void do_batch_forget(fuse_req_t req, fuse_ino_t nodeid,
dummy_req->ctx = req->ctx;
dummy_req->ch = NULL;
- req->se->op.forget(dummy_req, forget->nodeid, forget->nlookup);
+ req->se->op.forget(dummy_req, forgets[i].ino, forgets[i].nlookup);
}
fuse_reply_none(req);
} else {
@@ -762,12 +802,19 @@ static void do_batch_forget(fuse_req_t req, fuse_ino_t nodeid,
}
}
-static void do_getattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_getattr(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
struct fuse_file_info *fip = NULL;
struct fuse_file_info fi;
- struct fuse_getattr_in *arg = (struct fuse_getattr_in *)inarg;
+ struct fuse_getattr_in *arg;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (arg->getattr_flags & FUSE_GETATTR_FH) {
memset(&fi, 0, sizeof(fi));
@@ -782,14 +829,21 @@ static void do_getattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_setattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_setattr(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_setattr_in *arg = (struct fuse_setattr_in *)inarg;
-
if (req->se->op.setattr) {
+ struct fuse_setattr_in *arg;
struct fuse_file_info *fi = NULL;
struct fuse_file_info fi_store;
struct stat stbuf;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&stbuf, 0, sizeof(stbuf));
convert_attr(arg, &stbuf);
if (arg->valid & FATTR_FH) {
@@ -810,9 +864,16 @@ static void do_setattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_access(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_access(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_access_in *arg = (struct fuse_access_in *)inarg;
+ struct fuse_access_in *arg;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.access) {
req->se->op.access(req, nodeid, arg->mask);
@@ -821,9 +882,10 @@ static void do_access(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_readlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_readlink(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- (void)inarg;
+ (void)iter;
if (req->se->op.readlink) {
req->se->op.readlink(req, nodeid);
@@ -832,10 +894,18 @@ static void do_readlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_mknod(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_mknod(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_mknod_in *arg = (struct fuse_mknod_in *)inarg;
- char *name = PARAM(arg);
+ struct fuse_mknod_in *arg;
+ const char *name;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ name = fuse_mbuf_iter_advance_str(iter);
+ if (!arg || !name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
req->ctx.umask = arg->umask;
@@ -846,22 +916,37 @@ static void do_mknod(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_mkdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_mkdir(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *)inarg;
+ struct fuse_mkdir_in *arg;
+ const char *name;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ name = fuse_mbuf_iter_advance_str(iter);
+ if (!arg || !name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
req->ctx.umask = arg->umask;
if (req->se->op.mkdir) {
- req->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
+ req->se->op.mkdir(req, nodeid, name, arg->mode);
} else {
fuse_reply_err(req, ENOSYS);
}
}
-static void do_unlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_unlink(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- char *name = (char *)inarg;
+ const char *name = fuse_mbuf_iter_advance_str(iter);
+
+ if (!name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.unlink) {
req->se->op.unlink(req, nodeid, name);
@@ -870,9 +955,15 @@ static void do_unlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_rmdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_rmdir(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- char *name = (char *)inarg;
+ const char *name = fuse_mbuf_iter_advance_str(iter);
+
+ if (!name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.rmdir) {
req->se->op.rmdir(req, nodeid, name);
@@ -881,10 +972,16 @@ static void do_rmdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_symlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_symlink(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- char *name = (char *)inarg;
- char *linkname = ((char *)inarg) + strlen((char *)inarg) + 1;
+ const char *name = fuse_mbuf_iter_advance_str(iter);
+ const char *linkname = fuse_mbuf_iter_advance_str(iter);
+
+ if (!name || !linkname) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.symlink) {
req->se->op.symlink(req, linkname, nodeid, name);
@@ -893,11 +990,20 @@ static void do_symlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_rename(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_rename(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_rename_in *arg = (struct fuse_rename_in *)inarg;
- char *oldname = PARAM(arg);
- char *newname = oldname + strlen(oldname) + 1;
+ struct fuse_rename_in *arg;
+ const char *oldname;
+ const char *newname;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ oldname = fuse_mbuf_iter_advance_str(iter);
+ newname = fuse_mbuf_iter_advance_str(iter);
+ if (!arg || !oldname || !newname) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.rename) {
req->se->op.rename(req, nodeid, oldname, arg->newdir, newname, 0);
@@ -906,11 +1012,20 @@ static void do_rename(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_rename2(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_rename2(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_rename2_in *arg = (struct fuse_rename2_in *)inarg;
- char *oldname = PARAM(arg);
- char *newname = oldname + strlen(oldname) + 1;
+ struct fuse_rename2_in *arg;
+ const char *oldname;
+ const char *newname;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ oldname = fuse_mbuf_iter_advance_str(iter);
+ newname = fuse_mbuf_iter_advance_str(iter);
+ if (!arg || !oldname || !newname) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.rename) {
req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
@@ -920,24 +1035,38 @@ static void do_rename2(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_link(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_link(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_link_in *arg = (struct fuse_link_in *)inarg;
+ struct fuse_link_in *arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ const char *name = fuse_mbuf_iter_advance_str(iter);
+
+ if (!arg || !name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.link) {
- req->se->op.link(req, arg->oldnodeid, nodeid, PARAM(arg));
+ req->se->op.link(req, arg->oldnodeid, nodeid, name);
} else {
fuse_reply_err(req, ENOSYS);
}
}
-static void do_create(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_create(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_create_in *arg = (struct fuse_create_in *)inarg;
-
if (req->se->op.create) {
+ struct fuse_create_in *arg;
struct fuse_file_info fi;
- char *name = PARAM(arg);
+ const char *name;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ name = fuse_mbuf_iter_advance_str(iter);
+ if (!arg || !name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
memset(&fi, 0, sizeof(fi));
fi.flags = arg->flags;
@@ -950,11 +1079,18 @@ static void do_create(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_open(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_open(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_open_in *arg = (struct fuse_open_in *)inarg;
+ struct fuse_open_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.flags = arg->flags;
@@ -965,13 +1101,15 @@ static void do_open(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_read(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_read(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_read_in *arg = (struct fuse_read_in *)inarg;
-
if (req->se->op.read) {
+ struct fuse_read_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
fi.lock_owner = arg->lock_owner;
@@ -982,11 +1120,24 @@ static void do_read(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_write(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_write_in *arg = (struct fuse_write_in *)inarg;
+ struct fuse_write_in *arg;
struct fuse_file_info fi;
- char *param;
+ const char *param;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
+ param = fuse_mbuf_iter_advance(iter, arg->size);
+ if (!param) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
@@ -994,7 +1145,6 @@ static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
fi.lock_owner = arg->lock_owner;
fi.flags = arg->flags;
- param = PARAM(arg);
if (req->se->op.write) {
req->se->op.write(req, nodeid, param, arg->size, arg->offset, &fi);
@@ -1052,11 +1202,18 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid,
se->op.write_buf(req, nodeid, pbufv, arg->offset, &fi);
}
-static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_flush(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_flush_in *arg = (struct fuse_flush_in *)inarg;
+ struct fuse_flush_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
fi.flush = 1;
@@ -1069,19 +1226,26 @@ static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_release(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_release(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_release_in *arg = (struct fuse_release_in *)inarg;
+ struct fuse_release_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.flags = arg->flags;
fi.fh = arg->fh;
fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
fi.lock_owner = arg->lock_owner;
+
if (arg->release_flags & FUSE_RELEASE_FLOCK_UNLOCK) {
fi.flock_release = 1;
- fi.lock_owner = arg->lock_owner;
}
if (req->se->op.release) {
@@ -1091,11 +1255,19 @@ static void do_release(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_fsync(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_fsync(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_fsync_in *arg = (struct fuse_fsync_in *)inarg;
+ struct fuse_fsync_in *arg;
struct fuse_file_info fi;
- int datasync = arg->fsync_flags & 1;
+ int datasync;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+ datasync = arg->fsync_flags & 1;
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
@@ -1111,11 +1283,18 @@ static void do_fsync(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_opendir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_opendir(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_open_in *arg = (struct fuse_open_in *)inarg;
+ struct fuse_open_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.flags = arg->flags;
@@ -1126,11 +1305,18 @@ static void do_opendir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_readdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_readdir(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_read_in *arg = (struct fuse_read_in *)inarg;
+ struct fuse_read_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
@@ -1141,11 +1327,18 @@ static void do_readdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_readdirplus(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_readdirplus(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_read_in *arg = (struct fuse_read_in *)inarg;
+ struct fuse_read_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
@@ -1156,11 +1349,18 @@ static void do_readdirplus(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_releasedir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_releasedir(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_release_in *arg = (struct fuse_release_in *)inarg;
+ struct fuse_release_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.flags = arg->flags;
fi.fh = arg->fh;
@@ -1172,11 +1372,19 @@ static void do_releasedir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_fsyncdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_fsyncdir(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_fsync_in *arg = (struct fuse_fsync_in *)inarg;
+ struct fuse_fsync_in *arg;
struct fuse_file_info fi;
- int datasync = arg->fsync_flags & 1;
+ int datasync;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+ datasync = arg->fsync_flags & 1;
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
@@ -1188,10 +1396,11 @@ static void do_fsyncdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_statfs(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_statfs(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
(void)nodeid;
- (void)inarg;
+ (void)iter;
if (req->se->op.statfs) {
req->se->op.statfs(req, nodeid);
@@ -1204,11 +1413,25 @@ static void do_statfs(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_setxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_setxattr(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_setxattr_in *arg = (struct fuse_setxattr_in *)inarg;
- char *name = PARAM(arg);
- char *value = name + strlen(name) + 1;
+ struct fuse_setxattr_in *arg;
+ const char *name;
+ const char *value;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ name = fuse_mbuf_iter_advance_str(iter);
+ if (!arg || !name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
+ value = fuse_mbuf_iter_advance(iter, arg->size);
+ if (!value) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.setxattr) {
req->se->op.setxattr(req, nodeid, name, value, arg->size, arg->flags);
@@ -1217,20 +1440,36 @@ static void do_setxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_getxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_getxattr(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *)inarg;
+ struct fuse_getxattr_in *arg;
+ const char *name;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ name = fuse_mbuf_iter_advance_str(iter);
+ if (!arg || !name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.getxattr) {
- req->se->op.getxattr(req, nodeid, PARAM(arg), arg->size);
+ req->se->op.getxattr(req, nodeid, name, arg->size);
} else {
fuse_reply_err(req, ENOSYS);
}
}
-static void do_listxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_listxattr(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *)inarg;
+ struct fuse_getxattr_in *arg;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.listxattr) {
req->se->op.listxattr(req, nodeid, arg->size);
@@ -1239,9 +1478,15 @@ static void do_listxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_removexattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_removexattr(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- char *name = (char *)inarg;
+ const char *name = fuse_mbuf_iter_advance_str(iter);
+
+ if (!name) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.removexattr) {
req->se->op.removexattr(req, nodeid, name);
@@ -1265,12 +1510,19 @@ static void convert_fuse_file_lock(struct fuse_file_lock *fl,
flock->l_pid = fl->pid;
}
-static void do_getlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_getlk(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_lk_in *arg = (struct fuse_lk_in *)inarg;
+ struct fuse_lk_in *arg;
struct fuse_file_info fi;
struct flock flock;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
fi.lock_owner = arg->owner;
@@ -1284,12 +1536,18 @@ static void do_getlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
static void do_setlk_common(fuse_req_t req, fuse_ino_t nodeid,
- const void *inarg, int sleep)
+ struct fuse_mbuf_iter *iter, int sleep)
{
- struct fuse_lk_in *arg = (struct fuse_lk_in *)inarg;
+ struct fuse_lk_in *arg;
struct fuse_file_info fi;
struct flock flock;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
fi.lock_owner = arg->owner;
@@ -1327,14 +1585,16 @@ static void do_setlk_common(fuse_req_t req, fuse_ino_t nodeid,
}
}
-static void do_setlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_setlk(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- do_setlk_common(req, nodeid, inarg, 0);
+ do_setlk_common(req, nodeid, iter, 0);
}
-static void do_setlkw(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_setlkw(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- do_setlk_common(req, nodeid, inarg, 1);
+ do_setlk_common(req, nodeid, iter, 1);
}
static int find_interrupted(struct fuse_session *se, struct fuse_req *req)
@@ -1379,12 +1639,20 @@ static int find_interrupted(struct fuse_session *se, struct fuse_req *req)
return 0;
}
-static void do_interrupt(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_interrupt(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_interrupt_in *arg = (struct fuse_interrupt_in *)inarg;
+ struct fuse_interrupt_in *arg;
struct fuse_session *se = req->se;
(void)nodeid;
+
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
if (se->debug) {
fuse_log(FUSE_LOG_DEBUG, "INTERRUPT: %llu\n",
(unsigned long long)arg->unique);
@@ -1425,9 +1693,15 @@ static struct fuse_req *check_interrupt(struct fuse_session *se,
}
}
-static void do_bmap(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_bmap(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_bmap_in *arg = (struct fuse_bmap_in *)inarg;
+ struct fuse_bmap_in *arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
if (req->se->op.bmap) {
req->se->op.bmap(req, nodeid, arg->blocksize, arg->block);
@@ -1436,18 +1710,34 @@ static void do_bmap(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_ioctl(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_ioctl(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_ioctl_in *arg = (struct fuse_ioctl_in *)inarg;
- unsigned int flags = arg->flags;
- void *in_buf = arg->in_size ? PARAM(arg) : NULL;
+ struct fuse_ioctl_in *arg;
+ unsigned int flags;
+ void *in_buf = NULL;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
+ flags = arg->flags;
if (flags & FUSE_IOCTL_DIR && !(req->se->conn.want & FUSE_CAP_IOCTL_DIR)) {
fuse_reply_err(req, ENOTTY);
return;
}
+ if (arg->in_size) {
+ in_buf = fuse_mbuf_iter_advance(iter, arg->in_size);
+ if (!in_buf) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+ }
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
@@ -1468,11 +1758,18 @@ void fuse_pollhandle_destroy(struct fuse_pollhandle *ph)
free(ph);
}
-static void do_poll(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_poll(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_poll_in *arg = (struct fuse_poll_in *)inarg;
+ struct fuse_poll_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
fi.poll_events = arg->events;
@@ -1496,11 +1793,18 @@ static void do_poll(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_fallocate(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_fallocate(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_fallocate_in *arg = (struct fuse_fallocate_in *)inarg;
+ struct fuse_fallocate_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
@@ -1513,12 +1817,17 @@ static void do_fallocate(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
static void do_copy_file_range(fuse_req_t req, fuse_ino_t nodeid_in,
- const void *inarg)
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_copy_file_range_in *arg =
- (struct fuse_copy_file_range_in *)inarg;
+ struct fuse_copy_file_range_in *arg;
struct fuse_file_info fi_in, fi_out;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
memset(&fi_in, 0, sizeof(fi_in));
fi_in.fh = arg->fh_in;
@@ -1535,11 +1844,17 @@ static void do_copy_file_range(fuse_req_t req, fuse_ino_t nodeid_in,
}
}
-static void do_lseek(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_lseek(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_lseek_in *arg = (struct fuse_lseek_in *)inarg;
+ struct fuse_lseek_in *arg;
struct fuse_file_info fi;
+ arg = fuse_mbuf_iter_advance(iter, sizeof(*arg));
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
@@ -1550,15 +1865,33 @@ static void do_lseek(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
}
}
-static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_init(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
- struct fuse_init_in *arg = (struct fuse_init_in *)inarg;
+ size_t compat_size = offsetof(struct fuse_init_in, max_readahead);
+ struct fuse_init_in *arg;
struct fuse_init_out outarg;
struct fuse_session *se = req->se;
size_t bufsize = se->bufsize;
size_t outargsize = sizeof(outarg);
(void)nodeid;
+
+ /* First consume the old fields... */
+ arg = fuse_mbuf_iter_advance(iter, compat_size);
+ if (!arg) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+
+ /* ...and now consume the new fields. */
+ if (arg->major == 7 && arg->minor >= 6) {
+ if (!fuse_mbuf_iter_advance(iter, sizeof(*arg) - compat_size)) {
+ fuse_reply_err(req, EINVAL);
+ return;
+ }
+ }
+
if (se->debug) {
fuse_log(FUSE_LOG_DEBUG, "INIT: %u.%u\n", arg->major, arg->minor);
if (arg->major == 7 && arg->minor >= 6) {
@@ -1791,12 +2124,13 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
send_reply_ok(req, &outarg, outargsize);
}
-static void do_destroy(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
+static void do_destroy(fuse_req_t req, fuse_ino_t nodeid,
+ struct fuse_mbuf_iter *iter)
{
struct fuse_session *se = req->se;
(void)nodeid;
- (void)inarg;
+ (void)iter;
se->got_destroy = 1;
if (se->op.destroy) {
@@ -1976,7 +2310,7 @@ int fuse_req_interrupted(fuse_req_t req)
}
static struct {
- void (*func)(fuse_req_t, fuse_ino_t, const void *);
+ void (*func)(fuse_req_t, fuse_ino_t, struct fuse_mbuf_iter *);
const char *name;
} fuse_ll_ops[] = {
[FUSE_LOOKUP] = { do_lookup, "LOOKUP" },
@@ -2060,7 +2394,6 @@ void fuse_session_process_buf_int(struct fuse_session *se,
const struct fuse_buf *buf = bufv->buf;
struct fuse_mbuf_iter iter = FUSE_MBUF_ITER_INIT(buf);
struct fuse_in_header *in;
- const void *inarg;
struct fuse_req *req;
int err;
@@ -2138,13 +2471,11 @@ void fuse_session_process_buf_int(struct fuse_session *se,
}
}
- inarg = (void *)&in[1];
if (in->opcode == FUSE_WRITE && se->op.write_buf) {
do_write_buf(req, in->nodeid, &iter, bufv);
} else {
- fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
+ fuse_ll_ops[in->opcode].func(req, in->nodeid, &iter);
}
-
return;
reply_err:
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 046/108] virtiofsd: prevent ".." escape in lo_do_lookup()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (44 preceding siblings ...)
2020-01-23 16:45 ` [PULL 045/108] virtiofsd: check input buffer size in fuse_lowlevel.c ops Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 047/108] virtiofsd: prevent ".." escape in lo_do_readdir() Dr. David Alan Gilbert (git)
` (63 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Sergio Lopez <slp@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index e375406160..79d5966eea 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -624,12 +624,17 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
int res;
int saverr;
struct lo_data *lo = lo_data(req);
- struct lo_inode *inode;
+ struct lo_inode *inode, *dir = lo_inode(req, parent);
memset(e, 0, sizeof(*e));
e->attr_timeout = lo->timeout;
e->entry_timeout = lo->timeout;
+ /* Do not allow escaping root directory */
+ if (dir == &lo->root && strcmp(name, "..") == 0) {
+ name = ".";
+ }
+
newfd = openat(lo_fd(req, parent), name, O_PATH | O_NOFOLLOW);
if (newfd == -1) {
goto out_err;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 047/108] virtiofsd: prevent ".." escape in lo_do_readdir()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (45 preceding siblings ...)
2020-01-23 16:45 ` [PULL 046/108] virtiofsd: prevent ".." escape in lo_do_lookup() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 048/108] virtiofsd: use /proc/self/fd/ O_PATH file descriptor Dr. David Alan Gilbert (git)
` (62 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Construct a fake dirent for the root directory's ".." entry. This hides
the parent directory from the FUSE client.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Sergio Lopez <slp@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 36 +++++++++++++++++++-------------
1 file changed, 22 insertions(+), 14 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 79d5966eea..e3d65c3676 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1149,19 +1149,25 @@ out_err:
static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
off_t offset, struct fuse_file_info *fi, int plus)
{
+ struct lo_data *lo = lo_data(req);
struct lo_dirp *d;
+ struct lo_inode *dinode;
char *buf = NULL;
char *p;
size_t rem = size;
- int err = ENOMEM;
+ int err = EBADF;
- (void)ino;
+ dinode = lo_inode(req, ino);
+ if (!dinode) {
+ goto error;
+ }
d = lo_dirp(req, fi);
if (!d) {
goto error;
}
+ err = ENOMEM;
buf = calloc(1, size);
if (!buf) {
goto error;
@@ -1192,15 +1198,21 @@ static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
}
nextoff = d->entry->d_off;
name = d->entry->d_name;
+
fuse_ino_t entry_ino = 0;
+ struct fuse_entry_param e = (struct fuse_entry_param){
+ .attr.st_ino = d->entry->d_ino,
+ .attr.st_mode = d->entry->d_type << 12,
+ };
+
+ /* Hide root's parent directory */
+ if (dinode == &lo->root && strcmp(name, "..") == 0) {
+ e.attr.st_ino = lo->root.ino;
+ e.attr.st_mode = DT_DIR << 12;
+ }
+
if (plus) {
- struct fuse_entry_param e;
- if (is_dot_or_dotdot(name)) {
- e = (struct fuse_entry_param){
- .attr.st_ino = d->entry->d_ino,
- .attr.st_mode = d->entry->d_type << 12,
- };
- } else {
+ if (!is_dot_or_dotdot(name)) {
err = lo_do_lookup(req, ino, name, &e);
if (err) {
goto error;
@@ -1210,11 +1222,7 @@ static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
entsize = fuse_add_direntry_plus(req, p, rem, name, &e, nextoff);
} else {
- struct stat st = {
- .st_ino = d->entry->d_ino,
- .st_mode = d->entry->d_type << 12,
- };
- entsize = fuse_add_direntry(req, p, rem, name, &st, nextoff);
+ entsize = fuse_add_direntry(req, p, rem, name, &e.attr, nextoff);
}
if (entsize > rem) {
if (entry_ino != 0) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 048/108] virtiofsd: use /proc/self/fd/ O_PATH file descriptor
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (46 preceding siblings ...)
2020-01-23 16:45 ` [PULL 047/108] virtiofsd: prevent ".." escape in lo_do_readdir() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 049/108] virtiofsd: sandbox mount namespace Dr. David Alan Gilbert (git)
` (61 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Sandboxing will remove /proc from the mount namespace so we can no
longer build string paths into "/proc/self/fd/...".
Keep an O_PATH file descriptor so we can still re-open fds via
/proc/self/fd.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 130 ++++++++++++++++++++++++-------
1 file changed, 103 insertions(+), 27 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index e3d65c3676..e2e2211ea1 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -110,6 +110,9 @@ struct lo_data {
struct lo_map ino_map; /* protected by lo->mutex */
struct lo_map dirp_map; /* protected by lo->mutex */
struct lo_map fd_map; /* protected by lo->mutex */
+
+ /* An O_PATH file descriptor to /proc/self/fd/ */
+ int proc_self_fd;
};
static const struct fuse_opt lo_opts[] = {
@@ -379,9 +382,9 @@ static int lo_parent_and_name(struct lo_data *lo, struct lo_inode *inode,
int res;
retry:
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(procname, "%i", inode->fd);
- res = readlink(procname, path, PATH_MAX);
+ res = readlinkat(lo->proc_self_fd, procname, path, PATH_MAX);
if (res < 0) {
fuse_log(FUSE_LOG_WARNING, "%s: readlink failed: %m\n", __func__);
goto fail_noretry;
@@ -477,9 +480,9 @@ static int utimensat_empty(struct lo_data *lo, struct lo_inode *inode,
}
return res;
}
- sprintf(path, "/proc/self/fd/%i", inode->fd);
+ sprintf(path, "%i", inode->fd);
- return utimensat(AT_FDCWD, path, tv, 0);
+ return utimensat(lo->proc_self_fd, path, tv, 0);
fallback:
res = lo_parent_and_name(lo, inode, path, &parent);
@@ -535,8 +538,8 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
if (fi) {
res = fchmod(fd, attr->st_mode);
} else {
- sprintf(procname, "/proc/self/fd/%i", ifd);
- res = chmod(procname, attr->st_mode);
+ sprintf(procname, "%i", ifd);
+ res = fchmodat(lo->proc_self_fd, procname, attr->st_mode, 0);
}
if (res == -1) {
goto out_err;
@@ -552,11 +555,23 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
}
}
if (valid & FUSE_SET_ATTR_SIZE) {
+ int truncfd;
+
if (fi) {
- res = ftruncate(fd, attr->st_size);
+ truncfd = fd;
} else {
- sprintf(procname, "/proc/self/fd/%i", ifd);
- res = truncate(procname, attr->st_size);
+ sprintf(procname, "%i", ifd);
+ truncfd = openat(lo->proc_self_fd, procname, O_RDWR);
+ if (truncfd < 0) {
+ goto out_err;
+ }
+ }
+
+ res = ftruncate(truncfd, attr->st_size);
+ if (!fi) {
+ saverr = errno;
+ close(truncfd);
+ errno = saverr;
}
if (res == -1) {
goto out_err;
@@ -874,9 +889,9 @@ static int linkat_empty_nofollow(struct lo_data *lo, struct lo_inode *inode,
return res;
}
- sprintf(path, "/proc/self/fd/%i", inode->fd);
+ sprintf(path, "%i", inode->fd);
- return linkat(AT_FDCWD, path, dfd, name, AT_SYMLINK_FOLLOW);
+ return linkat(lo->proc_self_fd, path, dfd, name, AT_SYMLINK_FOLLOW);
fallback:
res = lo_parent_and_name(lo, inode, path, &parent);
@@ -1404,8 +1419,8 @@ static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
fi->flags &= ~O_APPEND;
}
- sprintf(buf, "/proc/self/fd/%i", lo_fd(req, ino));
- fd = open(buf, fi->flags & ~O_NOFOLLOW);
+ sprintf(buf, "%i", lo_fd(req, ino));
+ fd = openat(lo->proc_self_fd, buf, fi->flags & ~O_NOFOLLOW);
if (fd == -1) {
return (void)fuse_reply_err(req, errno);
}
@@ -1458,7 +1473,6 @@ static void lo_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
struct fuse_file_info *fi)
{
int res;
- (void)ino;
int fd;
char *buf;
@@ -1466,12 +1480,14 @@ static void lo_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
(void *)fi);
if (!fi) {
- res = asprintf(&buf, "/proc/self/fd/%i", lo_fd(req, ino));
+ struct lo_data *lo = lo_data(req);
+
+ res = asprintf(&buf, "%i", lo_fd(req, ino));
if (res == -1) {
return (void)fuse_reply_err(req, errno);
}
- fd = open(buf, O_RDWR);
+ fd = openat(lo->proc_self_fd, buf, O_RDWR);
free(buf);
if (fd == -1) {
return (void)fuse_reply_err(req, errno);
@@ -1587,11 +1603,13 @@ static void lo_flock(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
size_t size)
{
+ struct lo_data *lo = lo_data(req);
char *value = NULL;
char procname[64];
struct lo_inode *inode;
ssize_t ret;
int saverr;
+ int fd = -1;
inode = lo_inode(req, ino);
if (!inode) {
@@ -1616,7 +1634,11 @@ static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
goto out;
}
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(procname, "%i", inode->fd);
+ fd = openat(lo->proc_self_fd, procname, O_RDONLY);
+ if (fd < 0) {
+ goto out_err;
+ }
if (size) {
value = malloc(size);
@@ -1624,7 +1646,7 @@ static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
goto out_err;
}
- ret = getxattr(procname, name, value, size);
+ ret = fgetxattr(fd, name, value, size);
if (ret == -1) {
goto out_err;
}
@@ -1635,7 +1657,7 @@ static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
fuse_reply_buf(req, value, ret);
} else {
- ret = getxattr(procname, name, NULL, 0);
+ ret = fgetxattr(fd, name, NULL, 0);
if (ret == -1) {
goto out_err;
}
@@ -1644,6 +1666,10 @@ static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
}
out_free:
free(value);
+
+ if (fd >= 0) {
+ close(fd);
+ }
return;
out_err:
@@ -1655,11 +1681,13 @@ out:
static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
{
+ struct lo_data *lo = lo_data(req);
char *value = NULL;
char procname[64];
struct lo_inode *inode;
ssize_t ret;
int saverr;
+ int fd = -1;
inode = lo_inode(req, ino);
if (!inode) {
@@ -1683,7 +1711,11 @@ static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
goto out;
}
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(procname, "%i", inode->fd);
+ fd = openat(lo->proc_self_fd, procname, O_RDONLY);
+ if (fd < 0) {
+ goto out_err;
+ }
if (size) {
value = malloc(size);
@@ -1691,7 +1723,7 @@ static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
goto out_err;
}
- ret = listxattr(procname, value, size);
+ ret = flistxattr(fd, value, size);
if (ret == -1) {
goto out_err;
}
@@ -1702,7 +1734,7 @@ static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
fuse_reply_buf(req, value, ret);
} else {
- ret = listxattr(procname, NULL, 0);
+ ret = flistxattr(fd, NULL, 0);
if (ret == -1) {
goto out_err;
}
@@ -1711,6 +1743,10 @@ static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
}
out_free:
free(value);
+
+ if (fd >= 0) {
+ close(fd);
+ }
return;
out_err:
@@ -1724,9 +1760,11 @@ static void lo_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
const char *value, size_t size, int flags)
{
char procname[64];
+ struct lo_data *lo = lo_data(req);
struct lo_inode *inode;
ssize_t ret;
int saverr;
+ int fd = -1;
inode = lo_inode(req, ino);
if (!inode) {
@@ -1751,21 +1789,31 @@ static void lo_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
goto out;
}
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(procname, "%i", inode->fd);
+ fd = openat(lo->proc_self_fd, procname, O_RDWR);
+ if (fd < 0) {
+ saverr = errno;
+ goto out;
+ }
- ret = setxattr(procname, name, value, size, flags);
+ ret = fsetxattr(fd, name, value, size, flags);
saverr = ret == -1 ? errno : 0;
out:
+ if (fd >= 0) {
+ close(fd);
+ }
fuse_reply_err(req, saverr);
}
static void lo_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name)
{
char procname[64];
+ struct lo_data *lo = lo_data(req);
struct lo_inode *inode;
ssize_t ret;
int saverr;
+ int fd = -1;
inode = lo_inode(req, ino);
if (!inode) {
@@ -1789,12 +1837,20 @@ static void lo_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name)
goto out;
}
- sprintf(procname, "/proc/self/fd/%i", inode->fd);
+ sprintf(procname, "%i", inode->fd);
+ fd = openat(lo->proc_self_fd, procname, O_RDWR);
+ if (fd < 0) {
+ saverr = errno;
+ goto out;
+ }
- ret = removexattr(procname, name);
+ ret = fremovexattr(fd, name);
saverr = ret == -1 ? errno : 0;
out:
+ if (fd >= 0) {
+ close(fd);
+ }
fuse_reply_err(req, saverr);
}
@@ -1887,12 +1943,25 @@ static void print_capabilities(void)
printf("}\n");
}
+static void setup_proc_self_fd(struct lo_data *lo)
+{
+ lo->proc_self_fd = open("/proc/self/fd", O_PATH);
+ if (lo->proc_self_fd == -1) {
+ fuse_log(FUSE_LOG_ERR, "open(/proc/self/fd, O_PATH): %m\n");
+ exit(1);
+ }
+}
+
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct fuse_session *se;
struct fuse_cmdline_opts opts;
- struct lo_data lo = { .debug = 0, .writeback = 0 };
+ struct lo_data lo = {
+ .debug = 0,
+ .writeback = 0,
+ .proc_self_fd = -1,
+ };
struct lo_map_elem *root_elem;
int ret = -1;
@@ -2003,6 +2072,9 @@ int main(int argc, char *argv[])
fuse_daemonize(opts.foreground);
+ /* Must be after daemonize to get the right /proc/self/fd */
+ setup_proc_self_fd(&lo);
+
/* Block until ctrl+c or fusermount -u */
ret = virtio_loop(se);
@@ -2018,6 +2090,10 @@ err_out1:
lo_map_destroy(&lo.dirp_map);
lo_map_destroy(&lo.ino_map);
+ if (lo.proc_self_fd >= 0) {
+ close(lo.proc_self_fd);
+ }
+
if (lo.root.fd >= 0) {
close(lo.root.fd);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 049/108] virtiofsd: sandbox mount namespace
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (47 preceding siblings ...)
2020-01-23 16:45 ` [PULL 048/108] virtiofsd: use /proc/self/fd/ O_PATH file descriptor Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 050/108] virtiofsd: move to an empty network namespace Dr. David Alan Gilbert (git)
` (60 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Use a mount namespace with the shared directory tree mounted at "/" and
no other mounts.
This prevents symlink escape attacks because symlink targets are
resolved only against the shared directory and cannot go outside it.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Peng Tao <tao.peng@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 89 ++++++++++++++++++++++++++++++++
1 file changed, 89 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index e2e2211ea1..0570453eef 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -50,6 +50,7 @@
#include <stdlib.h>
#include <string.h>
#include <sys/file.h>
+#include <sys/mount.h>
#include <sys/syscall.h>
#include <sys/xattr.h>
#include <unistd.h>
@@ -1943,6 +1944,58 @@ static void print_capabilities(void)
printf("}\n");
}
+/* This magic is based on lxc's lxc_pivot_root() */
+static void setup_pivot_root(const char *source)
+{
+ int oldroot;
+ int newroot;
+
+ oldroot = open("/", O_DIRECTORY | O_RDONLY | O_CLOEXEC);
+ if (oldroot < 0) {
+ fuse_log(FUSE_LOG_ERR, "open(/): %m\n");
+ exit(1);
+ }
+
+ newroot = open(source, O_DIRECTORY | O_RDONLY | O_CLOEXEC);
+ if (newroot < 0) {
+ fuse_log(FUSE_LOG_ERR, "open(%s): %m\n", source);
+ exit(1);
+ }
+
+ if (fchdir(newroot) < 0) {
+ fuse_log(FUSE_LOG_ERR, "fchdir(newroot): %m\n");
+ exit(1);
+ }
+
+ if (syscall(__NR_pivot_root, ".", ".") < 0) {
+ fuse_log(FUSE_LOG_ERR, "pivot_root(., .): %m\n");
+ exit(1);
+ }
+
+ if (fchdir(oldroot) < 0) {
+ fuse_log(FUSE_LOG_ERR, "fchdir(oldroot): %m\n");
+ exit(1);
+ }
+
+ if (mount("", ".", "", MS_SLAVE | MS_REC, NULL) < 0) {
+ fuse_log(FUSE_LOG_ERR, "mount(., MS_SLAVE | MS_REC): %m\n");
+ exit(1);
+ }
+
+ if (umount2(".", MNT_DETACH) < 0) {
+ fuse_log(FUSE_LOG_ERR, "umount2(., MNT_DETACH): %m\n");
+ exit(1);
+ }
+
+ if (fchdir(newroot) < 0) {
+ fuse_log(FUSE_LOG_ERR, "fchdir(newroot): %m\n");
+ exit(1);
+ }
+
+ close(newroot);
+ close(oldroot);
+}
+
static void setup_proc_self_fd(struct lo_data *lo)
{
lo->proc_self_fd = open("/proc/self/fd", O_PATH);
@@ -1952,6 +2005,39 @@ static void setup_proc_self_fd(struct lo_data *lo)
}
}
+/*
+ * Make the source directory our root so symlinks cannot escape and no other
+ * files are accessible.
+ */
+static void setup_mount_namespace(const char *source)
+{
+ if (unshare(CLONE_NEWNS) != 0) {
+ fuse_log(FUSE_LOG_ERR, "unshare(CLONE_NEWNS): %m\n");
+ exit(1);
+ }
+
+ if (mount(NULL, "/", NULL, MS_REC | MS_SLAVE, NULL) < 0) {
+ fuse_log(FUSE_LOG_ERR, "mount(/, MS_REC|MS_PRIVATE): %m\n");
+ exit(1);
+ }
+
+ if (mount(source, source, NULL, MS_BIND, NULL) < 0) {
+ fuse_log(FUSE_LOG_ERR, "mount(%s, %s, MS_BIND): %m\n", source, source);
+ exit(1);
+ }
+
+ setup_pivot_root(source);
+}
+
+/*
+ * Lock down this process to prevent access to other processes or files outside
+ * source directory. This reduces the impact of arbitrary code execution bugs.
+ */
+static void setup_sandbox(struct lo_data *lo)
+{
+ setup_mount_namespace(lo->source);
+}
+
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
@@ -2052,6 +2138,7 @@ int main(int argc, char *argv[])
}
lo.root.fd = open(lo.source, O_PATH);
+
if (lo.root.fd == -1) {
fuse_log(FUSE_LOG_ERR, "open(\"%s\", O_PATH): %m\n", lo.source);
exit(1);
@@ -2075,6 +2162,8 @@ int main(int argc, char *argv[])
/* Must be after daemonize to get the right /proc/self/fd */
setup_proc_self_fd(&lo);
+ setup_sandbox(&lo);
+
/* Block until ctrl+c or fusermount -u */
ret = virtio_loop(se);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 050/108] virtiofsd: move to an empty network namespace
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (48 preceding siblings ...)
2020-01-23 16:45 ` [PULL 049/108] virtiofsd: sandbox mount namespace Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 051/108] virtiofsd: move to a new pid namespace Dr. David Alan Gilbert (git)
` (59 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
If the process is compromised there should be no network access. Use an
empty network namespace to sandbox networking.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 0570453eef..27ab328722 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1944,6 +1944,19 @@ static void print_capabilities(void)
printf("}\n");
}
+/*
+ * Called after our UNIX domain sockets have been created, now we can move to
+ * an empty network namespace to prevent TCP/IP and other network activity in
+ * case this process is compromised.
+ */
+static void setup_net_namespace(void)
+{
+ if (unshare(CLONE_NEWNET) != 0) {
+ fuse_log(FUSE_LOG_ERR, "unshare(CLONE_NEWNET): %m\n");
+ exit(1);
+ }
+}
+
/* This magic is based on lxc's lxc_pivot_root() */
static void setup_pivot_root(const char *source)
{
@@ -2035,6 +2048,7 @@ static void setup_mount_namespace(const char *source)
*/
static void setup_sandbox(struct lo_data *lo)
{
+ setup_net_namespace();
setup_mount_namespace(lo->source);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 051/108] virtiofsd: move to a new pid namespace
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (49 preceding siblings ...)
2020-01-23 16:45 ` [PULL 050/108] virtiofsd: move to an empty network namespace Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 052/108] virtiofsd: add seccomp whitelist Dr. David Alan Gilbert (git)
` (58 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
virtiofsd needs access to /proc/self/fd. Let's move to a new pid
namespace so that a compromised process cannot see another other
processes running on the system.
One wrinkle in this approach: unshare(CLONE_NEWPID) affects *child*
processes and not the current process. Therefore we need to fork the
pid 1 process that will actually run virtiofsd and leave a parent in
waitpid(2). This is not the same thing as daemonization and parent
processes should not notice a difference.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 134 ++++++++++++++++++++-----------
1 file changed, 86 insertions(+), 48 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 27ab328722..0947d14e5b 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -51,7 +51,10 @@
#include <string.h>
#include <sys/file.h>
#include <sys/mount.h>
+#include <sys/prctl.h>
#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
@@ -1945,24 +1948,95 @@ static void print_capabilities(void)
}
/*
- * Called after our UNIX domain sockets have been created, now we can move to
- * an empty network namespace to prevent TCP/IP and other network activity in
- * case this process is compromised.
+ * Move to a new mount, net, and pid namespaces to isolate this process.
*/
-static void setup_net_namespace(void)
+static void setup_namespaces(struct lo_data *lo, struct fuse_session *se)
{
- if (unshare(CLONE_NEWNET) != 0) {
- fuse_log(FUSE_LOG_ERR, "unshare(CLONE_NEWNET): %m\n");
+ pid_t child;
+
+ /*
+ * Create a new pid namespace for *child* processes. We'll have to
+ * fork in order to enter the new pid namespace. A new mount namespace
+ * is also needed so that we can remount /proc for the new pid
+ * namespace.
+ *
+ * Our UNIX domain sockets have been created. Now we can move to
+ * an empty network namespace to prevent TCP/IP and other network
+ * activity in case this process is compromised.
+ */
+ if (unshare(CLONE_NEWPID | CLONE_NEWNS | CLONE_NEWNET) != 0) {
+ fuse_log(FUSE_LOG_ERR, "unshare(CLONE_NEWPID | CLONE_NEWNS): %m\n");
+ exit(1);
+ }
+
+ child = fork();
+ if (child < 0) {
+ fuse_log(FUSE_LOG_ERR, "fork() failed: %m\n");
+ exit(1);
+ }
+ if (child > 0) {
+ pid_t waited;
+ int wstatus;
+
+ /* The parent waits for the child */
+ do {
+ waited = waitpid(child, &wstatus, 0);
+ } while (waited < 0 && errno == EINTR && !se->exited);
+
+ /* We were terminated by a signal, see fuse_signals.c */
+ if (se->exited) {
+ exit(0);
+ }
+
+ if (WIFEXITED(wstatus)) {
+ exit(WEXITSTATUS(wstatus));
+ }
+
+ exit(1);
+ }
+
+ /* Send us SIGTERM when the parent thread terminates, see prctl(2) */
+ prctl(PR_SET_PDEATHSIG, SIGTERM);
+
+ /*
+ * If the mounts have shared propagation then we want to opt out so our
+ * mount changes don't affect the parent mount namespace.
+ */
+ if (mount(NULL, "/", NULL, MS_REC | MS_SLAVE, NULL) < 0) {
+ fuse_log(FUSE_LOG_ERR, "mount(/, MS_REC|MS_SLAVE): %m\n");
+ exit(1);
+ }
+
+ /* The child must remount /proc to use the new pid namespace */
+ if (mount("proc", "/proc", "proc",
+ MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_RELATIME, NULL) < 0) {
+ fuse_log(FUSE_LOG_ERR, "mount(/proc): %m\n");
+ exit(1);
+ }
+
+ /* Now we can get our /proc/self/fd directory file descriptor */
+ lo->proc_self_fd = open("/proc/self/fd", O_PATH);
+ if (lo->proc_self_fd == -1) {
+ fuse_log(FUSE_LOG_ERR, "open(/proc/self/fd, O_PATH): %m\n");
exit(1);
}
}
-/* This magic is based on lxc's lxc_pivot_root() */
-static void setup_pivot_root(const char *source)
+/*
+ * Make the source directory our root so symlinks cannot escape and no other
+ * files are accessible. Assumes unshare(CLONE_NEWNS) was already called.
+ */
+static void setup_mounts(const char *source)
{
int oldroot;
int newroot;
+ if (mount(source, source, NULL, MS_BIND, NULL) < 0) {
+ fuse_log(FUSE_LOG_ERR, "mount(%s, %s, MS_BIND): %m\n", source, source);
+ exit(1);
+ }
+
+ /* This magic is based on lxc's lxc_pivot_root() */
oldroot = open("/", O_DIRECTORY | O_RDONLY | O_CLOEXEC);
if (oldroot < 0) {
fuse_log(FUSE_LOG_ERR, "open(/): %m\n");
@@ -2009,47 +2083,14 @@ static void setup_pivot_root(const char *source)
close(oldroot);
}
-static void setup_proc_self_fd(struct lo_data *lo)
-{
- lo->proc_self_fd = open("/proc/self/fd", O_PATH);
- if (lo->proc_self_fd == -1) {
- fuse_log(FUSE_LOG_ERR, "open(/proc/self/fd, O_PATH): %m\n");
- exit(1);
- }
-}
-
-/*
- * Make the source directory our root so symlinks cannot escape and no other
- * files are accessible.
- */
-static void setup_mount_namespace(const char *source)
-{
- if (unshare(CLONE_NEWNS) != 0) {
- fuse_log(FUSE_LOG_ERR, "unshare(CLONE_NEWNS): %m\n");
- exit(1);
- }
-
- if (mount(NULL, "/", NULL, MS_REC | MS_SLAVE, NULL) < 0) {
- fuse_log(FUSE_LOG_ERR, "mount(/, MS_REC|MS_PRIVATE): %m\n");
- exit(1);
- }
-
- if (mount(source, source, NULL, MS_BIND, NULL) < 0) {
- fuse_log(FUSE_LOG_ERR, "mount(%s, %s, MS_BIND): %m\n", source, source);
- exit(1);
- }
-
- setup_pivot_root(source);
-}
-
/*
* Lock down this process to prevent access to other processes or files outside
* source directory. This reduces the impact of arbitrary code execution bugs.
*/
-static void setup_sandbox(struct lo_data *lo)
+static void setup_sandbox(struct lo_data *lo, struct fuse_session *se)
{
- setup_net_namespace();
- setup_mount_namespace(lo->source);
+ setup_namespaces(lo, se);
+ setup_mounts(lo->source);
}
int main(int argc, char *argv[])
@@ -2173,10 +2214,7 @@ int main(int argc, char *argv[])
fuse_daemonize(opts.foreground);
- /* Must be after daemonize to get the right /proc/self/fd */
- setup_proc_self_fd(&lo);
-
- setup_sandbox(&lo);
+ setup_sandbox(&lo, se);
/* Block until ctrl+c or fusermount -u */
ret = virtio_loop(se);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 052/108] virtiofsd: add seccomp whitelist
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (50 preceding siblings ...)
2020-01-23 16:45 ` [PULL 051/108] virtiofsd: move to a new pid namespace Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 053/108] virtiofsd: Parse flag FUSE_WRITE_KILL_PRIV Dr. David Alan Gilbert (git)
` (57 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Only allow system calls that are needed by virtiofsd. All other system
calls cause SIGSYS to be directed at the thread and the process will
coredump.
Restricting system calls reduces the kernel attack surface and limits
what the process can do when compromised.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
with additional entries by:
Signed-off-by: Ganesh Maharaj Mahalingam <ganesh.mahalingam@intel.com>
Signed-off-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: piaojun <piaojun@huawei.com>
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Eric Ren <renzhen@linux.alibaba.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
Makefile | 5 +-
tools/virtiofsd/Makefile.objs | 5 +-
tools/virtiofsd/passthrough_ll.c | 2 +
tools/virtiofsd/seccomp.c | 151 +++++++++++++++++++++++++++++++
tools/virtiofsd/seccomp.h | 14 +++
5 files changed, 174 insertions(+), 3 deletions(-)
create mode 100644 tools/virtiofsd/seccomp.c
create mode 100644 tools/virtiofsd/seccomp.h
diff --git a/Makefile b/Makefile
index 2f81271ee7..ad400f36b2 100644
--- a/Makefile
+++ b/Makefile
@@ -327,7 +327,7 @@ HELPERS-y += vhost-user-gpu$(EXESUF)
vhost-user-json-y += contrib/vhost-user-gpu/50-qemu-gpu.json
endif
-ifdef CONFIG_LINUX
+ifeq ($(CONFIG_LINUX)$(CONFIG_SECCOMP),yy)
HELPERS-y += virtiofsd$(EXESUF)
vhost-user-json-y += tools/virtiofsd/50-qemu-virtiofsd.json
endif
@@ -674,7 +674,8 @@ rdmacm-mux$(EXESUF): LIBS += "-libumad"
rdmacm-mux$(EXESUF): $(rdmacm-mux-obj-y) $(COMMON_LDADDS)
$(call LINK, $^)
-ifdef CONFIG_LINUX # relies on Linux-specific syscalls
+# relies on Linux-specific syscalls
+ifeq ($(CONFIG_LINUX)$(CONFIG_SECCOMP),yy)
virtiofsd$(EXESUF): $(virtiofsd-obj-y) libvhost-user.a $(COMMON_LDADDS)
$(call LINK, $^)
endif
diff --git a/tools/virtiofsd/Makefile.objs b/tools/virtiofsd/Makefile.objs
index 45a807500d..076f667e46 100644
--- a/tools/virtiofsd/Makefile.objs
+++ b/tools/virtiofsd/Makefile.objs
@@ -5,5 +5,8 @@ virtiofsd-obj-y = buffer.o \
fuse_signals.o \
fuse_virtio.o \
helper.o \
- passthrough_ll.o
+ passthrough_ll.o \
+ seccomp.o
+seccomp.o-cflags := $(SECCOMP_CFLAGS)
+seccomp.o-libs := $(SECCOMP_LIBS)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 0947d14e5b..bd8925bd83 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -59,6 +59,7 @@
#include <unistd.h>
#include "passthrough_helpers.h"
+#include "seccomp.h"
struct lo_map_elem {
union {
@@ -2091,6 +2092,7 @@ static void setup_sandbox(struct lo_data *lo, struct fuse_session *se)
{
setup_namespaces(lo, se);
setup_mounts(lo->source);
+ setup_seccomp();
}
int main(int argc, char *argv[])
diff --git a/tools/virtiofsd/seccomp.c b/tools/virtiofsd/seccomp.c
new file mode 100644
index 0000000000..691fb63dea
--- /dev/null
+++ b/tools/virtiofsd/seccomp.c
@@ -0,0 +1,151 @@
+/*
+ * Seccomp sandboxing for virtiofsd
+ *
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "qemu/osdep.h"
+#include "seccomp.h"
+#include "fuse_i.h"
+#include "fuse_log.h"
+#include <errno.h>
+#include <glib.h>
+#include <seccomp.h>
+#include <stdlib.h>
+
+/* Bodge for libseccomp 2.4.2 which broke ppoll */
+#if !defined(__SNR_ppoll) && defined(__SNR_brk)
+#ifdef __NR_ppoll
+#define __SNR_ppoll __NR_ppoll
+#else
+#define __SNR_ppoll __PNR_ppoll
+#endif
+#endif
+
+static const int syscall_whitelist[] = {
+ /* TODO ireg sem*() syscalls */
+ SCMP_SYS(brk),
+ SCMP_SYS(capget), /* For CAP_FSETID */
+ SCMP_SYS(capset),
+ SCMP_SYS(clock_gettime),
+ SCMP_SYS(clone),
+#ifdef __NR_clone3
+ SCMP_SYS(clone3),
+#endif
+ SCMP_SYS(close),
+ SCMP_SYS(copy_file_range),
+ SCMP_SYS(dup),
+ SCMP_SYS(eventfd2),
+ SCMP_SYS(exit),
+ SCMP_SYS(exit_group),
+ SCMP_SYS(fallocate),
+ SCMP_SYS(fchmodat),
+ SCMP_SYS(fchownat),
+ SCMP_SYS(fcntl),
+ SCMP_SYS(fdatasync),
+ SCMP_SYS(fgetxattr),
+ SCMP_SYS(flistxattr),
+ SCMP_SYS(flock),
+ SCMP_SYS(fremovexattr),
+ SCMP_SYS(fsetxattr),
+ SCMP_SYS(fstat),
+ SCMP_SYS(fstatfs),
+ SCMP_SYS(fsync),
+ SCMP_SYS(ftruncate),
+ SCMP_SYS(futex),
+ SCMP_SYS(getdents),
+ SCMP_SYS(getdents64),
+ SCMP_SYS(getegid),
+ SCMP_SYS(geteuid),
+ SCMP_SYS(getpid),
+ SCMP_SYS(gettid),
+ SCMP_SYS(gettimeofday),
+ SCMP_SYS(linkat),
+ SCMP_SYS(lseek),
+ SCMP_SYS(madvise),
+ SCMP_SYS(mkdirat),
+ SCMP_SYS(mknodat),
+ SCMP_SYS(mmap),
+ SCMP_SYS(mprotect),
+ SCMP_SYS(mremap),
+ SCMP_SYS(munmap),
+ SCMP_SYS(newfstatat),
+ SCMP_SYS(open),
+ SCMP_SYS(openat),
+ SCMP_SYS(ppoll),
+ SCMP_SYS(prctl), /* TODO restrict to just PR_SET_NAME? */
+ SCMP_SYS(preadv),
+ SCMP_SYS(pread64),
+ SCMP_SYS(pwritev),
+ SCMP_SYS(pwrite64),
+ SCMP_SYS(read),
+ SCMP_SYS(readlinkat),
+ SCMP_SYS(recvmsg),
+ SCMP_SYS(renameat),
+ SCMP_SYS(renameat2),
+ SCMP_SYS(rt_sigaction),
+ SCMP_SYS(rt_sigprocmask),
+ SCMP_SYS(rt_sigreturn),
+ SCMP_SYS(sendmsg),
+ SCMP_SYS(setresgid),
+ SCMP_SYS(setresuid),
+#ifdef __NR_setresgid32
+ SCMP_SYS(setresgid32),
+#endif
+#ifdef __NR_setresuid32
+ SCMP_SYS(setresuid32),
+#endif
+ SCMP_SYS(set_robust_list),
+ SCMP_SYS(symlinkat),
+ SCMP_SYS(time), /* Rarely needed, except on static builds */
+ SCMP_SYS(tgkill),
+ SCMP_SYS(unlinkat),
+ SCMP_SYS(utimensat),
+ SCMP_SYS(write),
+ SCMP_SYS(writev),
+};
+
+void setup_seccomp(void)
+{
+ scmp_filter_ctx ctx;
+ size_t i;
+
+#ifdef SCMP_ACT_KILL_PROCESS
+ ctx = seccomp_init(SCMP_ACT_KILL_PROCESS);
+ /* Handle a newer libseccomp but an older kernel */
+ if (!ctx && errno == EOPNOTSUPP) {
+ ctx = seccomp_init(SCMP_ACT_TRAP);
+ }
+#else
+ ctx = seccomp_init(SCMP_ACT_TRAP);
+#endif
+ if (!ctx) {
+ fuse_log(FUSE_LOG_ERR, "seccomp_init() failed\n");
+ exit(1);
+ }
+
+ for (i = 0; i < G_N_ELEMENTS(syscall_whitelist); i++) {
+ if (seccomp_rule_add(ctx, SCMP_ACT_ALLOW,
+ syscall_whitelist[i], 0) != 0) {
+ fuse_log(FUSE_LOG_ERR, "seccomp_rule_add syscall %d",
+ syscall_whitelist[i]);
+ exit(1);
+ }
+ }
+
+ /* libvhost-user calls this for post-copy migration, we don't need it */
+ if (seccomp_rule_add(ctx, SCMP_ACT_ERRNO(ENOSYS),
+ SCMP_SYS(userfaultfd), 0) != 0) {
+ fuse_log(FUSE_LOG_ERR, "seccomp_rule_add userfaultfd failed\n");
+ exit(1);
+ }
+
+ if (seccomp_load(ctx) < 0) {
+ fuse_log(FUSE_LOG_ERR, "seccomp_load() failed\n");
+ exit(1);
+ }
+
+ seccomp_release(ctx);
+}
diff --git a/tools/virtiofsd/seccomp.h b/tools/virtiofsd/seccomp.h
new file mode 100644
index 0000000000..86bce72652
--- /dev/null
+++ b/tools/virtiofsd/seccomp.h
@@ -0,0 +1,14 @@
+/*
+ * Seccomp sandboxing for virtiofsd
+ *
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef VIRTIOFSD_SECCOMP_H
+#define VIRTIOFSD_SECCOMP_H
+
+void setup_seccomp(void);
+
+#endif /* VIRTIOFSD_SECCOMP_H */
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 053/108] virtiofsd: Parse flag FUSE_WRITE_KILL_PRIV
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (51 preceding siblings ...)
2020-01-23 16:45 ` [PULL 052/108] virtiofsd: add seccomp whitelist Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 054/108] virtiofsd: cap-ng helpers Dr. David Alan Gilbert (git)
` (56 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Vivek Goyal <vgoyal@redhat.com>
Caller can set FUSE_WRITE_KILL_PRIV in write_flags. Parse it and pass it
to the filesystem.
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: Sergio Lopez <slp@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_common.h | 6 +++++-
tools/virtiofsd/fuse_lowlevel.c | 4 +++-
2 files changed, 8 insertions(+), 2 deletions(-)
diff --git a/tools/virtiofsd/fuse_common.h b/tools/virtiofsd/fuse_common.h
index f8f6433743..686c42c0a5 100644
--- a/tools/virtiofsd/fuse_common.h
+++ b/tools/virtiofsd/fuse_common.h
@@ -93,8 +93,12 @@ struct fuse_file_info {
*/
unsigned int cache_readdir:1;
+ /* Indicates that suid/sgid bits should be removed upon write */
+ unsigned int kill_priv:1;
+
+
/** Padding. Reserved for future use*/
- unsigned int padding:25;
+ unsigned int padding:24;
unsigned int padding2:32;
/*
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 02e1d83038..2d6dc5a680 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -1142,6 +1142,7 @@ static void do_write(fuse_req_t req, fuse_ino_t nodeid,
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
fi.writepage = (arg->write_flags & FUSE_WRITE_CACHE) != 0;
+ fi.kill_priv = !!(arg->write_flags & FUSE_WRITE_KILL_PRIV);
fi.lock_owner = arg->lock_owner;
fi.flags = arg->flags;
@@ -1177,7 +1178,8 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid,
fi.lock_owner = arg->lock_owner;
fi.flags = arg->flags;
fi.fh = arg->fh;
- fi.writepage = arg->write_flags & FUSE_WRITE_CACHE;
+ fi.writepage = !!(arg->write_flags & FUSE_WRITE_CACHE);
+ fi.kill_priv = !!(arg->write_flags & FUSE_WRITE_KILL_PRIV);
if (ibufv->count == 1) {
assert(!(tmpbufv.buf[0].flags & FUSE_BUF_IS_FD));
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 054/108] virtiofsd: cap-ng helpers
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (52 preceding siblings ...)
2020-01-23 16:45 ` [PULL 053/108] virtiofsd: Parse flag FUSE_WRITE_KILL_PRIV Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 055/108] virtiofsd: Drop CAP_FSETID if client asked for it Dr. David Alan Gilbert (git)
` (55 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
libcap-ng reads /proc during capng_get_caps_process, and virtiofsd's
sandboxing doesn't have /proc mounted; thus we have to do the
caps read before we sandbox it and save/restore the state.
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>
---
Makefile | 4 +-
tools/virtiofsd/passthrough_ll.c | 72 ++++++++++++++++++++++++++++++++
2 files changed, 74 insertions(+), 2 deletions(-)
diff --git a/Makefile b/Makefile
index ad400f36b2..6b4b075a92 100644
--- a/Makefile
+++ b/Makefile
@@ -327,7 +327,7 @@ HELPERS-y += vhost-user-gpu$(EXESUF)
vhost-user-json-y += contrib/vhost-user-gpu/50-qemu-gpu.json
endif
-ifeq ($(CONFIG_LINUX)$(CONFIG_SECCOMP),yy)
+ifeq ($(CONFIG_LINUX)$(CONFIG_SECCOMP)$(CONFIG_LIBCAP_NG),yyy)
HELPERS-y += virtiofsd$(EXESUF)
vhost-user-json-y += tools/virtiofsd/50-qemu-virtiofsd.json
endif
@@ -675,7 +675,7 @@ rdmacm-mux$(EXESUF): $(rdmacm-mux-obj-y) $(COMMON_LDADDS)
$(call LINK, $^)
# relies on Linux-specific syscalls
-ifeq ($(CONFIG_LINUX)$(CONFIG_SECCOMP),yy)
+ifeq ($(CONFIG_LINUX)$(CONFIG_SECCOMP)$(CONFIG_LIBCAP_NG),yyy)
virtiofsd$(EXESUF): $(virtiofsd-obj-y) libvhost-user.a $(COMMON_LDADDS)
$(call LINK, $^)
endif
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index bd8925bd83..97e7c75667 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -39,6 +39,7 @@
#include "fuse_virtio.h"
#include "fuse_lowlevel.h"
#include <assert.h>
+#include <cap-ng.h>
#include <dirent.h>
#include <errno.h>
#include <inttypes.h>
@@ -139,6 +140,13 @@ static const struct fuse_opt lo_opts[] = {
static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n);
+static struct {
+ pthread_mutex_t mutex;
+ void *saved;
+} cap;
+/* That we loaded cap-ng in the current thread from the saved */
+static __thread bool cap_loaded = 0;
+
static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st);
static int is_dot_or_dotdot(const char *name)
@@ -162,6 +170,37 @@ static struct lo_data *lo_data(fuse_req_t req)
return (struct lo_data *)fuse_req_userdata(req);
}
+/*
+ * Load capng's state from our saved state if the current thread
+ * hadn't previously been loaded.
+ * returns 0 on success
+ */
+static int load_capng(void)
+{
+ if (!cap_loaded) {
+ pthread_mutex_lock(&cap.mutex);
+ capng_restore_state(&cap.saved);
+ /*
+ * restore_state free's the saved copy
+ * so make another.
+ */
+ cap.saved = capng_save_state();
+ if (!cap.saved) {
+ fuse_log(FUSE_LOG_ERR, "capng_save_state (thread)\n");
+ return -EINVAL;
+ }
+ pthread_mutex_unlock(&cap.mutex);
+
+ /*
+ * We want to use the loaded state for our pid,
+ * not the original
+ */
+ capng_setpid(syscall(SYS_gettid));
+ cap_loaded = true;
+ }
+ return 0;
+}
+
static void lo_map_init(struct lo_map *map)
{
map->elems = NULL;
@@ -2023,6 +2062,35 @@ static void setup_namespaces(struct lo_data *lo, struct fuse_session *se)
}
}
+/*
+ * Capture the capability state, we'll need to restore this for individual
+ * threads later; see load_capng.
+ */
+static void setup_capng(void)
+{
+ /* Note this accesses /proc so has to happen before the sandbox */
+ if (capng_get_caps_process()) {
+ fuse_log(FUSE_LOG_ERR, "capng_get_caps_process\n");
+ exit(1);
+ }
+ pthread_mutex_init(&cap.mutex, NULL);
+ pthread_mutex_lock(&cap.mutex);
+ cap.saved = capng_save_state();
+ if (!cap.saved) {
+ fuse_log(FUSE_LOG_ERR, "capng_save_state\n");
+ exit(1);
+ }
+ pthread_mutex_unlock(&cap.mutex);
+}
+
+static void cleanup_capng(void)
+{
+ free(cap.saved);
+ cap.saved = NULL;
+ pthread_mutex_destroy(&cap.mutex);
+}
+
+
/*
* Make the source directory our root so symlinks cannot escape and no other
* files are accessible. Assumes unshare(CLONE_NEWNS) was already called.
@@ -2216,12 +2284,16 @@ int main(int argc, char *argv[])
fuse_daemonize(opts.foreground);
+ /* Must be before sandbox since it wants /proc */
+ setup_capng();
+
setup_sandbox(&lo, se);
/* Block until ctrl+c or fusermount -u */
ret = virtio_loop(se);
fuse_session_unmount(se);
+ cleanup_capng();
err_out3:
fuse_remove_signal_handlers(se);
err_out2:
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 055/108] virtiofsd: Drop CAP_FSETID if client asked for it
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (53 preceding siblings ...)
2020-01-23 16:45 ` [PULL 054/108] virtiofsd: cap-ng helpers Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 056/108] virtiofsd: set maximum RLIMIT_NOFILE limit Dr. David Alan Gilbert (git)
` (54 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Vivek Goyal <vgoyal@redhat.com>
If client requested killing setuid/setgid bits on file being written, drop
CAP_FSETID capability so that setuid/setgid bits are cleared upon write
automatically.
pjdfstest chown/12.t needs this.
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
dgilbert: reworked for libcap-ng
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: Sergio Lopez <slp@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 105 +++++++++++++++++++++++++++++++
1 file changed, 105 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 97e7c75667..d53cb1e005 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -201,6 +201,91 @@ static int load_capng(void)
return 0;
}
+/*
+ * Helpers for dropping and regaining effective capabilities. Returns 0
+ * on success, error otherwise
+ */
+static int drop_effective_cap(const char *cap_name, bool *cap_dropped)
+{
+ int cap, ret;
+
+ cap = capng_name_to_capability(cap_name);
+ if (cap < 0) {
+ ret = errno;
+ fuse_log(FUSE_LOG_ERR, "capng_name_to_capability(%s) failed:%s\n",
+ cap_name, strerror(errno));
+ goto out;
+ }
+
+ if (load_capng()) {
+ ret = errno;
+ fuse_log(FUSE_LOG_ERR, "load_capng() failed\n");
+ goto out;
+ }
+
+ /* We dont have this capability in effective set already. */
+ if (!capng_have_capability(CAPNG_EFFECTIVE, cap)) {
+ ret = 0;
+ goto out;
+ }
+
+ if (capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, cap)) {
+ ret = errno;
+ fuse_log(FUSE_LOG_ERR, "capng_update(DROP,) failed\n");
+ goto out;
+ }
+
+ if (capng_apply(CAPNG_SELECT_CAPS)) {
+ ret = errno;
+ fuse_log(FUSE_LOG_ERR, "drop:capng_apply() failed\n");
+ goto out;
+ }
+
+ ret = 0;
+ if (cap_dropped) {
+ *cap_dropped = true;
+ }
+
+out:
+ return ret;
+}
+
+static int gain_effective_cap(const char *cap_name)
+{
+ int cap;
+ int ret = 0;
+
+ cap = capng_name_to_capability(cap_name);
+ if (cap < 0) {
+ ret = errno;
+ fuse_log(FUSE_LOG_ERR, "capng_name_to_capability(%s) failed:%s\n",
+ cap_name, strerror(errno));
+ goto out;
+ }
+
+ if (load_capng()) {
+ ret = errno;
+ fuse_log(FUSE_LOG_ERR, "load_capng() failed\n");
+ goto out;
+ }
+
+ if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, cap)) {
+ ret = errno;
+ fuse_log(FUSE_LOG_ERR, "capng_update(ADD,) failed\n");
+ goto out;
+ }
+
+ if (capng_apply(CAPNG_SELECT_CAPS)) {
+ ret = errno;
+ fuse_log(FUSE_LOG_ERR, "gain:capng_apply() failed\n");
+ goto out;
+ }
+ ret = 0;
+
+out:
+ return ret;
+}
+
static void lo_map_init(struct lo_map *map)
{
map->elems = NULL;
@@ -1577,6 +1662,7 @@ static void lo_write_buf(fuse_req_t req, fuse_ino_t ino,
(void)ino;
ssize_t res;
struct fuse_bufvec out_buf = FUSE_BUFVEC_INIT(fuse_buf_size(in_buf));
+ bool cap_fsetid_dropped = false;
out_buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
out_buf.buf[0].fd = lo_fi_fd(req, fi);
@@ -1588,12 +1674,31 @@ static void lo_write_buf(fuse_req_t req, fuse_ino_t ino,
out_buf.buf[0].size, (unsigned long)off);
}
+ /*
+ * If kill_priv is set, drop CAP_FSETID which should lead to kernel
+ * clearing setuid/setgid on file.
+ */
+ if (fi->kill_priv) {
+ res = drop_effective_cap("FSETID", &cap_fsetid_dropped);
+ if (res != 0) {
+ fuse_reply_err(req, res);
+ return;
+ }
+ }
+
res = fuse_buf_copy(&out_buf, in_buf);
if (res < 0) {
fuse_reply_err(req, -res);
} else {
fuse_reply_write(req, (size_t)res);
}
+
+ if (cap_fsetid_dropped) {
+ res = gain_effective_cap("FSETID");
+ if (res) {
+ fuse_log(FUSE_LOG_ERR, "Failed to gain CAP_FSETID\n");
+ }
+ }
}
static void lo_statfs(fuse_req_t req, fuse_ino_t ino)
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 056/108] virtiofsd: set maximum RLIMIT_NOFILE limit
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (54 preceding siblings ...)
2020-01-23 16:45 ` [PULL 055/108] virtiofsd: Drop CAP_FSETID if client asked for it Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 057/108] virtiofsd: fix libfuse information leaks Dr. David Alan Gilbert (git)
` (53 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
virtiofsd can exceed the default open file descriptor limit easily on
most systems. Take advantage of the fact that it runs as root to raise
the limit.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 32 ++++++++++++++++++++++++++++++++
1 file changed, 32 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index d53cb1e005..c281d817af 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -53,6 +53,7 @@
#include <sys/file.h>
#include <sys/mount.h>
#include <sys/prctl.h>
+#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
@@ -2268,6 +2269,35 @@ static void setup_sandbox(struct lo_data *lo, struct fuse_session *se)
setup_seccomp();
}
+/* Raise the maximum number of open file descriptors */
+static void setup_nofile_rlimit(void)
+{
+ const rlim_t max_fds = 1000000;
+ struct rlimit rlim;
+
+ if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
+ fuse_log(FUSE_LOG_ERR, "getrlimit(RLIMIT_NOFILE): %m\n");
+ exit(1);
+ }
+
+ if (rlim.rlim_cur >= max_fds) {
+ return; /* nothing to do */
+ }
+
+ rlim.rlim_cur = max_fds;
+ rlim.rlim_max = max_fds;
+
+ if (setrlimit(RLIMIT_NOFILE, &rlim) < 0) {
+ /* Ignore SELinux denials */
+ if (errno == EPERM) {
+ return;
+ }
+
+ fuse_log(FUSE_LOG_ERR, "setrlimit(RLIMIT_NOFILE): %m\n");
+ exit(1);
+ }
+}
+
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
@@ -2389,6 +2419,8 @@ int main(int argc, char *argv[])
fuse_daemonize(opts.foreground);
+ setup_nofile_rlimit();
+
/* Must be before sandbox since it wants /proc */
setup_capng();
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 057/108] virtiofsd: fix libfuse information leaks
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (55 preceding siblings ...)
2020-01-23 16:45 ` [PULL 056/108] virtiofsd: set maximum RLIMIT_NOFILE limit Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 058/108] virtiofsd: add --syslog command-line option Dr. David Alan Gilbert (git)
` (52 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Some FUSE message replies contain padding fields that are not
initialized by libfuse. This is fine in traditional FUSE applications
because the kernel is trusted. virtiofsd does not trust the guest and
must not expose uninitialized memory.
Use C struct initializers to automatically zero out memory. Not all of
these code changes are strictly necessary but they will prevent future
information leaks if the structs are extended.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 150 ++++++++++++++++----------------
1 file changed, 76 insertions(+), 74 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 2d6dc5a680..6ceb33d913 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -44,21 +44,23 @@ static __attribute__((constructor)) void fuse_ll_init_pagesize(void)
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);
+ *attr = (struct fuse_attr){
+ .ino = stbuf->st_ino,
+ .mode = stbuf->st_mode,
+ .nlink = stbuf->st_nlink,
+ .uid = stbuf->st_uid,
+ .gid = stbuf->st_gid,
+ .rdev = stbuf->st_rdev,
+ .size = stbuf->st_size,
+ .blksize = stbuf->st_blksize,
+ .blocks = stbuf->st_blocks,
+ .atime = stbuf->st_atime,
+ .mtime = stbuf->st_mtime,
+ .ctime = stbuf->st_ctime,
+ .atimensec = ST_ATIM_NSEC(stbuf),
+ .mtimensec = ST_MTIM_NSEC(stbuf),
+ .ctimensec = ST_CTIM_NSEC(stbuf),
+ };
}
static void convert_attr(const struct fuse_setattr_in *attr, struct stat *stbuf)
@@ -183,16 +185,16 @@ static int fuse_send_msg(struct fuse_session *se, struct fuse_chan *ch,
int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
int count)
{
- struct fuse_out_header out;
+ struct fuse_out_header out = {
+ .unique = req->unique,
+ .error = error,
+ };
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);
@@ -277,14 +279,16 @@ size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,
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;
+ *kstatfs = (struct fuse_kstatfs){
+ .bsize = stbuf->f_bsize,
+ .frsize = stbuf->f_frsize,
+ .blocks = stbuf->f_blocks,
+ .bfree = stbuf->f_bfree,
+ .bavail = stbuf->f_bavail,
+ .files = stbuf->f_files,
+ .ffree = stbuf->f_ffree,
+ .namelen = stbuf->f_namemax,
+ };
}
static int send_reply_ok(fuse_req_t req, const void *arg, size_t argsize)
@@ -328,12 +332,14 @@ static unsigned int calc_timeout_nsec(double t)
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);
+ *arg = (struct fuse_entry_out){
+ .nodeid = e->ino,
+ .generation = e->generation,
+ .entry_valid = calc_timeout_sec(e->entry_timeout),
+ .entry_valid_nsec = calc_timeout_nsec(e->entry_timeout),
+ .attr_valid = calc_timeout_sec(e->attr_timeout),
+ .attr_valid_nsec = calc_timeout_nsec(e->attr_timeout),
+ };
convert_stat(&e->attr, &arg->attr);
}
@@ -362,10 +368,12 @@ size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize,
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;
+ *dirent = (struct fuse_dirent){
+ .ino = e->attr.st_ino,
+ .off = off,
+ .namelen = namelen,
+ .type = (e->attr.st_mode & S_IFMT) >> 12,
+ };
memcpy(dirent->name, name, namelen);
memset(dirent->name + namelen, 0, entlen_padded - entlen);
@@ -496,15 +504,14 @@ static int fuse_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv)
{
struct iovec iov[2];
- struct fuse_out_header out;
+ struct fuse_out_header out = {
+ .unique = req->unique,
+ };
int res;
iov[0].iov_base = &out;
iov[0].iov_len = sizeof(struct fuse_out_header);
- out.unique = req->unique;
- out.error = 0;
-
res = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv);
if (res <= 0) {
fuse_free_req(req);
@@ -2145,14 +2152,14 @@ static void do_destroy(fuse_req_t req, fuse_ino_t nodeid,
static int send_notify_iov(struct fuse_session *se, int notify_code,
struct iovec *iov, int count)
{
- struct fuse_out_header out;
+ struct fuse_out_header out = {
+ .error = notify_code,
+ };
if (!se->got_init) {
return -ENOTCONN;
}
- out.unique = 0;
- out.error = notify_code;
iov[0].iov_base = &out;
iov[0].iov_len = sizeof(struct fuse_out_header);
@@ -2162,11 +2169,11 @@ static int send_notify_iov(struct fuse_session *se, int notify_code,
int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph)
{
if (ph != NULL) {
- struct fuse_notify_poll_wakeup_out outarg;
+ struct fuse_notify_poll_wakeup_out outarg = {
+ .kh = ph->kh,
+ };
struct iovec iov[2];
- outarg.kh = ph->kh;
-
iov[1].iov_base = &outarg;
iov[1].iov_len = sizeof(outarg);
@@ -2179,17 +2186,17 @@ int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph)
int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
off_t off, off_t len)
{
- struct fuse_notify_inval_inode_out outarg;
+ struct fuse_notify_inval_inode_out outarg = {
+ .ino = ino,
+ .off = off,
+ .len = len,
+ };
struct iovec iov[2];
if (!se) {
return -EINVAL;
}
- outarg.ino = ino;
- outarg.off = off;
- outarg.len = len;
-
iov[1].iov_base = &outarg;
iov[1].iov_len = sizeof(outarg);
@@ -2199,17 +2206,16 @@ int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
const char *name, size_t namelen)
{
- struct fuse_notify_inval_entry_out outarg;
+ struct fuse_notify_inval_entry_out outarg = {
+ .parent = parent,
+ .namelen = namelen,
+ };
struct iovec iov[3];
if (!se) {
return -EINVAL;
}
- outarg.parent = parent;
- outarg.namelen = namelen;
- outarg.padding = 0;
-
iov[1].iov_base = &outarg;
iov[1].iov_len = sizeof(outarg);
iov[2].iov_base = (void *)name;
@@ -2222,18 +2228,17 @@ int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
fuse_ino_t child, const char *name,
size_t namelen)
{
- struct fuse_notify_delete_out outarg;
+ struct fuse_notify_delete_out outarg = {
+ .parent = parent,
+ .child = child,
+ .namelen = namelen,
+ };
struct iovec iov[3];
if (!se) {
return -EINVAL;
}
- outarg.parent = parent;
- outarg.child = child;
- outarg.namelen = namelen;
- outarg.padding = 0;
-
iov[1].iov_base = &outarg;
iov[1].iov_len = sizeof(outarg);
iov[2].iov_base = (void *)name;
@@ -2245,24 +2250,21 @@ int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
off_t offset, struct fuse_bufvec *bufv)
{
- struct fuse_out_header out;
- struct fuse_notify_store_out outarg;
+ struct fuse_out_header out = {
+ .error = FUSE_NOTIFY_STORE,
+ };
+ struct fuse_notify_store_out outarg = {
+ .nodeid = ino,
+ .offset = offset,
+ .size = fuse_buf_size(bufv),
+ };
struct iovec iov[3];
- size_t size = fuse_buf_size(bufv);
int res;
if (!se) {
return -EINVAL;
}
- out.unique = 0;
- out.error = FUSE_NOTIFY_STORE;
-
- outarg.nodeid = ino;
- outarg.offset = offset;
- outarg.size = size;
- outarg.padding = 0;
-
iov[0].iov_base = &out;
iov[0].iov_len = sizeof(out);
iov[1].iov_base = &outarg;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 058/108] virtiofsd: add --syslog command-line option
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (56 preceding siblings ...)
2020-01-23 16:45 ` [PULL 057/108] virtiofsd: fix libfuse information leaks Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 059/108] virtiofsd: print log only when priority is high enough Dr. David Alan Gilbert (git)
` (51 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Sometimes collecting output from stderr is inconvenient or does not fit
within the overall logging architecture. Add syslog(3) support for
cases where stderr cannot be used.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
dgilbert: Reworked as a logging function
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>
---
tools/virtiofsd/fuse_lowlevel.h | 1 +
tools/virtiofsd/helper.c | 2 ++
tools/virtiofsd/passthrough_ll.c | 50 ++++++++++++++++++++++++++++++--
tools/virtiofsd/seccomp.c | 32 ++++++++++++++------
tools/virtiofsd/seccomp.h | 4 ++-
5 files changed, 76 insertions(+), 13 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index 0d61df8110..f2750bc189 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -1795,6 +1795,7 @@ struct fuse_cmdline_opts {
int show_version;
int show_help;
int print_capabilities;
+ int syslog;
unsigned int max_idle_threads;
};
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 5531425223..9692ef9f1f 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -54,6 +54,7 @@ static const struct fuse_opt fuse_helper_opts[] = {
FUSE_HELPER_OPT("subtype=", nodefault_subtype),
FUSE_OPT_KEY("subtype=", FUSE_OPT_KEY_KEEP),
FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),
+ FUSE_HELPER_OPT("--syslog", syslog),
FUSE_OPT_END
};
@@ -138,6 +139,7 @@ void fuse_cmdline_help(void)
" -V --version print version\n"
" --print-capabilities print vhost-user.json\n"
" -d -o debug enable debug output (implies -f)\n"
+ " --syslog log to syslog (default stderr)\n"
" -f foreground operation\n"
" --daemonize run in background\n"
" -o max_idle_threads the maximum number of idle worker "
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index c281d817af..0372aca143 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -58,6 +58,7 @@
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
+#include <syslog.h>
#include <unistd.h>
#include "passthrough_helpers.h"
@@ -138,6 +139,7 @@ static const struct fuse_opt lo_opts[] = {
{ "norace", offsetof(struct lo_data, norace), 1 },
FUSE_OPT_END
};
+static bool use_syslog = false;
static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n);
@@ -2262,11 +2264,12 @@ static void setup_mounts(const char *source)
* Lock down this process to prevent access to other processes or files outside
* source directory. This reduces the impact of arbitrary code execution bugs.
*/
-static void setup_sandbox(struct lo_data *lo, struct fuse_session *se)
+static void setup_sandbox(struct lo_data *lo, struct fuse_session *se,
+ bool enable_syslog)
{
setup_namespaces(lo, se);
setup_mounts(lo->source);
- setup_seccomp();
+ setup_seccomp(enable_syslog);
}
/* Raise the maximum number of open file descriptors */
@@ -2298,6 +2301,42 @@ static void setup_nofile_rlimit(void)
}
}
+static void log_func(enum fuse_log_level level, const char *fmt, va_list ap)
+{
+ if (use_syslog) {
+ int priority = LOG_ERR;
+ switch (level) {
+ case FUSE_LOG_EMERG:
+ priority = LOG_EMERG;
+ break;
+ case FUSE_LOG_ALERT:
+ priority = LOG_ALERT;
+ break;
+ case FUSE_LOG_CRIT:
+ priority = LOG_CRIT;
+ break;
+ case FUSE_LOG_ERR:
+ priority = LOG_ERR;
+ break;
+ case FUSE_LOG_WARNING:
+ priority = LOG_WARNING;
+ break;
+ case FUSE_LOG_NOTICE:
+ priority = LOG_NOTICE;
+ break;
+ case FUSE_LOG_INFO:
+ priority = LOG_INFO;
+ break;
+ case FUSE_LOG_DEBUG:
+ priority = LOG_DEBUG;
+ break;
+ }
+ vsyslog(priority, fmt, ap);
+ } else {
+ vfprintf(stderr, fmt, ap);
+ }
+}
+
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
@@ -2336,6 +2375,11 @@ int main(int argc, char *argv[])
if (fuse_parse_cmdline(&args, &opts) != 0) {
return 1;
}
+ fuse_set_log_func(log_func);
+ use_syslog = opts.syslog;
+ if (use_syslog) {
+ openlog("virtiofsd", LOG_PID, LOG_DAEMON);
+ }
if (opts.show_help) {
printf("usage: %s [options]\n\n", argv[0]);
fuse_cmdline_help();
@@ -2424,7 +2468,7 @@ int main(int argc, char *argv[])
/* Must be before sandbox since it wants /proc */
setup_capng();
- setup_sandbox(&lo, se);
+ setup_sandbox(&lo, se, opts.syslog);
/* Block until ctrl+c or fusermount -u */
ret = virtio_loop(se);
diff --git a/tools/virtiofsd/seccomp.c b/tools/virtiofsd/seccomp.c
index 691fb63dea..2d9d4a7ec0 100644
--- a/tools/virtiofsd/seccomp.c
+++ b/tools/virtiofsd/seccomp.c
@@ -107,11 +107,28 @@ static const int syscall_whitelist[] = {
SCMP_SYS(writev),
};
-void setup_seccomp(void)
+/* Syscalls used when --syslog is enabled */
+static const int syscall_whitelist_syslog[] = {
+ SCMP_SYS(sendto),
+};
+
+static void add_whitelist(scmp_filter_ctx ctx, const int syscalls[], size_t len)
{
- scmp_filter_ctx ctx;
size_t i;
+ for (i = 0; i < len; i++) {
+ if (seccomp_rule_add(ctx, SCMP_ACT_ALLOW, syscalls[i], 0) != 0) {
+ fuse_log(FUSE_LOG_ERR, "seccomp_rule_add syscall %d failed\n",
+ syscalls[i]);
+ exit(1);
+ }
+ }
+}
+
+void setup_seccomp(bool enable_syslog)
+{
+ scmp_filter_ctx ctx;
+
#ifdef SCMP_ACT_KILL_PROCESS
ctx = seccomp_init(SCMP_ACT_KILL_PROCESS);
/* Handle a newer libseccomp but an older kernel */
@@ -126,13 +143,10 @@ void setup_seccomp(void)
exit(1);
}
- for (i = 0; i < G_N_ELEMENTS(syscall_whitelist); i++) {
- if (seccomp_rule_add(ctx, SCMP_ACT_ALLOW,
- syscall_whitelist[i], 0) != 0) {
- fuse_log(FUSE_LOG_ERR, "seccomp_rule_add syscall %d",
- syscall_whitelist[i]);
- exit(1);
- }
+ add_whitelist(ctx, syscall_whitelist, G_N_ELEMENTS(syscall_whitelist));
+ if (enable_syslog) {
+ add_whitelist(ctx, syscall_whitelist_syslog,
+ G_N_ELEMENTS(syscall_whitelist_syslog));
}
/* libvhost-user calls this for post-copy migration, we don't need it */
diff --git a/tools/virtiofsd/seccomp.h b/tools/virtiofsd/seccomp.h
index 86bce72652..d47c8eade6 100644
--- a/tools/virtiofsd/seccomp.h
+++ b/tools/virtiofsd/seccomp.h
@@ -9,6 +9,8 @@
#ifndef VIRTIOFSD_SECCOMP_H
#define VIRTIOFSD_SECCOMP_H
-void setup_seccomp(void);
+#include <stdbool.h>
+
+void setup_seccomp(bool enable_syslog);
#endif /* VIRTIOFSD_SECCOMP_H */
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 059/108] virtiofsd: print log only when priority is high enough
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (57 preceding siblings ...)
2020-01-23 16:45 ` [PULL 058/108] virtiofsd: add --syslog command-line option Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 060/108] virtiofsd: Add ID to the log with FUSE_LOG_DEBUG level Dr. David Alan Gilbert (git)
` (50 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Eryu Guan <eguan@linux.alibaba.com>
Introduce "-o log_level=" command line option to specify current log
level (priority), valid values are "debug info warn err", e.g.
./virtiofsd -o log_level=debug ...
So only log priority higher than "debug" will be printed to
stderr/syslog. And the default level is info.
The "-o debug"/"-d" options are kept, and imply debug log level.
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
dgilbert: Reworked for libfuse's log_func
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
with fix by:
Signed-off-by: Xiao Yang <yangx.jy@cn.fujitsu.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 75 ++++++++------------
tools/virtiofsd/fuse_lowlevel.h | 1 +
tools/virtiofsd/helper.c | 8 ++-
tools/virtiofsd/passthrough_ll.c | 118 +++++++++++++------------------
4 files changed, 87 insertions(+), 115 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 6ceb33d913..a7a19685b5 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -158,19 +158,17 @@ static int fuse_send_msg(struct fuse_session *se, struct fuse_chan *ch,
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);
- }
+ 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);
}
if (fuse_lowlevel_is_virtio(se)) {
@@ -1662,10 +1660,8 @@ static void do_interrupt(fuse_req_t req, fuse_ino_t nodeid,
return;
}
- if (se->debug) {
- fuse_log(FUSE_LOG_DEBUG, "INTERRUPT: %llu\n",
- (unsigned long long)arg->unique);
- }
+ fuse_log(FUSE_LOG_DEBUG, "INTERRUPT: %llu\n",
+ (unsigned long long)arg->unique);
req->u.i.unique = arg->unique;
@@ -1901,13 +1897,10 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid,
}
}
- if (se->debug) {
- fuse_log(FUSE_LOG_DEBUG, "INIT: %u.%u\n", arg->major, arg->minor);
- if (arg->major == 7 && arg->minor >= 6) {
- fuse_log(FUSE_LOG_DEBUG, "flags=0x%08x\n", arg->flags);
- fuse_log(FUSE_LOG_DEBUG, "max_readahead=0x%08x\n",
- arg->max_readahead);
- }
+ fuse_log(FUSE_LOG_DEBUG, "INIT: %u.%u\n", arg->major, arg->minor);
+ if (arg->major == 7 && arg->minor >= 6) {
+ fuse_log(FUSE_LOG_DEBUG, "flags=0x%08x\n", arg->flags);
+ fuse_log(FUSE_LOG_DEBUG, "max_readahead=0x%08x\n", arg->max_readahead);
}
se->conn.proto_major = arg->major;
se->conn.proto_minor = arg->minor;
@@ -2116,19 +2109,14 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid,
outarg.congestion_threshold = se->conn.congestion_threshold;
outarg.time_gran = se->conn.time_gran;
- if (se->debug) {
- fuse_log(FUSE_LOG_DEBUG, " INIT: %u.%u\n", outarg.major,
- outarg.minor);
- fuse_log(FUSE_LOG_DEBUG, " flags=0x%08x\n", outarg.flags);
- fuse_log(FUSE_LOG_DEBUG, " max_readahead=0x%08x\n",
- outarg.max_readahead);
- fuse_log(FUSE_LOG_DEBUG, " max_write=0x%08x\n", outarg.max_write);
- fuse_log(FUSE_LOG_DEBUG, " max_background=%i\n",
- outarg.max_background);
- fuse_log(FUSE_LOG_DEBUG, " congestion_threshold=%i\n",
- outarg.congestion_threshold);
- fuse_log(FUSE_LOG_DEBUG, " time_gran=%u\n", outarg.time_gran);
- }
+ fuse_log(FUSE_LOG_DEBUG, " INIT: %u.%u\n", outarg.major, outarg.minor);
+ fuse_log(FUSE_LOG_DEBUG, " flags=0x%08x\n", outarg.flags);
+ fuse_log(FUSE_LOG_DEBUG, " max_readahead=0x%08x\n", outarg.max_readahead);
+ fuse_log(FUSE_LOG_DEBUG, " max_write=0x%08x\n", outarg.max_write);
+ fuse_log(FUSE_LOG_DEBUG, " max_background=%i\n", outarg.max_background);
+ fuse_log(FUSE_LOG_DEBUG, " congestion_threshold=%i\n",
+ outarg.congestion_threshold);
+ fuse_log(FUSE_LOG_DEBUG, " time_gran=%u\n", outarg.time_gran);
send_reply_ok(req, &outarg, outargsize);
}
@@ -2407,14 +2395,11 @@ void fuse_session_process_buf_int(struct fuse_session *se,
in = fuse_mbuf_iter_advance(&iter, sizeof(*in));
assert(in); /* caller guarantees the input buffer is large enough */
- if (se->debug) {
- fuse_log(FUSE_LOG_DEBUG,
- "unique: %llu, opcode: %s (%i), nodeid: %llu, insize: %zu, "
- "pid: %u\n",
- (unsigned long long)in->unique,
- opname((enum fuse_opcode)in->opcode), in->opcode,
- (unsigned long long)in->nodeid, buf->size, in->pid);
- }
+ fuse_log(
+ FUSE_LOG_DEBUG,
+ "unique: %llu, opcode: %s (%i), nodeid: %llu, insize: %zu, pid: %u\n",
+ (unsigned long long)in->unique, opname((enum fuse_opcode)in->opcode),
+ in->opcode, (unsigned long long)in->nodeid, buf->size, in->pid);
req = fuse_ll_alloc_req(se);
if (req == NULL) {
diff --git a/tools/virtiofsd/fuse_lowlevel.h b/tools/virtiofsd/fuse_lowlevel.h
index f2750bc189..138041e5f1 100644
--- a/tools/virtiofsd/fuse_lowlevel.h
+++ b/tools/virtiofsd/fuse_lowlevel.h
@@ -1796,6 +1796,7 @@ struct fuse_cmdline_opts {
int show_help;
int print_capabilities;
int syslog;
+ int log_level;
unsigned int max_idle_threads;
};
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 9692ef9f1f..6d50a46a7e 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -34,7 +34,6 @@
t, offsetof(struct fuse_cmdline_opts, p), v \
}
-
static const struct fuse_opt fuse_helper_opts[] = {
FUSE_HELPER_OPT("-h", show_help),
FUSE_HELPER_OPT("--help", show_help),
@@ -55,6 +54,10 @@ static const struct fuse_opt fuse_helper_opts[] = {
FUSE_OPT_KEY("subtype=", FUSE_OPT_KEY_KEEP),
FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),
FUSE_HELPER_OPT("--syslog", syslog),
+ FUSE_HELPER_OPT_VALUE("log_level=debug", log_level, FUSE_LOG_DEBUG),
+ FUSE_HELPER_OPT_VALUE("log_level=info", log_level, FUSE_LOG_INFO),
+ FUSE_HELPER_OPT_VALUE("log_level=warn", log_level, FUSE_LOG_WARNING),
+ FUSE_HELPER_OPT_VALUE("log_level=err", log_level, FUSE_LOG_ERR),
FUSE_OPT_END
};
@@ -142,6 +145,9 @@ void fuse_cmdline_help(void)
" --syslog log to syslog (default stderr)\n"
" -f foreground operation\n"
" --daemonize run in background\n"
+ " -o log_level=<level> log level, default to \"info\"\n"
+ " level could be one of \"debug, "
+ "info, warn, err\"\n"
" -o max_idle_threads the maximum number of idle worker "
"threads\n"
" allowed (default: 10)\n"
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 0372aca143..ff6910fd73 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -37,6 +37,7 @@
#include "qemu/osdep.h"
#include "fuse_virtio.h"
+#include "fuse_log.h"
#include "fuse_lowlevel.h"
#include <assert.h>
#include <cap-ng.h>
@@ -140,6 +141,7 @@ static const struct fuse_opt lo_opts[] = {
FUSE_OPT_END
};
static bool use_syslog = false;
+static int current_log_level;
static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n);
@@ -458,11 +460,6 @@ static int lo_fd(fuse_req_t req, fuse_ino_t ino)
return inode ? inode->fd : -1;
}
-static bool lo_debug(fuse_req_t req)
-{
- return lo_data(req)->debug != 0;
-}
-
static void lo_init(void *userdata, struct fuse_conn_info *conn)
{
struct lo_data *lo = (struct lo_data *)userdata;
@@ -472,15 +469,11 @@ static void lo_init(void *userdata, struct fuse_conn_info *conn)
}
if (lo->writeback && conn->capable & FUSE_CAP_WRITEBACK_CACHE) {
- if (lo->debug) {
- fuse_log(FUSE_LOG_DEBUG, "lo_init: activating writeback\n");
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating writeback\n");
conn->want |= FUSE_CAP_WRITEBACK_CACHE;
}
if (lo->flock && conn->capable & FUSE_CAP_FLOCK_LOCKS) {
- if (lo->debug) {
- fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
conn->want |= FUSE_CAP_FLOCK_LOCKS;
}
}
@@ -823,10 +816,8 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
}
e->ino = inode->fuse_ino;
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
- (unsigned long long)parent, name, (unsigned long long)e->ino);
- }
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n", (unsigned long long)parent,
+ name, (unsigned long long)e->ino);
return 0;
@@ -843,10 +834,8 @@ static void lo_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
struct fuse_entry_param e;
int err;
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_lookup(parent=%" PRIu64 ", name=%s)\n",
- parent, name);
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_lookup(parent=%" PRIu64 ", name=%s)\n", parent,
+ name);
/*
* Don't use is_safe_path_component(), allow "." and ".." for NFS export
@@ -971,10 +960,8 @@ static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
goto out;
}
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
- (unsigned long long)parent, name, (unsigned long long)e.ino);
- }
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n", (unsigned long long)parent,
+ name, (unsigned long long)e.ino);
fuse_reply_entry(req, &e);
return;
@@ -1074,10 +1061,8 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
pthread_mutex_unlock(&lo->mutex);
e.ino = inode->fuse_ino;
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
- (unsigned long long)parent, name, (unsigned long long)e.ino);
- }
+ fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n", (unsigned long long)parent,
+ name, (unsigned long long)e.ino);
fuse_reply_entry(req, &e);
return;
@@ -1171,11 +1156,9 @@ static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
return;
}
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",
- (unsigned long long)ino, (unsigned long long)inode->refcount,
- (unsigned long long)nlookup);
- }
+ fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",
+ (unsigned long long)ino, (unsigned long long)inode->refcount,
+ (unsigned long long)nlookup);
unref_inode(lo, inode, nlookup);
}
@@ -1445,10 +1428,8 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
int err;
struct lo_cred old = {};
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_create(parent=%" PRIu64 ", name=%s)\n",
- parent, name);
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_create(parent=%" PRIu64 ", name=%s)\n", parent,
+ name);
if (!is_safe_path_component(name)) {
fuse_reply_err(req, EINVAL);
@@ -1525,10 +1506,8 @@ static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
char buf[64];
struct lo_data *lo = lo_data(req);
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_open(ino=%" PRIu64 ", flags=%d)\n", ino,
- fi->flags);
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_open(ino=%" PRIu64 ", flags=%d)\n", ino,
+ fi->flags);
/*
* With writeback cache, kernel may send read requests even
@@ -1644,12 +1623,10 @@ static void lo_read(fuse_req_t req, fuse_ino_t ino, size_t size, off_t offset,
{
struct fuse_bufvec buf = FUSE_BUFVEC_INIT(size);
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG,
- "lo_read(ino=%" PRIu64 ", size=%zd, "
- "off=%lu)\n",
- ino, size, (unsigned long)offset);
- }
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_read(ino=%" PRIu64 ", size=%zd, "
+ "off=%lu)\n",
+ ino, size, (unsigned long)offset);
buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
buf.buf[0].fd = lo_fi_fd(req, fi);
@@ -1671,11 +1648,9 @@ static void lo_write_buf(fuse_req_t req, fuse_ino_t ino,
out_buf.buf[0].fd = lo_fi_fd(req, fi);
out_buf.buf[0].pos = off;
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG,
- "lo_write(ino=%" PRIu64 ", size=%zd, off=%lu)\n", ino,
- out_buf.buf[0].size, (unsigned long)off);
- }
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_write_buf(ino=%" PRIu64 ", size=%zd, off=%lu)\n", ino,
+ out_buf.buf[0].size, (unsigned long)off);
/*
* If kill_priv is set, drop CAP_FSETID which should lead to kernel
@@ -1774,11 +1749,8 @@ static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
goto out;
}
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG,
- "lo_getxattr(ino=%" PRIu64 ", name=%s size=%zd)\n", ino, name,
- size);
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_getxattr(ino=%" PRIu64 ", name=%s size=%zd)\n",
+ ino, name, size);
if (inode->is_symlink) {
/* Sorry, no race free way to getxattr on symlink. */
@@ -1852,10 +1824,8 @@ static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
goto out;
}
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_listxattr(ino=%" PRIu64 ", size=%zd)\n",
- ino, size);
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_listxattr(ino=%" PRIu64 ", size=%zd)\n", ino,
+ size);
if (inode->is_symlink) {
/* Sorry, no race free way to listxattr on symlink. */
@@ -1929,11 +1899,8 @@ static void lo_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
goto out;
}
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG,
- "lo_setxattr(ino=%" PRIu64 ", name=%s value=%s size=%zd)\n",
- ino, name, value, size);
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_setxattr(ino=%" PRIu64
+ ", name=%s value=%s size=%zd)\n", ino, name, value, size);
if (inode->is_symlink) {
/* Sorry, no race free way to setxattr on symlink. */
@@ -1978,10 +1945,8 @@ static void lo_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name)
goto out;
}
- if (lo_debug(req)) {
- fuse_log(FUSE_LOG_DEBUG, "lo_removexattr(ino=%" PRIu64 ", name=%s)\n",
- ino, name);
- }
+ fuse_log(FUSE_LOG_DEBUG, "lo_removexattr(ino=%" PRIu64 ", name=%s)\n", ino,
+ name);
if (inode->is_symlink) {
/* Sorry, no race free way to setxattr on symlink. */
@@ -2303,6 +2268,10 @@ static void setup_nofile_rlimit(void)
static void log_func(enum fuse_log_level level, const char *fmt, va_list ap)
{
+ if (current_log_level < level) {
+ return;
+ }
+
if (use_syslog) {
int priority = LOG_ERR;
switch (level) {
@@ -2401,8 +2370,19 @@ int main(int argc, char *argv[])
return 1;
}
+ /*
+ * log_level is 0 if not configured via cmd options (0 is LOG_EMERG,
+ * and we don't use this log level).
+ */
+ if (opts.log_level != 0) {
+ current_log_level = opts.log_level;
+ }
lo.debug = opts.debug;
+ if (lo.debug) {
+ current_log_level = FUSE_LOG_DEBUG;
+ }
lo.root.refcount = 2;
+
if (lo.source) {
struct stat stat;
int res;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 060/108] virtiofsd: Add ID to the log with FUSE_LOG_DEBUG level
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (58 preceding siblings ...)
2020-01-23 16:45 ` [PULL 059/108] virtiofsd: print log only when priority is high enough Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 061/108] virtiofsd: Add timestamp " Dr. David Alan Gilbert (git)
` (49 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
virtiofsd has some threads, so we see a lot of logs with debug option.
It would be useful for debugging if we can identify the specific thread
from the log.
Add ID, which is got by gettid(), to the log with FUSE_LOG_DEBUG level
so that we can grep the specific thread.
The log is like as:
]# ./virtiofsd -d -o vhost_user_socket=/tmp/vhostqemu0 -o source=/tmp/share0 -o cache=auto
...
[ID: 00000097] unique: 12696, success, outsize: 120
[ID: 00000097] virtio_send_msg: elem 18: with 2 in desc of length 120
[ID: 00000003] fv_queue_thread: Got queue event on Queue 1
[ID: 00000003] fv_queue_thread: Queue 1 gave evalue: 1 available: in: 65552 out: 80
[ID: 00000003] fv_queue_thread: Waiting for Queue 1 event
[ID: 00000071] fv_queue_worker: elem 33: with 2 out desc of length 80 bad_in_num=0 bad_out_num=0
[ID: 00000071] unique: 12694, opcode: READ (15), nodeid: 2, insize: 80, pid: 2014
[ID: 00000071] lo_read(ino=2, size=65536, off=131072)
Signed-off-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
added rework as suggested by Daniel P. Berrangé during review
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index ff6910fd73..f08324f000 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -43,6 +43,7 @@
#include <cap-ng.h>
#include <dirent.h>
#include <errno.h>
+#include <glib.h>
#include <inttypes.h>
#include <limits.h>
#include <pthread.h>
@@ -2268,10 +2269,17 @@ static void setup_nofile_rlimit(void)
static void log_func(enum fuse_log_level level, const char *fmt, va_list ap)
{
+ g_autofree char *localfmt = NULL;
+
if (current_log_level < level) {
return;
}
+ if (current_log_level == FUSE_LOG_DEBUG) {
+ localfmt = g_strdup_printf("[ID: %08ld] %s", syscall(__NR_gettid), fmt);
+ fmt = localfmt;
+ }
+
if (use_syslog) {
int priority = LOG_ERR;
switch (level) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 061/108] virtiofsd: Add timestamp to the log with FUSE_LOG_DEBUG level
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (59 preceding siblings ...)
2020-01-23 16:45 ` [PULL 060/108] virtiofsd: Add ID to the log with FUSE_LOG_DEBUG level Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 062/108] virtiofsd: Handle reinit Dr. David Alan Gilbert (git)
` (48 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
virtiofsd has some threads, so we see a lot of logs with debug option.
It would be useful for debugging if we can see the timestamp.
Add nano second timestamp, which got by get_clock(), to the log with
FUSE_LOG_DEBUG level if the syslog option isn't set.
The log is like as:
# ./virtiofsd -d -o vhost_user_socket=/tmp/vhostqemu0 -o source=/tmp/share0 -o cache=auto
...
[5365943125463727] [ID: 00000002] fv_queue_thread: Start for queue 0 kick_fd 9
[5365943125568644] [ID: 00000002] fv_queue_thread: Waiting for Queue 0 event
[5365943125573561] [ID: 00000002] fv_queue_thread: Got queue event on Queue 0
Signed-off-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 9 ++++++++-
1 file changed, 8 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index f08324f000..98114a3f4a 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -36,6 +36,7 @@
*/
#include "qemu/osdep.h"
+#include "qemu/timer.h"
#include "fuse_virtio.h"
#include "fuse_log.h"
#include "fuse_lowlevel.h"
@@ -2276,7 +2277,13 @@ static void log_func(enum fuse_log_level level, const char *fmt, va_list ap)
}
if (current_log_level == FUSE_LOG_DEBUG) {
- localfmt = g_strdup_printf("[ID: %08ld] %s", syscall(__NR_gettid), fmt);
+ if (!use_syslog) {
+ localfmt = g_strdup_printf("[%" PRId64 "] [ID: %08ld] %s",
+ get_clock(), syscall(__NR_gettid), fmt);
+ } else {
+ localfmt = g_strdup_printf("[ID: %08ld] %s", syscall(__NR_gettid),
+ fmt);
+ }
fmt = localfmt;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 062/108] virtiofsd: Handle reinit
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (60 preceding siblings ...)
2020-01-23 16:45 ` [PULL 061/108] virtiofsd: Add timestamp " Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 063/108] virtiofsd: Handle hard reboot Dr. David Alan Gilbert (git)
` (47 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Allow init->destroy->init for mount->umount->mount
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>
---
tools/virtiofsd/fuse_lowlevel.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index a7a19685b5..7d742b5a72 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2028,6 +2028,7 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid,
}
se->got_init = 1;
+ se->got_destroy = 0;
if (se->op.init) {
se->op.init(se->userdata, &se->conn);
}
@@ -2130,6 +2131,7 @@ static void do_destroy(fuse_req_t req, fuse_ino_t nodeid,
(void)iter;
se->got_destroy = 1;
+ se->got_init = 0;
if (se->op.destroy) {
se->op.destroy(se->userdata);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 063/108] virtiofsd: Handle hard reboot
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (61 preceding siblings ...)
2020-01-23 16:45 ` [PULL 062/108] virtiofsd: Handle reinit Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 064/108] virtiofsd: Kill threads when queues are stopped Dr. David Alan Gilbert (git)
` (46 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Handle a
mount
hard reboot (without unmount)
mount
we get another 'init' which FUSE doesn't normally expect.
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>
---
tools/virtiofsd/fuse_lowlevel.c | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 7d742b5a72..65f91dabae 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2433,7 +2433,21 @@ void fuse_session_process_buf_int(struct fuse_session *se,
goto reply_err;
}
} else if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT) {
- goto reply_err;
+ if (fuse_lowlevel_is_virtio(se)) {
+ /*
+ * TODO: This is after a hard reboot typically, we need to do
+ * a destroy, but we can't reply to this request yet so
+ * we can't use do_destroy
+ */
+ fuse_log(FUSE_LOG_DEBUG, "%s: reinit\n", __func__);
+ se->got_destroy = 1;
+ se->got_init = 0;
+ if (se->op.destroy) {
+ se->op.destroy(se->userdata);
+ }
+ } else {
+ goto reply_err;
+ }
}
err = EACCES;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 064/108] virtiofsd: Kill threads when queues are stopped
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (62 preceding siblings ...)
2020-01-23 16:45 ` [PULL 063/108] virtiofsd: Handle hard reboot Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 065/108] vhost-user: Print unexpected slave message types Dr. David Alan Gilbert (git)
` (45 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Kill the threads we've started when the queues get stopped.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
With improvements by:
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_virtio.c | 51 ++++++++++++++++++++++++++++++-----
1 file changed, 44 insertions(+), 7 deletions(-)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 872968f2c8..7a8774a3ee 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -41,6 +41,7 @@ struct fv_QueueInfo {
/* Our queue index, corresponds to array position */
int qidx;
int kick_fd;
+ int kill_fd; /* For killing the thread */
/* The element for the command currently being processed */
VuVirtqElement *qe;
@@ -412,14 +413,17 @@ static void *fv_queue_thread(void *opaque)
fuse_log(FUSE_LOG_INFO, "%s: Start for queue %d kick_fd %d\n", __func__,
qi->qidx, qi->kick_fd);
while (1) {
- struct pollfd pf[1];
+ struct pollfd pf[2];
pf[0].fd = qi->kick_fd;
pf[0].events = POLLIN;
pf[0].revents = 0;
+ pf[1].fd = qi->kill_fd;
+ pf[1].events = POLLIN;
+ pf[1].revents = 0;
fuse_log(FUSE_LOG_DEBUG, "%s: Waiting for Queue %d event\n", __func__,
qi->qidx);
- int poll_res = ppoll(pf, 1, NULL, NULL);
+ int poll_res = ppoll(pf, 2, NULL, NULL);
if (poll_res == -1) {
if (errno == EINTR) {
@@ -430,12 +434,23 @@ static void *fv_queue_thread(void *opaque)
fuse_log(FUSE_LOG_ERR, "fv_queue_thread ppoll: %m\n");
break;
}
- assert(poll_res == 1);
+ assert(poll_res >= 1);
if (pf[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
fuse_log(FUSE_LOG_ERR, "%s: Unexpected poll revents %x Queue %d\n",
__func__, pf[0].revents, qi->qidx);
break;
}
+ if (pf[1].revents & (POLLERR | POLLHUP | POLLNVAL)) {
+ fuse_log(FUSE_LOG_ERR,
+ "%s: Unexpected poll revents %x Queue %d killfd\n",
+ __func__, pf[1].revents, qi->qidx);
+ break;
+ }
+ if (pf[1].revents) {
+ fuse_log(FUSE_LOG_INFO, "%s: kill event on queue %d - quitting\n",
+ __func__, qi->qidx);
+ break;
+ }
assert(pf[0].revents & POLLIN);
fuse_log(FUSE_LOG_DEBUG, "%s: Got queue event on Queue %d\n", __func__,
qi->qidx);
@@ -589,6 +604,28 @@ out:
return NULL;
}
+static void fv_queue_cleanup_thread(struct fv_VuDev *vud, int qidx)
+{
+ int ret;
+ struct fv_QueueInfo *ourqi;
+
+ assert(qidx < vud->nqueues);
+ ourqi = vud->qi[qidx];
+
+ /* Kill the thread */
+ if (eventfd_write(ourqi->kill_fd, 1)) {
+ fuse_log(FUSE_LOG_ERR, "Eventfd_write for queue %d: %s\n",
+ qidx, strerror(errno));
+ }
+ ret = pthread_join(ourqi->thread, NULL);
+ if (ret) {
+ fuse_log(FUSE_LOG_ERR, "%s: Failed to join thread idx %d err %d\n",
+ __func__, qidx, ret);
+ }
+ close(ourqi->kill_fd);
+ ourqi->kick_fd = -1;
+}
+
/* Callback from libvhost-user on start or stop of a queue */
static void fv_queue_set_started(VuDev *dev, int qidx, bool started)
{
@@ -633,16 +670,16 @@ static void fv_queue_set_started(VuDev *dev, int qidx, bool started)
}
ourqi = vud->qi[qidx];
ourqi->kick_fd = dev->vq[qidx].kick_fd;
+
+ ourqi->kill_fd = eventfd(0, EFD_CLOEXEC | EFD_SEMAPHORE);
+ assert(ourqi->kill_fd != -1);
if (pthread_create(&ourqi->thread, NULL, fv_queue_thread, ourqi)) {
fuse_log(FUSE_LOG_ERR, "%s: Failed to create thread for queue %d\n",
__func__, qidx);
assert(0);
}
} else {
- /* TODO: Kill the thread */
- assert(qidx < vud->nqueues);
- ourqi = vud->qi[qidx];
- ourqi->kick_fd = -1;
+ fv_queue_cleanup_thread(vud, qidx);
}
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 065/108] vhost-user: Print unexpected slave message types
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (63 preceding siblings ...)
2020-01-23 16:45 ` [PULL 064/108] virtiofsd: Kill threads when queues are stopped Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 066/108] contrib/libvhost-user: Protect slave fd with mutex Dr. David Alan Gilbert (git)
` (44 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
When we receive an unexpected message type on the slave fd, print
the type.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
hw/virtio/vhost-user.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index d27a10fcc6..2e81f5514f 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -1061,7 +1061,7 @@ static void slave_read(void *opaque)
fd[0]);
break;
default:
- error_report("Received unexpected msg type.");
+ error_report("Received unexpected msg type: %d.", hdr.request);
ret = -EINVAL;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 066/108] contrib/libvhost-user: Protect slave fd with mutex
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (64 preceding siblings ...)
2020-01-23 16:45 ` [PULL 065/108] vhost-user: Print unexpected slave message types Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 067/108] virtiofsd: passthrough_ll: add renameat2 support Dr. David Alan Gilbert (git)
` (43 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
In future patches we'll be performing commands on the slave-fd driven
by commands on queues, since those queues will be driven by individual
threads we need to make sure they don't attempt to use the slave-fd
for multiple commands in parallel.
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>
---
contrib/libvhost-user/libvhost-user.c | 24 ++++++++++++++++++++----
contrib/libvhost-user/libvhost-user.h | 3 +++
2 files changed, 23 insertions(+), 4 deletions(-)
diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
index ec27b78ff1..63e41062a4 100644
--- a/contrib/libvhost-user/libvhost-user.c
+++ b/contrib/libvhost-user/libvhost-user.c
@@ -392,26 +392,37 @@ vu_send_reply(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
return vu_message_write(dev, conn_fd, vmsg);
}
+/*
+ * Processes a reply on the slave channel.
+ * Entered with slave_mutex held and releases it before exit.
+ * Returns true on success.
+ */
static bool
vu_process_message_reply(VuDev *dev, const VhostUserMsg *vmsg)
{
VhostUserMsg msg_reply;
+ bool result = false;
if ((vmsg->flags & VHOST_USER_NEED_REPLY_MASK) == 0) {
- return true;
+ result = true;
+ goto out;
}
if (!vu_message_read(dev, dev->slave_fd, &msg_reply)) {
- return false;
+ goto out;
}
if (msg_reply.request != vmsg->request) {
DPRINT("Received unexpected msg type. Expected %d received %d",
vmsg->request, msg_reply.request);
- return false;
+ goto out;
}
- return msg_reply.payload.u64 == 0;
+ result = msg_reply.payload.u64 == 0;
+
+out:
+ pthread_mutex_unlock(&dev->slave_mutex);
+ return result;
}
/* Kick the log_call_fd if required. */
@@ -1105,10 +1116,13 @@ bool vu_set_queue_host_notifier(VuDev *dev, VuVirtq *vq, int fd,
return false;
}
+ pthread_mutex_lock(&dev->slave_mutex);
if (!vu_message_write(dev, dev->slave_fd, &vmsg)) {
+ pthread_mutex_unlock(&dev->slave_mutex);
return false;
}
+ /* Also unlocks the slave_mutex */
return vu_process_message_reply(dev, &vmsg);
}
@@ -1628,6 +1642,7 @@ vu_deinit(VuDev *dev)
close(dev->slave_fd);
dev->slave_fd = -1;
}
+ pthread_mutex_destroy(&dev->slave_mutex);
if (dev->sock != -1) {
close(dev->sock);
@@ -1663,6 +1678,7 @@ vu_init(VuDev *dev,
dev->remove_watch = remove_watch;
dev->iface = iface;
dev->log_call_fd = -1;
+ pthread_mutex_init(&dev->slave_mutex, NULL);
dev->slave_fd = -1;
dev->max_queues = max_queues;
diff --git a/contrib/libvhost-user/libvhost-user.h b/contrib/libvhost-user/libvhost-user.h
index 46b600799b..1844b6f8d4 100644
--- a/contrib/libvhost-user/libvhost-user.h
+++ b/contrib/libvhost-user/libvhost-user.h
@@ -19,6 +19,7 @@
#include <stddef.h>
#include <sys/poll.h>
#include <linux/vhost.h>
+#include <pthread.h>
#include "standard-headers/linux/virtio_ring.h"
/* Based on qemu/hw/virtio/vhost-user.c */
@@ -355,6 +356,8 @@ struct VuDev {
VuVirtq *vq;
VuDevInflightInfo inflight_info;
int log_call_fd;
+ /* Must be held while using slave_fd */
+ pthread_mutex_t slave_mutex;
int slave_fd;
uint64_t log_size;
uint8_t *log_table;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 067/108] virtiofsd: passthrough_ll: add renameat2 support
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (65 preceding siblings ...)
2020-01-23 16:45 ` [PULL 066/108] contrib/libvhost-user: Protect slave fd with mutex Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 068/108] virtiofsd: passthrough_ll: disable readdirplus on cache=never Dr. David Alan Gilbert (git)
` (42 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 98114a3f4a..18d69abcbc 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1099,7 +1099,17 @@ static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
}
if (flags) {
+#ifndef SYS_renameat2
fuse_reply_err(req, EINVAL);
+#else
+ res = syscall(SYS_renameat2, lo_fd(req, parent), name,
+ lo_fd(req, newparent), newname, flags);
+ if (res == -1 && errno == ENOSYS) {
+ fuse_reply_err(req, EINVAL);
+ } else {
+ fuse_reply_err(req, res == -1 ? errno : 0);
+ }
+#endif
return;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 068/108] virtiofsd: passthrough_ll: disable readdirplus on cache=never
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (66 preceding siblings ...)
2020-01-23 16:45 ` [PULL 067/108] virtiofsd: passthrough_ll: add renameat2 support Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 069/108] virtiofsd: passthrough_ll: control readdirplus Dr. David Alan Gilbert (git)
` (41 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
...because the attributes sent in the READDIRPLUS reply would be discarded
anyway.
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 18d69abcbc..6480c517dc 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -478,6 +478,10 @@ static void lo_init(void *userdata, struct fuse_conn_info *conn)
fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
conn->want |= FUSE_CAP_FLOCK_LOCKS;
}
+ if (lo->cache == CACHE_NEVER) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: disabling readdirplus\n");
+ conn->want &= ~FUSE_CAP_READDIRPLUS;
+ }
}
static void lo_getattr(fuse_req_t req, fuse_ino_t ino,
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 069/108] virtiofsd: passthrough_ll: control readdirplus
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (67 preceding siblings ...)
2020-01-23 16:45 ` [PULL 068/108] virtiofsd: passthrough_ll: disable readdirplus on cache=never Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 070/108] virtiofsd: rename unref_inode() to unref_inode_lolocked() Dr. David Alan Gilbert (git)
` (40 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/helper.c | 4 ++++
tools/virtiofsd/passthrough_ll.c | 7 ++++++-
2 files changed, 10 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 6d50a46a7e..14f5d70c10 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -153,6 +153,10 @@ void fuse_cmdline_help(void)
" allowed (default: 10)\n"
" -o norace disable racy fallback\n"
" default: false\n"
+ " -o readdirplus|no_readdirplus\n"
+ " enable/disable readirplus\n"
+ " default: readdirplus except with "
+ "cache=never\n"
);
}
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 6480c517dc..8b1784ff7b 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -117,6 +117,8 @@ struct lo_data {
double timeout;
int cache;
int timeout_set;
+ int readdirplus_set;
+ int readdirplus_clear;
struct lo_inode root; /* protected by lo->mutex */
struct lo_map ino_map; /* protected by lo->mutex */
struct lo_map dirp_map; /* protected by lo->mutex */
@@ -140,6 +142,8 @@ static const struct fuse_opt lo_opts[] = {
{ "cache=auto", offsetof(struct lo_data, cache), CACHE_NORMAL },
{ "cache=always", offsetof(struct lo_data, cache), CACHE_ALWAYS },
{ "norace", offsetof(struct lo_data, norace), 1 },
+ { "readdirplus", offsetof(struct lo_data, readdirplus_set), 1 },
+ { "no_readdirplus", offsetof(struct lo_data, readdirplus_clear), 1 },
FUSE_OPT_END
};
static bool use_syslog = false;
@@ -478,7 +482,8 @@ static void lo_init(void *userdata, struct fuse_conn_info *conn)
fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
conn->want |= FUSE_CAP_FLOCK_LOCKS;
}
- if (lo->cache == CACHE_NEVER) {
+ if ((lo->cache == CACHE_NEVER && !lo->readdirplus_set) ||
+ lo->readdirplus_clear) {
fuse_log(FUSE_LOG_DEBUG, "lo_init: disabling readdirplus\n");
conn->want &= ~FUSE_CAP_READDIRPLUS;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 070/108] virtiofsd: rename unref_inode() to unref_inode_lolocked()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (68 preceding siblings ...)
2020-01-23 16:45 ` [PULL 069/108] virtiofsd: passthrough_ll: control readdirplus Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 071/108] virtiofsd: fail when parent inode isn't known in lo_do_lookup() Dr. David Alan Gilbert (git)
` (39 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 15 ++++++++-------
1 file changed, 8 insertions(+), 7 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 8b1784ff7b..de12e75a9e 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -148,8 +148,8 @@ static const struct fuse_opt lo_opts[] = {
};
static bool use_syslog = false;
static int current_log_level;
-
-static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n);
+static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
+ uint64_t n);
static struct {
pthread_mutex_t mutex;
@@ -586,7 +586,7 @@ retry:
return 0;
fail_unref:
- unref_inode(lo, p, 1);
+ unref_inode_lolocked(lo, p, 1);
fail:
if (retries) {
retries--;
@@ -624,7 +624,7 @@ fallback:
res = lo_parent_and_name(lo, inode, path, &parent);
if (res != -1) {
res = utimensat(parent->fd, path, tv, AT_SYMLINK_NOFOLLOW);
- unref_inode(lo, parent, 1);
+ unref_inode_lolocked(lo, parent, 1);
}
return res;
@@ -1027,7 +1027,7 @@ fallback:
res = lo_parent_and_name(lo, inode, path, &parent);
if (res != -1) {
res = linkat(parent->fd, path, dfd, name, 0);
- unref_inode(lo, parent, 1);
+ unref_inode_lolocked(lo, parent, 1);
}
return res;
@@ -1141,7 +1141,8 @@ static void lo_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
fuse_reply_err(req, res == -1 ? errno : 0);
}
-static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n)
+static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
+ uint64_t n)
{
if (!inode) {
return;
@@ -1181,7 +1182,7 @@ static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
(unsigned long long)ino, (unsigned long long)inode->refcount,
(unsigned long long)nlookup);
- unref_inode(lo, inode, nlookup);
+ unref_inode_lolocked(lo, inode, nlookup);
}
static void lo_forget(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 071/108] virtiofsd: fail when parent inode isn't known in lo_do_lookup()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (69 preceding siblings ...)
2020-01-23 16:45 ` [PULL 070/108] virtiofsd: rename unref_inode() to unref_inode_lolocked() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 072/108] virtiofsd: extract root inode init into setup_root() Dr. David Alan Gilbert (git)
` (38 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
The Linux file handle APIs (struct export_operations) can access inodes
that are not attached to parents because path name traversal is not
performed. Refuse if there is no parent in lo_do_lookup().
Also clean up lo_do_lookup() while we're here.
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 14 ++++++++++++--
1 file changed, 12 insertions(+), 2 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index de12e75a9e..33bfb4d1f4 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -777,6 +777,15 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
struct lo_data *lo = lo_data(req);
struct lo_inode *inode, *dir = lo_inode(req, parent);
+ /*
+ * name_to_handle_at() and open_by_handle_at() can reach here with fuse
+ * mount point in guest, but we don't have its inode info in the
+ * ino_map.
+ */
+ if (!dir) {
+ return ENOENT;
+ }
+
memset(e, 0, sizeof(*e));
e->attr_timeout = lo->timeout;
e->entry_timeout = lo->timeout;
@@ -786,7 +795,7 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
name = ".";
}
- newfd = openat(lo_fd(req, parent), name, O_PATH | O_NOFOLLOW);
+ newfd = openat(dir->fd, name, O_PATH | O_NOFOLLOW);
if (newfd == -1) {
goto out_err;
}
@@ -796,7 +805,7 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
goto out_err;
}
- inode = lo_find(lo_data(req), &e->attr);
+ inode = lo_find(lo, &e->attr);
if (inode) {
close(newfd);
newfd = -1;
@@ -812,6 +821,7 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
inode->is_symlink = S_ISLNK(e->attr.st_mode);
inode->refcount = 1;
inode->fd = newfd;
+ newfd = -1;
inode->ino = e->attr.st_ino;
inode->dev = e->attr.st_dev;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 072/108] virtiofsd: extract root inode init into setup_root()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (70 preceding siblings ...)
2020-01-23 16:45 ` [PULL 071/108] virtiofsd: fail when parent inode isn't known in lo_do_lookup() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 073/108] virtiofsd: passthrough_ll: clean up cache related options Dr. David Alan Gilbert (git)
` (37 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
Inititialize the root inode in a single place.
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
dgilbert:
with fix suggested by Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 35 +++++++++++++++++++++++---------
1 file changed, 25 insertions(+), 10 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 33bfb4d1f4..9e7191eb75 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -2351,6 +2351,30 @@ static void log_func(enum fuse_log_level level, const char *fmt, va_list ap)
}
}
+static void setup_root(struct lo_data *lo, struct lo_inode *root)
+{
+ int fd, res;
+ struct stat stat;
+
+ fd = open("/", O_PATH);
+ if (fd == -1) {
+ fuse_log(FUSE_LOG_ERR, "open(%s, O_PATH): %m\n", lo->source);
+ exit(1);
+ }
+
+ res = fstatat(fd, "", &stat, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1) {
+ fuse_log(FUSE_LOG_ERR, "fstatat(%s): %m\n", lo->source);
+ exit(1);
+ }
+
+ root->is_symlink = false;
+ root->fd = fd;
+ root->ino = stat.st_ino;
+ root->dev = stat.st_dev;
+ root->refcount = 2;
+}
+
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
@@ -2426,8 +2450,6 @@ int main(int argc, char *argv[])
if (lo.debug) {
current_log_level = FUSE_LOG_DEBUG;
}
- lo.root.refcount = 2;
-
if (lo.source) {
struct stat stat;
int res;
@@ -2446,7 +2468,6 @@ int main(int argc, char *argv[])
} else {
lo.source = "/";
}
- lo.root.is_symlink = false;
if (!lo.timeout_set) {
switch (lo.cache) {
case CACHE_NEVER:
@@ -2466,13 +2487,6 @@ int main(int argc, char *argv[])
exit(1);
}
- lo.root.fd = open(lo.source, O_PATH);
-
- if (lo.root.fd == -1) {
- fuse_log(FUSE_LOG_ERR, "open(\"%s\", O_PATH): %m\n", lo.source);
- exit(1);
- }
-
se = fuse_session_new(&args, &lo_oper, sizeof(lo_oper), &lo);
if (se == NULL) {
goto err_out1;
@@ -2495,6 +2509,7 @@ int main(int argc, char *argv[])
setup_sandbox(&lo, se, opts.syslog);
+ setup_root(&lo, &lo.root);
/* Block until ctrl+c or fusermount -u */
ret = virtio_loop(se);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 073/108] virtiofsd: passthrough_ll: clean up cache related options
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (71 preceding siblings ...)
2020-01-23 16:45 ` [PULL 072/108] virtiofsd: extract root inode init into setup_root() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 074/108] virtiofsd: passthrough_ll: use hashtable Dr. David Alan Gilbert (git)
` (36 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
- Rename "cache=never" to "cache=none" to match 9p's similar option.
- Rename CACHE_NORMAL constant to CACHE_AUTO to match the "cache=auto"
option.
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
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>
---
tools/virtiofsd/helper.c | 5 ++++-
tools/virtiofsd/passthrough_ll.c | 20 ++++++++++----------
2 files changed, 14 insertions(+), 11 deletions(-)
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 14f5d70c10..567202444a 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -145,6 +145,9 @@ void fuse_cmdline_help(void)
" --syslog log to syslog (default stderr)\n"
" -f foreground operation\n"
" --daemonize run in background\n"
+ " -o cache=<mode> cache mode. could be one of \"auto, "
+ "always, none\"\n"
+ " default: auto\n"
" -o log_level=<level> log level, default to \"info\"\n"
" level could be one of \"debug, "
"info, warn, err\"\n"
@@ -156,7 +159,7 @@ void fuse_cmdline_help(void)
" -o readdirplus|no_readdirplus\n"
" enable/disable readirplus\n"
" default: readdirplus except with "
- "cache=never\n"
+ "cache=none\n"
);
}
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 9e7191eb75..b40f2874a7 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -101,8 +101,8 @@ struct lo_cred {
};
enum {
- CACHE_NEVER,
- CACHE_NORMAL,
+ CACHE_NONE,
+ CACHE_AUTO,
CACHE_ALWAYS,
};
@@ -138,8 +138,8 @@ static const struct fuse_opt lo_opts[] = {
{ "no_xattr", offsetof(struct lo_data, xattr), 0 },
{ "timeout=%lf", offsetof(struct lo_data, timeout), 0 },
{ "timeout=", offsetof(struct lo_data, timeout_set), 1 },
- { "cache=never", offsetof(struct lo_data, cache), CACHE_NEVER },
- { "cache=auto", offsetof(struct lo_data, cache), CACHE_NORMAL },
+ { "cache=none", offsetof(struct lo_data, cache), CACHE_NONE },
+ { "cache=auto", offsetof(struct lo_data, cache), CACHE_AUTO },
{ "cache=always", offsetof(struct lo_data, cache), CACHE_ALWAYS },
{ "norace", offsetof(struct lo_data, norace), 1 },
{ "readdirplus", offsetof(struct lo_data, readdirplus_set), 1 },
@@ -482,7 +482,7 @@ static void lo_init(void *userdata, struct fuse_conn_info *conn)
fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
conn->want |= FUSE_CAP_FLOCK_LOCKS;
}
- if ((lo->cache == CACHE_NEVER && !lo->readdirplus_set) ||
+ if ((lo->cache == CACHE_NONE && !lo->readdirplus_set) ||
lo->readdirplus_clear) {
fuse_log(FUSE_LOG_DEBUG, "lo_init: disabling readdirplus\n");
conn->want &= ~FUSE_CAP_READDIRPLUS;
@@ -1493,7 +1493,7 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
fi->fh = fh;
err = lo_do_lookup(req, parent, name, &e);
}
- if (lo->cache == CACHE_NEVER) {
+ if (lo->cache == CACHE_NONE) {
fi->direct_io = 1;
} else if (lo->cache == CACHE_ALWAYS) {
fi->keep_cache = 1;
@@ -1578,7 +1578,7 @@ static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
}
fi->fh = fh;
- if (lo->cache == CACHE_NEVER) {
+ if (lo->cache == CACHE_NONE) {
fi->direct_io = 1;
} else if (lo->cache == CACHE_ALWAYS) {
fi->keep_cache = 1;
@@ -2395,7 +2395,7 @@ int main(int argc, char *argv[])
lo.root.next = lo.root.prev = &lo.root;
lo.root.fd = -1;
lo.root.fuse_ino = FUSE_ROOT_ID;
- lo.cache = CACHE_NORMAL;
+ lo.cache = CACHE_AUTO;
/*
* Set up the ino map like this:
@@ -2470,11 +2470,11 @@ int main(int argc, char *argv[])
}
if (!lo.timeout_set) {
switch (lo.cache) {
- case CACHE_NEVER:
+ case CACHE_NONE:
lo.timeout = 0.0;
break;
- case CACHE_NORMAL:
+ case CACHE_AUTO:
lo.timeout = 1.0;
break;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 074/108] virtiofsd: passthrough_ll: use hashtable
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (72 preceding siblings ...)
2020-01-23 16:45 ` [PULL 073/108] virtiofsd: passthrough_ll: clean up cache related options Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 075/108] virtiofsd: Clean up inodes on destroy Dr. David Alan Gilbert (git)
` (35 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
Improve performance of inode lookup by using a hash table.
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Liu Bo <bo.liu@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 81 ++++++++++++++++++--------------
1 file changed, 45 insertions(+), 36 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index b40f2874a7..b176a314d6 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -84,13 +84,15 @@ struct lo_map {
ssize_t freelist;
};
+struct lo_key {
+ ino_t ino;
+ dev_t dev;
+};
+
struct lo_inode {
- struct lo_inode *next; /* protected by lo->mutex */
- struct lo_inode *prev; /* protected by lo->mutex */
int fd;
bool is_symlink;
- ino_t ino;
- dev_t dev;
+ struct lo_key key;
uint64_t refcount; /* protected by lo->mutex */
fuse_ino_t fuse_ino;
};
@@ -119,7 +121,8 @@ struct lo_data {
int timeout_set;
int readdirplus_set;
int readdirplus_clear;
- struct lo_inode root; /* protected by lo->mutex */
+ struct lo_inode root;
+ GHashTable *inodes; /* protected by lo->mutex */
struct lo_map ino_map; /* protected by lo->mutex */
struct lo_map dirp_map; /* protected by lo->mutex */
struct lo_map fd_map; /* protected by lo->mutex */
@@ -573,7 +576,7 @@ retry:
}
goto fail_unref;
}
- if (stat.st_dev != inode->dev || stat.st_ino != inode->ino) {
+ if (stat.st_dev != inode->key.dev || stat.st_ino != inode->key.ino) {
if (!retries) {
fuse_log(FUSE_LOG_WARNING,
"%s: failed to match last\n", __func__);
@@ -753,19 +756,20 @@ out_err:
static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st)
{
struct lo_inode *p;
- struct lo_inode *ret = NULL;
+ struct lo_key key = {
+ .ino = st->st_ino,
+ .dev = st->st_dev,
+ };
pthread_mutex_lock(&lo->mutex);
- for (p = lo->root.next; p != &lo->root; p = p->next) {
- if (p->ino == st->st_ino && p->dev == st->st_dev) {
- assert(p->refcount > 0);
- ret = p;
- ret->refcount++;
- break;
- }
+ p = g_hash_table_lookup(lo->inodes, &key);
+ if (p) {
+ assert(p->refcount > 0);
+ p->refcount++;
}
pthread_mutex_unlock(&lo->mutex);
- return ret;
+
+ return p;
}
static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
@@ -810,8 +814,6 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
close(newfd);
newfd = -1;
} else {
- struct lo_inode *prev, *next;
-
saverr = ENOMEM;
inode = calloc(1, sizeof(struct lo_inode));
if (!inode) {
@@ -822,17 +824,12 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
inode->refcount = 1;
inode->fd = newfd;
newfd = -1;
- inode->ino = e->attr.st_ino;
- inode->dev = e->attr.st_dev;
+ inode->key.ino = e->attr.st_ino;
+ inode->key.dev = e->attr.st_dev;
pthread_mutex_lock(&lo->mutex);
inode->fuse_ino = lo_add_inode_mapping(req, inode);
- prev = &lo->root;
- next = prev->next;
- next->prev = inode;
- inode->next = next;
- inode->prev = prev;
- prev->next = inode;
+ g_hash_table_insert(lo->inodes, &inode->key, inode);
pthread_mutex_unlock(&lo->mutex);
}
e->ino = inode->fuse_ino;
@@ -1162,14 +1159,8 @@ static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
assert(inode->refcount >= n);
inode->refcount -= n;
if (!inode->refcount) {
- struct lo_inode *prev, *next;
-
- prev = inode->prev;
- next = inode->next;
- next->prev = prev;
- prev->next = next;
-
lo_map_remove(&lo->ino_map, inode->fuse_ino);
+ g_hash_table_remove(lo->inodes, &inode->key);
pthread_mutex_unlock(&lo->mutex);
close(inode->fd);
free(inode);
@@ -1369,7 +1360,7 @@ static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
/* Hide root's parent directory */
if (dinode == &lo->root && strcmp(name, "..") == 0) {
- e.attr.st_ino = lo->root.ino;
+ e.attr.st_ino = lo->root.key.ino;
e.attr.st_mode = DT_DIR << 12;
}
@@ -2370,11 +2361,26 @@ static void setup_root(struct lo_data *lo, struct lo_inode *root)
root->is_symlink = false;
root->fd = fd;
- root->ino = stat.st_ino;
- root->dev = stat.st_dev;
+ root->key.ino = stat.st_ino;
+ root->key.dev = stat.st_dev;
root->refcount = 2;
}
+static guint lo_key_hash(gconstpointer key)
+{
+ const struct lo_key *lkey = key;
+
+ return (guint)lkey->ino + (guint)lkey->dev;
+}
+
+static gboolean lo_key_equal(gconstpointer a, gconstpointer b)
+{
+ const struct lo_key *la = a;
+ const struct lo_key *lb = b;
+
+ return la->ino == lb->ino && la->dev == lb->dev;
+}
+
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
@@ -2392,7 +2398,7 @@ int main(int argc, char *argv[])
umask(0);
pthread_mutex_init(&lo.mutex, NULL);
- lo.root.next = lo.root.prev = &lo.root;
+ lo.inodes = g_hash_table_new(lo_key_hash, lo_key_equal);
lo.root.fd = -1;
lo.root.fuse_ino = FUSE_ROOT_ID;
lo.cache = CACHE_AUTO;
@@ -2522,6 +2528,9 @@ err_out2:
err_out1:
fuse_opt_free_args(&args);
+ if (lo.inodes) {
+ g_hash_table_destroy(lo.inodes);
+ }
lo_map_destroy(&lo.fd_map);
lo_map_destroy(&lo.dirp_map);
lo_map_destroy(&lo.ino_map);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 075/108] virtiofsd: Clean up inodes on destroy
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (73 preceding siblings ...)
2020-01-23 16:45 ` [PULL 074/108] virtiofsd: passthrough_ll: use hashtable Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 076/108] virtiofsd: support nanosecond resolution for file timestamp Dr. David Alan Gilbert (git)
` (34 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Clear out our inodes and fd's on a 'destroy' - so we get rid
of them if we reboot the guest.
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>
---
tools/virtiofsd/passthrough_ll.c | 26 ++++++++++++++++++++++++++
1 file changed, 26 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index b176a314d6..9ed77a17fd 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1169,6 +1169,25 @@ static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
}
}
+static int unref_all_inodes_cb(gpointer key, gpointer value, gpointer user_data)
+{
+ struct lo_inode *inode = value;
+ struct lo_data *lo = user_data;
+
+ inode->refcount = 0;
+ lo_map_remove(&lo->ino_map, inode->fuse_ino);
+ close(inode->fd);
+
+ return TRUE;
+}
+
+static void unref_all_inodes(struct lo_data *lo)
+{
+ pthread_mutex_lock(&lo->mutex);
+ g_hash_table_foreach_remove(lo->inodes, unref_all_inodes_cb, lo);
+ pthread_mutex_unlock(&lo->mutex);
+}
+
static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{
struct lo_data *lo = lo_data(req);
@@ -2035,6 +2054,12 @@ static void lo_lseek(fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
}
}
+static void lo_destroy(void *userdata)
+{
+ struct lo_data *lo = (struct lo_data *)userdata;
+ unref_all_inodes(lo);
+}
+
static struct fuse_lowlevel_ops lo_oper = {
.init = lo_init,
.lookup = lo_lookup,
@@ -2073,6 +2098,7 @@ static struct fuse_lowlevel_ops lo_oper = {
.copy_file_range = lo_copy_file_range,
#endif
.lseek = lo_lseek,
+ .destroy = lo_destroy,
};
/* Print vhost-user.json backend program capabilities */
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 076/108] virtiofsd: support nanosecond resolution for file timestamp
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (74 preceding siblings ...)
2020-01-23 16:45 ` [PULL 075/108] virtiofsd: Clean up inodes on destroy Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:45 ` [PULL 077/108] virtiofsd: fix error handling in main() Dr. David Alan Gilbert (git)
` (33 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Jiufei Xue <jiufei.xue@linux.alibaba.com>
Define HAVE_STRUCT_STAT_ST_ATIM to 1 if `st_atim' is member of `struct
stat' which means support nanosecond resolution for the file timestamp
fields.
Signed-off-by: Jiufei Xue <jiufei.xue@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
configure | 16 ++++++++++++++++
tools/virtiofsd/fuse_misc.h | 1 +
2 files changed, 17 insertions(+)
diff --git a/configure b/configure
index d91eab4d65..6ab028dd0d 100755
--- a/configure
+++ b/configure
@@ -5197,6 +5197,19 @@ if compile_prog "" "" ; then
strchrnul=yes
fi
+#########################################
+# check if we have st_atim
+
+st_atim=no
+cat > $TMPC << EOF
+#include <sys/stat.h>
+#include <stddef.h>
+int main(void) { return offsetof(struct stat, st_atim); }
+EOF
+if compile_prog "" "" ; then
+ st_atim=yes
+fi
+
##########################################
# check if trace backend exists
@@ -6895,6 +6908,9 @@ fi
if test "$strchrnul" = "yes" ; then
echo "HAVE_STRCHRNUL=y" >> $config_host_mak
fi
+if test "$st_atim" = "yes" ; then
+ echo "HAVE_STRUCT_STAT_ST_ATIM=y" >> $config_host_mak
+fi
if test "$byteswap_h" = "yes" ; then
echo "CONFIG_BYTESWAP_H=y" >> $config_host_mak
fi
diff --git a/tools/virtiofsd/fuse_misc.h b/tools/virtiofsd/fuse_misc.h
index f252baa752..5c618ce21f 100644
--- a/tools/virtiofsd/fuse_misc.h
+++ b/tools/virtiofsd/fuse_misc.h
@@ -7,6 +7,7 @@
*/
#include <pthread.h>
+#include "config-host.h"
/*
* Versioned symbols cannot be used in some cases because it
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 077/108] virtiofsd: fix error handling in main()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (75 preceding siblings ...)
2020-01-23 16:45 ` [PULL 076/108] virtiofsd: support nanosecond resolution for file timestamp Dr. David Alan Gilbert (git)
@ 2020-01-23 16:45 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 078/108] virtiofsd: cleanup allocated resource in se Dr. David Alan Gilbert (git)
` (32 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:45 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Liu Bo <bo.liu@linux.alibaba.com>
Neither fuse_parse_cmdline() nor fuse_opt_parse() goes to the right place
to do cleanup.
Signed-off-by: Liu Bo <bo.liu@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 9ed77a17fd..af050c6d97 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -2443,13 +2443,14 @@ int main(int argc, char *argv[])
lo_map_init(&lo.fd_map);
if (fuse_parse_cmdline(&args, &opts) != 0) {
- return 1;
+ goto err_out1;
}
fuse_set_log_func(log_func);
use_syslog = opts.syslog;
if (use_syslog) {
openlog("virtiofsd", LOG_PID, LOG_DAEMON);
}
+
if (opts.show_help) {
printf("usage: %s [options]\n\n", argv[0]);
fuse_cmdline_help();
@@ -2468,7 +2469,7 @@ int main(int argc, char *argv[])
}
if (fuse_opt_parse(&args, &lo, lo_opts, NULL) == -1) {
- return 1;
+ goto err_out1;
}
/*
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 078/108] virtiofsd: cleanup allocated resource in se
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (76 preceding siblings ...)
2020-01-23 16:45 ` [PULL 077/108] virtiofsd: fix error handling in main() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 079/108] virtiofsd: fix memory leak on lo.source Dr. David Alan Gilbert (git)
` (31 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Liu Bo <bo.liu@linux.alibaba.com>
This cleans up unfreed resources in se on quiting, including
se->virtio_dev, se->vu_socket_path, se->vu_socketfd.
Signed-off-by: Liu Bo <bo.liu@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 7 +++++++
tools/virtiofsd/fuse_virtio.c | 7 +++++++
tools/virtiofsd/fuse_virtio.h | 2 +-
3 files changed, 15 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 65f91dabae..440508a6ec 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2532,6 +2532,13 @@ void fuse_session_destroy(struct fuse_session *se)
if (se->fd != -1) {
close(se->fd);
}
+
+ if (se->vu_socket_path) {
+ virtio_session_close(se);
+ free(se->vu_socket_path);
+ se->vu_socket_path = NULL;
+ }
+
free(se);
}
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 7a8774a3ee..e7bd772805 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -833,3 +833,10 @@ int virtio_session_mount(struct fuse_session *se)
return 0;
}
+
+void virtio_session_close(struct fuse_session *se)
+{
+ close(se->vu_socketfd);
+ free(se->virtio_dev);
+ se->virtio_dev = NULL;
+}
diff --git a/tools/virtiofsd/fuse_virtio.h b/tools/virtiofsd/fuse_virtio.h
index cc676b9193..111684032c 100644
--- a/tools/virtiofsd/fuse_virtio.h
+++ b/tools/virtiofsd/fuse_virtio.h
@@ -19,7 +19,7 @@
struct fuse_session;
int virtio_session_mount(struct fuse_session *se);
-
+void virtio_session_close(struct fuse_session *se);
int virtio_loop(struct fuse_session *se);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 079/108] virtiofsd: fix memory leak on lo.source
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (77 preceding siblings ...)
2020-01-23 16:46 ` [PULL 078/108] virtiofsd: cleanup allocated resource in se Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 080/108] virtiofsd: add helper for lo_data cleanup Dr. David Alan Gilbert (git)
` (30 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Liu Bo <bo.liu@linux.alibaba.com>
valgrind reported that lo.source is leaked on quiting, but it was defined
as (const char*) as it may point to a const string "/".
Signed-off-by: Liu Bo <bo.liu@linux.alibaba.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index af050c6d97..056ebe8556 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -115,7 +115,7 @@ struct lo_data {
int writeback;
int flock;
int xattr;
- const char *source;
+ char *source;
double timeout;
int cache;
int timeout_set;
@@ -2497,9 +2497,8 @@ int main(int argc, char *argv[])
fuse_log(FUSE_LOG_ERR, "source is not a directory\n");
exit(1);
}
-
} else {
- lo.source = "/";
+ lo.source = strdup("/");
}
if (!lo.timeout_set) {
switch (lo.cache) {
@@ -2570,5 +2569,7 @@ err_out1:
close(lo.root.fd);
}
+ free(lo.source);
+
return ret ? 1 : 0;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 080/108] virtiofsd: add helper for lo_data cleanup
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (78 preceding siblings ...)
2020-01-23 16:46 ` [PULL 079/108] virtiofsd: fix memory leak on lo.source Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 081/108] virtiofsd: Prevent multiply running with same vhost_user_socket Dr. David Alan Gilbert (git)
` (29 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Liu Bo <bo.liu@linux.alibaba.com>
This offers an helper function for lo_data's cleanup.
Signed-off-by: Liu Bo <bo.liu@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 37 ++++++++++++++++++--------------
1 file changed, 21 insertions(+), 16 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 056ebe8556..e8dc5c7320 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -2407,6 +2407,26 @@ static gboolean lo_key_equal(gconstpointer a, gconstpointer b)
return la->ino == lb->ino && la->dev == lb->dev;
}
+static void fuse_lo_data_cleanup(struct lo_data *lo)
+{
+ if (lo->inodes) {
+ g_hash_table_destroy(lo->inodes);
+ }
+ lo_map_destroy(&lo->fd_map);
+ lo_map_destroy(&lo->dirp_map);
+ lo_map_destroy(&lo->ino_map);
+
+ if (lo->proc_self_fd >= 0) {
+ close(lo->proc_self_fd);
+ }
+
+ if (lo->root.fd >= 0) {
+ close(lo->root.fd);
+ }
+
+ free(lo->source);
+}
+
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
@@ -2554,22 +2574,7 @@ err_out2:
err_out1:
fuse_opt_free_args(&args);
- if (lo.inodes) {
- g_hash_table_destroy(lo.inodes);
- }
- lo_map_destroy(&lo.fd_map);
- lo_map_destroy(&lo.dirp_map);
- lo_map_destroy(&lo.ino_map);
-
- if (lo.proc_self_fd >= 0) {
- close(lo.proc_self_fd);
- }
-
- if (lo.root.fd >= 0) {
- close(lo.root.fd);
- }
-
- free(lo.source);
+ fuse_lo_data_cleanup(&lo);
return ret ? 1 : 0;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 081/108] virtiofsd: Prevent multiply running with same vhost_user_socket
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (79 preceding siblings ...)
2020-01-23 16:46 ` [PULL 080/108] virtiofsd: add helper for lo_data cleanup Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 082/108] virtiofsd: enable PARALLEL_DIROPS during INIT Dr. David Alan Gilbert (git)
` (28 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
virtiofsd can run multiply even if the vhost_user_socket is same path.
]# ./virtiofsd -o vhost_user_socket=/tmp/vhostqemu -o source=/tmp/share &
[1] 244965
virtio_session_mount: Waiting for vhost-user socket connection...
]# ./virtiofsd -o vhost_user_socket=/tmp/vhostqemu -o source=/tmp/share &
[2] 244966
virtio_session_mount: Waiting for vhost-user socket connection...
]#
The user will get confused about the situation and maybe the cause of the
unexpected problem. So it's better to prevent the multiple running.
Create a regular file under localstatedir directory to exclude the
vhost_user_socket. To create and lock the file, use qemu_write_pidfile()
because the API has some sanity checks and file lock.
Signed-off-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Applied fixes from Stefan's review and moved osdep include
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 1 +
tools/virtiofsd/fuse_virtio.c | 49 ++++++++++++++++++++++++++++++++-
2 files changed, 49 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 440508a6ec..aac282f278 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -18,6 +18,7 @@
#include <assert.h>
#include <errno.h>
+#include <glib.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index e7bd772805..b7948def27 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -13,11 +13,12 @@
#include "qemu/osdep.h"
#include "qemu/iov.h"
-#include "fuse_virtio.h"
+#include "qapi/error.h"
#include "fuse_i.h"
#include "standard-headers/linux/fuse.h"
#include "fuse_misc.h"
#include "fuse_opt.h"
+#include "fuse_virtio.h"
#include <assert.h>
#include <errno.h>
@@ -743,6 +744,42 @@ int virtio_loop(struct fuse_session *se)
return 0;
}
+static void strreplace(char *s, char old, char new)
+{
+ for (; *s; ++s) {
+ if (*s == old) {
+ *s = new;
+ }
+ }
+}
+
+static bool fv_socket_lock(struct fuse_session *se)
+{
+ g_autofree gchar *sk_name = NULL;
+ g_autofree gchar *pidfile = NULL;
+ g_autofree gchar *dir = NULL;
+ Error *local_err = NULL;
+
+ dir = qemu_get_local_state_pathname("run/virtiofsd");
+
+ if (g_mkdir_with_parents(dir, S_IRWXU) < 0) {
+ fuse_log(FUSE_LOG_ERR, "%s: Failed to create directory %s: %s",
+ __func__, dir, strerror(errno));
+ return false;
+ }
+
+ sk_name = g_strdup(se->vu_socket_path);
+ strreplace(sk_name, '/', '.');
+ pidfile = g_strdup_printf("%s/%s.pid", dir, sk_name);
+
+ if (!qemu_write_pidfile(pidfile, &local_err)) {
+ error_report_err(local_err);
+ return false;
+ }
+
+ return true;
+}
+
static int fv_create_listen_socket(struct fuse_session *se)
{
struct sockaddr_un un;
@@ -758,6 +795,16 @@ static int fv_create_listen_socket(struct fuse_session *se)
return -1;
}
+ if (!strlen(se->vu_socket_path)) {
+ fuse_log(FUSE_LOG_ERR, "Socket path is empty\n");
+ return -1;
+ }
+
+ /* Check the vu_socket_path is already used */
+ if (!fv_socket_lock(se)) {
+ return -1;
+ }
+
/*
* Create the Unix socket to communicate with qemu
* based on QEMU's vhost-user-bridge
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 082/108] virtiofsd: enable PARALLEL_DIROPS during INIT
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (80 preceding siblings ...)
2020-01-23 16:46 ` [PULL 081/108] virtiofsd: Prevent multiply running with same vhost_user_socket Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 083/108] virtiofsd: fix incorrect error handling in lo_do_lookup Dr. David Alan Gilbert (git)
` (27 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Liu Bo <bo.liu@linux.alibaba.com>
lookup is a RO operations, PARALLEL_DIROPS can be enabled.
Signed-off-by: Liu Bo <bo.liu@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index aac282f278..70568d22a4 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2062,6 +2062,9 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid,
if (se->conn.want & FUSE_CAP_ASYNC_READ) {
outarg.flags |= FUSE_ASYNC_READ;
}
+ if (se->conn.want & FUSE_CAP_PARALLEL_DIROPS) {
+ outarg.flags |= FUSE_PARALLEL_DIROPS;
+ }
if (se->conn.want & FUSE_CAP_POSIX_LOCKS) {
outarg.flags |= FUSE_POSIX_LOCKS;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 083/108] virtiofsd: fix incorrect error handling in lo_do_lookup
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (81 preceding siblings ...)
2020-01-23 16:46 ` [PULL 082/108] virtiofsd: enable PARALLEL_DIROPS during INIT Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 084/108] Virtiofsd: fix memory leak on fuse queueinfo Dr. David Alan Gilbert (git)
` (26 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Eric Ren <renzhen@linux.alibaba.com>
Signed-off-by: Eric Ren <renzhen@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 1 -
1 file changed, 1 deletion(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index e8dc5c7320..05b5f898db 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -814,7 +814,6 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
close(newfd);
newfd = -1;
} else {
- saverr = ENOMEM;
inode = calloc(1, sizeof(struct lo_inode));
if (!inode) {
goto out_err;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 084/108] Virtiofsd: fix memory leak on fuse queueinfo
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (82 preceding siblings ...)
2020-01-23 16:46 ` [PULL 083/108] virtiofsd: fix incorrect error handling in lo_do_lookup Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 085/108] virtiofsd: Support remote posix locks Dr. David Alan Gilbert (git)
` (25 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Liu Bo <bo.liu@linux.alibaba.com>
For fuse's queueinfo, both queueinfo array and queueinfos are allocated in
fv_queue_set_started() but not cleaned up when the daemon process quits.
This fixes the leak in proper places.
Signed-off-by: Liu Bo <bo.liu@linux.alibaba.com>
Signed-off-by: Eric Ren <renzhen@linux.alibaba.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_virtio.c | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index b7948def27..fb8d6d1379 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -625,6 +625,8 @@ static void fv_queue_cleanup_thread(struct fv_VuDev *vud, int qidx)
}
close(ourqi->kill_fd);
ourqi->kick_fd = -1;
+ free(vud->qi[qidx]);
+ vud->qi[qidx] = NULL;
}
/* Callback from libvhost-user on start or stop of a queue */
@@ -884,6 +886,12 @@ int virtio_session_mount(struct fuse_session *se)
void virtio_session_close(struct fuse_session *se)
{
close(se->vu_socketfd);
+
+ if (!se->virtio_dev) {
+ return;
+ }
+
+ free(se->virtio_dev->qi);
free(se->virtio_dev);
se->virtio_dev = NULL;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 085/108] virtiofsd: Support remote posix locks
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (83 preceding siblings ...)
2020-01-23 16:46 ` [PULL 084/108] Virtiofsd: fix memory leak on fuse queueinfo Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 086/108] virtiofsd: use fuse_lowlevel_is_virtio() in fuse_session_destroy() Dr. David Alan Gilbert (git)
` (24 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Vivek Goyal <vgoyal@redhat.com>
Doing posix locks with-in guest kernel are not sufficient if a file/dir
is being shared by multiple guests. So we need the notion of daemon doing
the locks which are visible to rest of the guests.
Given posix locks are per process, one can not call posix lock API on host,
otherwise bunch of basic posix locks properties are broken. For example,
If two processes (A and B) in guest open the file and take locks on different
sections of file, if one of the processes closes the fd, it will close
fd on virtiofsd and all posix locks on file will go away. This means if
process A closes the fd, then locks of process B will go away too.
Similar other problems exist too.
This patch set tries to emulate posix locks while using open file
description locks provided on Linux.
Daemon provides two options (-o posix_lock, -o no_posix_lock) to enable
or disable posix locking in daemon. By default it is enabled.
There are few issues though.
- GETLK() returns pid of process holding lock. As we are emulating locks
using OFD, and these locks are not per process and don't return pid
of process, so GETLK() in guest does not reuturn process pid.
- As of now only F_SETLK is supported and not F_SETLKW. We can't block
the thread in virtiofsd for arbitrary long duration as there is only
one thread serving the queue. That means unlock request will not make
it to daemon and F_SETLKW will block infinitely and bring virtio-fs
to a halt. This is a solvable problem though and will require significant
changes in virtiofsd and kernel. Left as a TODO item for now.
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/helper.c | 3 +
tools/virtiofsd/passthrough_ll.c | 189 +++++++++++++++++++++++++++++++
2 files changed, 192 insertions(+)
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 567202444a..33749bfcb7 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -156,6 +156,9 @@ void fuse_cmdline_help(void)
" allowed (default: 10)\n"
" -o norace disable racy fallback\n"
" default: false\n"
+ " -o posix_lock|no_posix_lock\n"
+ " enable/disable remote posix lock\n"
+ " default: posix_lock\n"
" -o readdirplus|no_readdirplus\n"
" enable/disable readirplus\n"
" default: readdirplus except with "
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 05b5f898db..9414935b52 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -67,6 +67,12 @@
#include "passthrough_helpers.h"
#include "seccomp.h"
+/* Keep track of inode posix locks for each owner. */
+struct lo_inode_plock {
+ uint64_t lock_owner;
+ int fd; /* fd for OFD locks */
+};
+
struct lo_map_elem {
union {
struct lo_inode *inode;
@@ -95,6 +101,8 @@ struct lo_inode {
struct lo_key key;
uint64_t refcount; /* protected by lo->mutex */
fuse_ino_t fuse_ino;
+ pthread_mutex_t plock_mutex;
+ GHashTable *posix_locks; /* protected by lo_inode->plock_mutex */
};
struct lo_cred {
@@ -114,6 +122,7 @@ struct lo_data {
int norace;
int writeback;
int flock;
+ int posix_lock;
int xattr;
char *source;
double timeout;
@@ -137,6 +146,8 @@ static const struct fuse_opt lo_opts[] = {
{ "source=%s", offsetof(struct lo_data, source), 0 },
{ "flock", offsetof(struct lo_data, flock), 1 },
{ "no_flock", offsetof(struct lo_data, flock), 0 },
+ { "posix_lock", offsetof(struct lo_data, posix_lock), 1 },
+ { "no_posix_lock", offsetof(struct lo_data, posix_lock), 0 },
{ "xattr", offsetof(struct lo_data, xattr), 1 },
{ "no_xattr", offsetof(struct lo_data, xattr), 0 },
{ "timeout=%lf", offsetof(struct lo_data, timeout), 0 },
@@ -485,6 +496,17 @@ static void lo_init(void *userdata, struct fuse_conn_info *conn)
fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
conn->want |= FUSE_CAP_FLOCK_LOCKS;
}
+
+ if (conn->capable & FUSE_CAP_POSIX_LOCKS) {
+ if (lo->posix_lock) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating posix locks\n");
+ conn->want |= FUSE_CAP_POSIX_LOCKS;
+ } else {
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: disabling posix locks\n");
+ conn->want &= ~FUSE_CAP_POSIX_LOCKS;
+ }
+ }
+
if ((lo->cache == CACHE_NONE && !lo->readdirplus_set) ||
lo->readdirplus_clear) {
fuse_log(FUSE_LOG_DEBUG, "lo_init: disabling readdirplus\n");
@@ -772,6 +794,19 @@ static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st)
return p;
}
+/* value_destroy_func for posix_locks GHashTable */
+static void posix_locks_value_destroy(gpointer data)
+{
+ struct lo_inode_plock *plock = data;
+
+ /*
+ * We had used open() for locks and had only one fd. So
+ * closing this fd should release all OFD locks.
+ */
+ close(plock->fd);
+ free(plock);
+}
+
static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
struct fuse_entry_param *e)
{
@@ -825,6 +860,9 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
newfd = -1;
inode->key.ino = e->attr.st_ino;
inode->key.dev = e->attr.st_dev;
+ pthread_mutex_init(&inode->plock_mutex, NULL);
+ inode->posix_locks = g_hash_table_new_full(
+ g_direct_hash, g_direct_equal, NULL, posix_locks_value_destroy);
pthread_mutex_lock(&lo->mutex);
inode->fuse_ino = lo_add_inode_mapping(req, inode);
@@ -1160,6 +1198,11 @@ static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
if (!inode->refcount) {
lo_map_remove(&lo->ino_map, inode->fuse_ino);
g_hash_table_remove(lo->inodes, &inode->key);
+ if (g_hash_table_size(inode->posix_locks)) {
+ fuse_log(FUSE_LOG_WARNING, "Hash table is not empty\n");
+ }
+ g_hash_table_destroy(inode->posix_locks);
+ pthread_mutex_destroy(&inode->plock_mutex);
pthread_mutex_unlock(&lo->mutex);
close(inode->fd);
free(inode);
@@ -1516,6 +1559,136 @@ out:
}
}
+/* Should be called with inode->plock_mutex held */
+static struct lo_inode_plock *lookup_create_plock_ctx(struct lo_data *lo,
+ struct lo_inode *inode,
+ uint64_t lock_owner,
+ pid_t pid, int *err)
+{
+ struct lo_inode_plock *plock;
+ char procname[64];
+ int fd;
+
+ plock =
+ g_hash_table_lookup(inode->posix_locks, GUINT_TO_POINTER(lock_owner));
+
+ if (plock) {
+ return plock;
+ }
+
+ plock = malloc(sizeof(struct lo_inode_plock));
+ if (!plock) {
+ *err = ENOMEM;
+ return NULL;
+ }
+
+ /* Open another instance of file which can be used for ofd locks. */
+ sprintf(procname, "%i", inode->fd);
+
+ /* TODO: What if file is not writable? */
+ fd = openat(lo->proc_self_fd, procname, O_RDWR);
+ if (fd == -1) {
+ *err = errno;
+ free(plock);
+ return NULL;
+ }
+
+ plock->lock_owner = lock_owner;
+ plock->fd = fd;
+ g_hash_table_insert(inode->posix_locks, GUINT_TO_POINTER(plock->lock_owner),
+ plock);
+ return plock;
+}
+
+static void lo_getlk(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
+ struct flock *lock)
+{
+ struct lo_data *lo = lo_data(req);
+ struct lo_inode *inode;
+ struct lo_inode_plock *plock;
+ int ret, saverr = 0;
+
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_getlk(ino=%" PRIu64 ", flags=%d)"
+ " owner=0x%lx, l_type=%d l_start=0x%lx"
+ " l_len=0x%lx\n",
+ ino, fi->flags, fi->lock_owner, lock->l_type, lock->l_start,
+ lock->l_len);
+
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
+ pthread_mutex_lock(&inode->plock_mutex);
+ plock =
+ lookup_create_plock_ctx(lo, inode, fi->lock_owner, lock->l_pid, &ret);
+ if (!plock) {
+ pthread_mutex_unlock(&inode->plock_mutex);
+ fuse_reply_err(req, ret);
+ return;
+ }
+
+ ret = fcntl(plock->fd, F_OFD_GETLK, lock);
+ if (ret == -1) {
+ saverr = errno;
+ }
+ pthread_mutex_unlock(&inode->plock_mutex);
+
+ if (saverr) {
+ fuse_reply_err(req, saverr);
+ } else {
+ fuse_reply_lock(req, lock);
+ }
+}
+
+static void lo_setlk(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
+ struct flock *lock, int sleep)
+{
+ struct lo_data *lo = lo_data(req);
+ struct lo_inode *inode;
+ struct lo_inode_plock *plock;
+ int ret, saverr = 0;
+
+ fuse_log(FUSE_LOG_DEBUG,
+ "lo_setlk(ino=%" PRIu64 ", flags=%d)"
+ " cmd=%d pid=%d owner=0x%lx sleep=%d l_whence=%d"
+ " l_start=0x%lx l_len=0x%lx\n",
+ ino, fi->flags, lock->l_type, lock->l_pid, fi->lock_owner, sleep,
+ lock->l_whence, lock->l_start, lock->l_len);
+
+ if (sleep) {
+ fuse_reply_err(req, EOPNOTSUPP);
+ return;
+ }
+
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
+ pthread_mutex_lock(&inode->plock_mutex);
+ plock =
+ lookup_create_plock_ctx(lo, inode, fi->lock_owner, lock->l_pid, &ret);
+
+ if (!plock) {
+ pthread_mutex_unlock(&inode->plock_mutex);
+ fuse_reply_err(req, ret);
+ return;
+ }
+
+ /* TODO: Is it alright to modify flock? */
+ lock->l_pid = 0;
+ ret = fcntl(plock->fd, F_OFD_SETLK, lock);
+ if (ret == -1) {
+ saverr = errno;
+ }
+ pthread_mutex_unlock(&inode->plock_mutex);
+ fuse_reply_err(req, saverr);
+}
+
static void lo_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync,
struct fuse_file_info *fi)
{
@@ -1617,6 +1790,19 @@ static void lo_flush(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
int res;
(void)ino;
+ struct lo_inode *inode;
+
+ inode = lo_inode(req, ino);
+ if (!inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
+ /* An fd is going away. Cleanup associated posix locks */
+ pthread_mutex_lock(&inode->plock_mutex);
+ g_hash_table_remove(inode->posix_locks, GUINT_TO_POINTER(fi->lock_owner));
+ pthread_mutex_unlock(&inode->plock_mutex);
+
res = close(dup(lo_fi_fd(req, fi)));
fuse_reply_err(req, res == -1 ? errno : 0);
}
@@ -2080,6 +2266,8 @@ static struct fuse_lowlevel_ops lo_oper = {
.releasedir = lo_releasedir,
.fsyncdir = lo_fsyncdir,
.create = lo_create,
+ .getlk = lo_getlk,
+ .setlk = lo_setlk,
.open = lo_open,
.release = lo_release,
.flush = lo_flush,
@@ -2434,6 +2622,7 @@ int main(int argc, char *argv[])
struct lo_data lo = {
.debug = 0,
.writeback = 0,
+ .posix_lock = 1,
.proc_self_fd = -1,
};
struct lo_map_elem *root_elem;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 086/108] virtiofsd: use fuse_lowlevel_is_virtio() in fuse_session_destroy()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (84 preceding siblings ...)
2020-01-23 16:46 ` [PULL 085/108] virtiofsd: Support remote posix locks Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 087/108] virtiofsd: prevent fv_queue_thread() vs virtio_loop() races Dr. David Alan Gilbert (git)
` (23 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
vu_socket_path is NULL when --fd=FDNUM was used. Use
fuse_lowlevel_is_virtio() instead.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_lowlevel.c | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 70568d22a4..dab6a31e08 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2537,12 +2537,13 @@ void fuse_session_destroy(struct fuse_session *se)
close(se->fd);
}
- if (se->vu_socket_path) {
+ if (fuse_lowlevel_is_virtio(se)) {
virtio_session_close(se);
- free(se->vu_socket_path);
- se->vu_socket_path = NULL;
}
+ free(se->vu_socket_path);
+ se->vu_socket_path = NULL;
+
free(se);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 087/108] virtiofsd: prevent fv_queue_thread() vs virtio_loop() races
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (85 preceding siblings ...)
2020-01-23 16:46 ` [PULL 086/108] virtiofsd: use fuse_lowlevel_is_virtio() in fuse_session_destroy() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 088/108] virtiofsd: make lo_release() atomic Dr. David Alan Gilbert (git)
` (22 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
We call into libvhost-user from the virtqueue handler thread and the
vhost-user message processing thread without a lock. There is nothing
protecting the virtqueue handler thread if the vhost-user message
processing thread changes the virtqueue or memory table while it is
running.
This patch introduces a read-write lock. Virtqueue handler threads are
readers. The vhost-user message processing thread is a writer. This
will allow concurrency for multiqueue in the future while protecting
against fv_queue_thread() vs virtio_loop() races.
Note that the critical sections could be made smaller but it would be
more invasive and require libvhost-user changes. Let's start simple and
improve performance later, if necessary. Another option would be an
RCU-style approach with lighter-weight primitives.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_virtio.c | 34 +++++++++++++++++++++++++++++++++-
1 file changed, 33 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index fb8d6d1379..f6242f9338 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -58,6 +58,18 @@ struct fv_VuDev {
VuDev dev;
struct fuse_session *se;
+ /*
+ * Either handle virtqueues or vhost-user protocol messages. Don't do
+ * both at the same time since that could lead to race conditions if
+ * virtqueues or memory tables change while another thread is accessing
+ * them.
+ *
+ * The assumptions are:
+ * 1. fv_queue_thread() reads/writes to virtqueues and only reads VuDev.
+ * 2. virtio_loop() reads/writes virtqueues and VuDev.
+ */
+ pthread_rwlock_t vu_dispatch_rwlock;
+
/*
* The following pair of fields are only accessed in the main
* virtio_loop
@@ -415,6 +427,8 @@ static void *fv_queue_thread(void *opaque)
qi->qidx, qi->kick_fd);
while (1) {
struct pollfd pf[2];
+ int ret;
+
pf[0].fd = qi->kick_fd;
pf[0].events = POLLIN;
pf[0].revents = 0;
@@ -461,6 +475,9 @@ static void *fv_queue_thread(void *opaque)
fuse_log(FUSE_LOG_ERR, "Eventfd_read for queue: %m\n");
break;
}
+ /* Mutual exclusion with virtio_loop() */
+ ret = pthread_rwlock_rdlock(&qi->virtio_dev->vu_dispatch_rwlock);
+ assert(ret == 0); /* there is no possible error case */
/* out is from guest, in is too guest */
unsigned int in_bytes, out_bytes;
vu_queue_get_avail_bytes(dev, q, &in_bytes, &out_bytes, ~0, ~0);
@@ -469,6 +486,7 @@ static void *fv_queue_thread(void *opaque)
"%s: Queue %d gave evalue: %zx available: in: %u out: %u\n",
__func__, qi->qidx, (size_t)evalue, in_bytes, out_bytes);
+
while (1) {
bool allocated_bufv = false;
struct fuse_bufvec bufv;
@@ -597,6 +615,8 @@ static void *fv_queue_thread(void *opaque)
free(elem);
elem = NULL;
}
+
+ pthread_rwlock_unlock(&qi->virtio_dev->vu_dispatch_rwlock);
}
out:
pthread_mutex_destroy(&ch.lock);
@@ -711,6 +731,8 @@ int virtio_loop(struct fuse_session *se)
while (!fuse_session_exited(se)) {
struct pollfd pf[1];
+ bool ok;
+ int ret;
pf[0].fd = se->vu_socketfd;
pf[0].events = POLLIN;
pf[0].revents = 0;
@@ -735,7 +757,15 @@ int virtio_loop(struct fuse_session *se)
}
assert(pf[0].revents & POLLIN);
fuse_log(FUSE_LOG_DEBUG, "%s: Got VU event\n", __func__);
- if (!vu_dispatch(&se->virtio_dev->dev)) {
+ /* Mutual exclusion with fv_queue_thread() */
+ ret = pthread_rwlock_wrlock(&se->virtio_dev->vu_dispatch_rwlock);
+ assert(ret == 0); /* there is no possible error case */
+
+ ok = vu_dispatch(&se->virtio_dev->dev);
+
+ pthread_rwlock_unlock(&se->virtio_dev->vu_dispatch_rwlock);
+
+ if (!ok) {
fuse_log(FUSE_LOG_ERR, "%s: vu_dispatch failed\n", __func__);
break;
}
@@ -877,6 +907,7 @@ int virtio_session_mount(struct fuse_session *se)
se->vu_socketfd = data_sock;
se->virtio_dev->se = se;
+ pthread_rwlock_init(&se->virtio_dev->vu_dispatch_rwlock, NULL);
vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, fv_set_watch,
fv_remove_watch, &fv_iface);
@@ -892,6 +923,7 @@ void virtio_session_close(struct fuse_session *se)
}
free(se->virtio_dev->qi);
+ pthread_rwlock_destroy(&se->virtio_dev->vu_dispatch_rwlock);
free(se->virtio_dev);
se->virtio_dev = NULL;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 088/108] virtiofsd: make lo_release() atomic
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (86 preceding siblings ...)
2020-01-23 16:46 ` [PULL 087/108] virtiofsd: prevent fv_queue_thread() vs virtio_loop() races Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 089/108] virtiofsd: prevent races with lo_dirp_put() Dr. David Alan Gilbert (git)
` (21 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Hold the lock across both lo_map_get() and lo_map_remove() to prevent
races between two FUSE_RELEASE requests. In this case I don't see a
serious bug but it's safer to do things atomically.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 12 ++++++++----
1 file changed, 8 insertions(+), 4 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 9414935b52..690edbc4c5 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1772,14 +1772,18 @@ static void lo_release(fuse_req_t req, fuse_ino_t ino,
struct fuse_file_info *fi)
{
struct lo_data *lo = lo_data(req);
- int fd;
+ struct lo_map_elem *elem;
+ int fd = -1;
(void)ino;
- fd = lo_fi_fd(req, fi);
-
pthread_mutex_lock(&lo->mutex);
- lo_map_remove(&lo->fd_map, fi->fh);
+ elem = lo_map_get(&lo->fd_map, fi->fh);
+ if (elem) {
+ fd = elem->fd;
+ elem = NULL;
+ lo_map_remove(&lo->fd_map, fi->fh);
+ }
pthread_mutex_unlock(&lo->mutex);
close(fd);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 089/108] virtiofsd: prevent races with lo_dirp_put()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (87 preceding siblings ...)
2020-01-23 16:46 ` [PULL 088/108] virtiofsd: make lo_release() atomic Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 090/108] virtiofsd: rename inode->refcount to inode->nlookup Dr. David Alan Gilbert (git)
` (20 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Introduce lo_dirp_put() so that FUSE_RELEASEDIR does not cause
use-after-free races with other threads that are accessing lo_dirp.
Also make lo_releasedir() atomic to prevent FUSE_RELEASEDIR racing with
itself. This prevents double-frees.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 41 +++++++++++++++++++++++++++-----
1 file changed, 35 insertions(+), 6 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 690edbc4c5..2d703b57e5 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1284,11 +1284,28 @@ static void lo_readlink(fuse_req_t req, fuse_ino_t ino)
}
struct lo_dirp {
+ gint refcount;
DIR *dp;
struct dirent *entry;
off_t offset;
};
+static void lo_dirp_put(struct lo_dirp **dp)
+{
+ struct lo_dirp *d = *dp;
+
+ if (!d) {
+ return;
+ }
+ *dp = NULL;
+
+ if (g_atomic_int_dec_and_test(&d->refcount)) {
+ closedir(d->dp);
+ free(d);
+ }
+}
+
+/* Call lo_dirp_put() on the return value when no longer needed */
static struct lo_dirp *lo_dirp(fuse_req_t req, struct fuse_file_info *fi)
{
struct lo_data *lo = lo_data(req);
@@ -1296,6 +1313,9 @@ static struct lo_dirp *lo_dirp(fuse_req_t req, struct fuse_file_info *fi)
pthread_mutex_lock(&lo->mutex);
elem = lo_map_get(&lo->dirp_map, fi->fh);
+ if (elem) {
+ g_atomic_int_inc(&elem->dirp->refcount);
+ }
pthread_mutex_unlock(&lo->mutex);
if (!elem) {
return NULL;
@@ -1331,6 +1351,7 @@ static void lo_opendir(fuse_req_t req, fuse_ino_t ino,
d->offset = 0;
d->entry = NULL;
+ g_atomic_int_set(&d->refcount, 1); /* paired with lo_releasedir() */
pthread_mutex_lock(&lo->mutex);
fh = lo_add_dirp_mapping(req, d);
pthread_mutex_unlock(&lo->mutex);
@@ -1364,7 +1385,7 @@ static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
off_t offset, struct fuse_file_info *fi, int plus)
{
struct lo_data *lo = lo_data(req);
- struct lo_dirp *d;
+ struct lo_dirp *d = NULL;
struct lo_inode *dinode;
char *buf = NULL;
char *p;
@@ -1454,6 +1475,8 @@ static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
err = 0;
error:
+ lo_dirp_put(&d);
+
/*
* If there's an error, we can only signal it if we haven't stored
* any entries yet - otherwise we'd end up with wrong lookup
@@ -1484,22 +1507,25 @@ static void lo_releasedir(fuse_req_t req, fuse_ino_t ino,
struct fuse_file_info *fi)
{
struct lo_data *lo = lo_data(req);
+ struct lo_map_elem *elem;
struct lo_dirp *d;
(void)ino;
- d = lo_dirp(req, fi);
- if (!d) {
+ pthread_mutex_lock(&lo->mutex);
+ elem = lo_map_get(&lo->dirp_map, fi->fh);
+ if (!elem) {
+ pthread_mutex_unlock(&lo->mutex);
fuse_reply_err(req, EBADF);
return;
}
- pthread_mutex_lock(&lo->mutex);
+ d = elem->dirp;
lo_map_remove(&lo->dirp_map, fi->fh);
pthread_mutex_unlock(&lo->mutex);
- closedir(d->dp);
- free(d);
+ lo_dirp_put(&d); /* paired with lo_opendir() */
+
fuse_reply_err(req, 0);
}
@@ -1710,6 +1736,9 @@ static void lo_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync,
} else {
res = fsync(fd);
}
+
+ lo_dirp_put(&d);
+
fuse_reply_err(req, res == -1 ? errno : 0);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 090/108] virtiofsd: rename inode->refcount to inode->nlookup
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (88 preceding siblings ...)
2020-01-23 16:46 ` [PULL 089/108] virtiofsd: prevent races with lo_dirp_put() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 091/108] libvhost-user: Fix some memtable remap cases Dr. David Alan Gilbert (git)
` (19 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
This reference counter plays a specific role in the FUSE protocol. It's
not a generic object reference counter and the FUSE kernel code calls it
"nlookup".
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 37 +++++++++++++++++++++-----------
1 file changed, 25 insertions(+), 12 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 2d703b57e5..c819b5f782 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -99,7 +99,20 @@ struct lo_inode {
int fd;
bool is_symlink;
struct lo_key key;
- uint64_t refcount; /* protected by lo->mutex */
+
+ /*
+ * This counter keeps the inode alive during the FUSE session.
+ * Incremented when the FUSE inode number is sent in a reply
+ * (FUSE_LOOKUP, FUSE_READDIRPLUS, etc). Decremented when an inode is
+ * released by requests like FUSE_FORGET, FUSE_RMDIR, FUSE_RENAME, etc.
+ *
+ * Note that this value is untrusted because the client can manipulate
+ * it arbitrarily using FUSE_FORGET requests.
+ *
+ * Protected by lo->mutex.
+ */
+ uint64_t nlookup;
+
fuse_ino_t fuse_ino;
pthread_mutex_t plock_mutex;
GHashTable *posix_locks; /* protected by lo_inode->plock_mutex */
@@ -568,7 +581,7 @@ retry:
if (last == path) {
p = &lo->root;
pthread_mutex_lock(&lo->mutex);
- p->refcount++;
+ p->nlookup++;
pthread_mutex_unlock(&lo->mutex);
} else {
*last = '\0';
@@ -786,8 +799,8 @@ static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st)
pthread_mutex_lock(&lo->mutex);
p = g_hash_table_lookup(lo->inodes, &key);
if (p) {
- assert(p->refcount > 0);
- p->refcount++;
+ assert(p->nlookup > 0);
+ p->nlookup++;
}
pthread_mutex_unlock(&lo->mutex);
@@ -855,7 +868,7 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
}
inode->is_symlink = S_ISLNK(e->attr.st_mode);
- inode->refcount = 1;
+ inode->nlookup = 1;
inode->fd = newfd;
newfd = -1;
inode->key.ino = e->attr.st_ino;
@@ -1112,7 +1125,7 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
}
pthread_mutex_lock(&lo->mutex);
- inode->refcount++;
+ inode->nlookup++;
pthread_mutex_unlock(&lo->mutex);
e.ino = inode->fuse_ino;
@@ -1193,9 +1206,9 @@ static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
}
pthread_mutex_lock(&lo->mutex);
- assert(inode->refcount >= n);
- inode->refcount -= n;
- if (!inode->refcount) {
+ assert(inode->nlookup >= n);
+ inode->nlookup -= n;
+ if (!inode->nlookup) {
lo_map_remove(&lo->ino_map, inode->fuse_ino);
g_hash_table_remove(lo->inodes, &inode->key);
if (g_hash_table_size(inode->posix_locks)) {
@@ -1216,7 +1229,7 @@ static int unref_all_inodes_cb(gpointer key, gpointer value, gpointer user_data)
struct lo_inode *inode = value;
struct lo_data *lo = user_data;
- inode->refcount = 0;
+ inode->nlookup = 0;
lo_map_remove(&lo->ino_map, inode->fuse_ino);
close(inode->fd);
@@ -1241,7 +1254,7 @@ static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
}
fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",
- (unsigned long long)ino, (unsigned long long)inode->refcount,
+ (unsigned long long)ino, (unsigned long long)inode->nlookup,
(unsigned long long)nlookup);
unref_inode_lolocked(lo, inode, nlookup);
@@ -2609,7 +2622,7 @@ static void setup_root(struct lo_data *lo, struct lo_inode *root)
root->fd = fd;
root->key.ino = stat.st_ino;
root->key.dev = stat.st_dev;
- root->refcount = 2;
+ root->nlookup = 2;
}
static guint lo_key_hash(gconstpointer key)
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 091/108] libvhost-user: Fix some memtable remap cases
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (89 preceding siblings ...)
2020-01-23 16:46 ` [PULL 090/108] virtiofsd: rename inode->refcount to inode->nlookup Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 092/108] virtiofsd: passthrough_ll: fix refcounting on remove/rename Dr. David Alan Gilbert (git)
` (18 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
If a new setmemtable command comes in once the vhost threads are
running, it will remap the guests address space and the threads
will now be looking in the wrong place.
Fortunately we're running this command under lock, so we can
update the queue mappings so that threads will look in the new-right
place.
Note: This doesn't fix things that the threads might be doing
without a lock (e.g. a readv/writev!) That's for another time.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
contrib/libvhost-user/libvhost-user.c | 33 ++++++++++++++++++++-------
contrib/libvhost-user/libvhost-user.h | 3 +++
2 files changed, 28 insertions(+), 8 deletions(-)
diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
index 63e41062a4..b89bf18501 100644
--- a/contrib/libvhost-user/libvhost-user.c
+++ b/contrib/libvhost-user/libvhost-user.c
@@ -564,6 +564,21 @@ vu_reset_device_exec(VuDev *dev, VhostUserMsg *vmsg)
return false;
}
+static bool
+map_ring(VuDev *dev, VuVirtq *vq)
+{
+ vq->vring.desc = qva_to_va(dev, vq->vra.desc_user_addr);
+ vq->vring.used = qva_to_va(dev, vq->vra.used_user_addr);
+ vq->vring.avail = qva_to_va(dev, vq->vra.avail_user_addr);
+
+ DPRINT("Setting virtq addresses:\n");
+ DPRINT(" vring_desc at %p\n", vq->vring.desc);
+ DPRINT(" vring_used at %p\n", vq->vring.used);
+ DPRINT(" vring_avail at %p\n", vq->vring.avail);
+
+ return !(vq->vring.desc && vq->vring.used && vq->vring.avail);
+}
+
static bool
vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg *vmsg)
{
@@ -767,6 +782,14 @@ vu_set_mem_table_exec(VuDev *dev, VhostUserMsg *vmsg)
close(vmsg->fds[i]);
}
+ for (i = 0; i < dev->max_queues; i++) {
+ if (dev->vq[i].vring.desc) {
+ if (map_ring(dev, &dev->vq[i])) {
+ vu_panic(dev, "remaping queue %d during setmemtable", i);
+ }
+ }
+ }
+
return false;
}
@@ -853,18 +876,12 @@ vu_set_vring_addr_exec(VuDev *dev, VhostUserMsg *vmsg)
DPRINT(" avail_user_addr: 0x%016" PRIx64 "\n", vra->avail_user_addr);
DPRINT(" log_guest_addr: 0x%016" PRIx64 "\n", vra->log_guest_addr);
+ vq->vra = *vra;
vq->vring.flags = vra->flags;
- vq->vring.desc = qva_to_va(dev, vra->desc_user_addr);
- vq->vring.used = qva_to_va(dev, vra->used_user_addr);
- vq->vring.avail = qva_to_va(dev, vra->avail_user_addr);
vq->vring.log_guest_addr = vra->log_guest_addr;
- DPRINT("Setting virtq addresses:\n");
- DPRINT(" vring_desc at %p\n", vq->vring.desc);
- DPRINT(" vring_used at %p\n", vq->vring.used);
- DPRINT(" vring_avail at %p\n", vq->vring.avail);
- if (!(vq->vring.desc && vq->vring.used && vq->vring.avail)) {
+ if (map_ring(dev, vq)) {
vu_panic(dev, "Invalid vring_addr message");
return false;
}
diff --git a/contrib/libvhost-user/libvhost-user.h b/contrib/libvhost-user/libvhost-user.h
index 1844b6f8d4..5cb7708559 100644
--- a/contrib/libvhost-user/libvhost-user.h
+++ b/contrib/libvhost-user/libvhost-user.h
@@ -327,6 +327,9 @@ typedef struct VuVirtq {
int err_fd;
unsigned int enable;
bool started;
+
+ /* Guest addresses of our ring */
+ struct vhost_vring_addr vra;
} VuVirtq;
enum VuWatchCondtion {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 092/108] virtiofsd: passthrough_ll: fix refcounting on remove/rename
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (90 preceding siblings ...)
2020-01-23 16:46 ` [PULL 091/108] libvhost-user: Fix some memtable remap cases Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 093/108] virtiofsd: introduce inode refcount to prevent use-after-free Dr. David Alan Gilbert (git)
` (17 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 50 +++++++++++++++++++++++++++++++-
1 file changed, 49 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index c819b5f782..e3a6d6b611 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1140,17 +1140,42 @@ out_err:
fuse_reply_err(req, saverr);
}
+static struct lo_inode *lookup_name(fuse_req_t req, fuse_ino_t parent,
+ const char *name)
+{
+ int res;
+ struct stat attr;
+
+ res = fstatat(lo_fd(req, parent), name, &attr,
+ AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
+ if (res == -1) {
+ return NULL;
+ }
+
+ return lo_find(lo_data(req), &attr);
+}
+
static void lo_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
{
int res;
+ struct lo_inode *inode;
+ struct lo_data *lo = lo_data(req);
+
if (!is_safe_path_component(name)) {
fuse_reply_err(req, EINVAL);
return;
}
+ inode = lookup_name(req, parent, name);
+ if (!inode) {
+ fuse_reply_err(req, EIO);
+ return;
+ }
+
res = unlinkat(lo_fd(req, parent), name, AT_REMOVEDIR);
fuse_reply_err(req, res == -1 ? errno : 0);
+ unref_inode_lolocked(lo, inode, 1);
}
static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
@@ -1158,12 +1183,23 @@ static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
unsigned int flags)
{
int res;
+ struct lo_inode *oldinode;
+ struct lo_inode *newinode;
+ struct lo_data *lo = lo_data(req);
if (!is_safe_path_component(name) || !is_safe_path_component(newname)) {
fuse_reply_err(req, EINVAL);
return;
}
+ oldinode = lookup_name(req, parent, name);
+ newinode = lookup_name(req, newparent, newname);
+
+ if (!oldinode) {
+ fuse_reply_err(req, EIO);
+ goto out;
+ }
+
if (flags) {
#ifndef SYS_renameat2
fuse_reply_err(req, EINVAL);
@@ -1176,26 +1212,38 @@ static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
fuse_reply_err(req, res == -1 ? errno : 0);
}
#endif
- return;
+ goto out;
}
res = renameat(lo_fd(req, parent), name, lo_fd(req, newparent), newname);
fuse_reply_err(req, res == -1 ? errno : 0);
+out:
+ unref_inode_lolocked(lo, oldinode, 1);
+ unref_inode_lolocked(lo, newinode, 1);
}
static void lo_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
{
int res;
+ struct lo_inode *inode;
+ struct lo_data *lo = lo_data(req);
if (!is_safe_path_component(name)) {
fuse_reply_err(req, EINVAL);
return;
}
+ inode = lookup_name(req, parent, name);
+ if (!inode) {
+ fuse_reply_err(req, EIO);
+ return;
+ }
+
res = unlinkat(lo_fd(req, parent), name, 0);
fuse_reply_err(req, res == -1 ? errno : 0);
+ unref_inode_lolocked(lo, inode, 1);
}
static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 093/108] virtiofsd: introduce inode refcount to prevent use-after-free
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (91 preceding siblings ...)
2020-01-23 16:46 ` [PULL 092/108] virtiofsd: passthrough_ll: fix refcounting on remove/rename Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 094/108] virtiofsd: do not always set FUSE_FLOCK_LOCKS Dr. David Alan Gilbert (git)
` (16 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
If thread A is using an inode it must not be deleted by thread B when
processing a FUSE_FORGET request.
The FUSE protocol itself already has a counter called nlookup that is
used in FUSE_FORGET messages. We cannot trust this counter since the
untrusted client can manipulate it via FUSE_FORGET messages.
Introduce a new refcount to keep inodes alive for the required lifespan.
lo_inode_put() must be called to release a reference. FUSE's nlookup
counter holds exactly one reference so that the inode stays alive as
long as the client still wants to remember it.
Note that the lo_inode->is_symlink field is moved to avoid creating a
hole in the struct due to struct field alignment.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: Sergio Lopez <slp@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 169 ++++++++++++++++++++++++++-----
1 file changed, 146 insertions(+), 23 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index e3a6d6b611..ab1613586e 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -97,7 +97,13 @@ struct lo_key {
struct lo_inode {
int fd;
- bool is_symlink;
+
+ /*
+ * Atomic reference count for this object. The nlookup field holds a
+ * reference and release it when nlookup reaches 0.
+ */
+ gint refcount;
+
struct lo_key key;
/*
@@ -116,6 +122,8 @@ struct lo_inode {
fuse_ino_t fuse_ino;
pthread_mutex_t plock_mutex;
GHashTable *posix_locks; /* protected by lo_inode->plock_mutex */
+
+ bool is_symlink;
};
struct lo_cred {
@@ -471,6 +479,23 @@ static ssize_t lo_add_inode_mapping(fuse_req_t req, struct lo_inode *inode)
return elem - lo_data(req)->ino_map.elems;
}
+static void lo_inode_put(struct lo_data *lo, struct lo_inode **inodep)
+{
+ struct lo_inode *inode = *inodep;
+
+ if (!inode) {
+ return;
+ }
+
+ *inodep = NULL;
+
+ if (g_atomic_int_dec_and_test(&inode->refcount)) {
+ close(inode->fd);
+ free(inode);
+ }
+}
+
+/* Caller must release refcount using lo_inode_put() */
static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino)
{
struct lo_data *lo = lo_data(req);
@@ -478,6 +503,9 @@ static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino)
pthread_mutex_lock(&lo->mutex);
elem = lo_map_get(&lo->ino_map, ino);
+ if (elem) {
+ g_atomic_int_inc(&elem->inode->refcount);
+ }
pthread_mutex_unlock(&lo->mutex);
if (!elem) {
@@ -487,10 +515,23 @@ static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino)
return elem->inode;
}
+/*
+ * TODO Remove this helper and force callers to hold an inode refcount until
+ * they are done with the fd. This will be done in a later patch to make
+ * review easier.
+ */
static int lo_fd(fuse_req_t req, fuse_ino_t ino)
{
struct lo_inode *inode = lo_inode(req, ino);
- return inode ? inode->fd : -1;
+ int fd;
+
+ if (!inode) {
+ return -1;
+ }
+
+ fd = inode->fd;
+ lo_inode_put(lo_data(req), &inode);
+ return fd;
}
static void lo_init(void *userdata, struct fuse_conn_info *conn)
@@ -545,6 +586,10 @@ static void lo_getattr(fuse_req_t req, fuse_ino_t ino,
fuse_reply_attr(req, &buf, lo->timeout);
}
+/*
+ * Increments parent->nlookup and caller must release refcount using
+ * lo_inode_put(&parent).
+ */
static int lo_parent_and_name(struct lo_data *lo, struct lo_inode *inode,
char path[PATH_MAX], struct lo_inode **parent)
{
@@ -582,6 +627,7 @@ retry:
p = &lo->root;
pthread_mutex_lock(&lo->mutex);
p->nlookup++;
+ g_atomic_int_inc(&p->refcount);
pthread_mutex_unlock(&lo->mutex);
} else {
*last = '\0';
@@ -625,6 +671,7 @@ retry:
fail_unref:
unref_inode_lolocked(lo, p, 1);
+ lo_inode_put(lo, &p);
fail:
if (retries) {
retries--;
@@ -663,6 +710,7 @@ fallback:
if (res != -1) {
res = utimensat(parent->fd, path, tv, AT_SYMLINK_NOFOLLOW);
unref_inode_lolocked(lo, parent, 1);
+ lo_inode_put(lo, &parent);
}
return res;
@@ -780,11 +828,13 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
goto out_err;
}
}
+ lo_inode_put(lo, &inode);
return lo_getattr(req, ino, fi);
out_err:
saverr = errno;
+ lo_inode_put(lo, &inode);
fuse_reply_err(req, saverr);
}
@@ -801,6 +851,7 @@ static struct lo_inode *lo_find(struct lo_data *lo, struct stat *st)
if (p) {
assert(p->nlookup > 0);
p->nlookup++;
+ g_atomic_int_inc(&p->refcount);
}
pthread_mutex_unlock(&lo->mutex);
@@ -820,6 +871,10 @@ static void posix_locks_value_destroy(gpointer data)
free(plock);
}
+/*
+ * Increments nlookup and caller must release refcount using
+ * lo_inode_put(&parent).
+ */
static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
struct fuse_entry_param *e)
{
@@ -827,7 +882,8 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
int res;
int saverr;
struct lo_data *lo = lo_data(req);
- struct lo_inode *inode, *dir = lo_inode(req, parent);
+ struct lo_inode *inode = NULL;
+ struct lo_inode *dir = lo_inode(req, parent);
/*
* name_to_handle_at() and open_by_handle_at() can reach here with fuse
@@ -868,6 +924,13 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
}
inode->is_symlink = S_ISLNK(e->attr.st_mode);
+
+ /*
+ * One for the caller and one for nlookup (released in
+ * unref_inode_lolocked())
+ */
+ g_atomic_int_set(&inode->refcount, 2);
+
inode->nlookup = 1;
inode->fd = newfd;
newfd = -1;
@@ -883,6 +946,8 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
pthread_mutex_unlock(&lo->mutex);
}
e->ino = inode->fuse_ino;
+ lo_inode_put(lo, &inode);
+ lo_inode_put(lo, &dir);
fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n", (unsigned long long)parent,
name, (unsigned long long)e->ino);
@@ -894,6 +959,8 @@ out_err:
if (newfd != -1) {
close(newfd);
}
+ lo_inode_put(lo, &inode);
+ lo_inode_put(lo, &dir);
return saverr;
}
@@ -991,6 +1058,7 @@ static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
{
int res;
int saverr;
+ struct lo_data *lo = lo_data(req);
struct lo_inode *dir;
struct fuse_entry_param e;
struct lo_cred old = {};
@@ -1032,9 +1100,11 @@ static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
name, (unsigned long long)e.ino);
fuse_reply_entry(req, &e);
+ lo_inode_put(lo, &dir);
return;
out:
+ lo_inode_put(lo, &dir);
fuse_reply_err(req, saverr);
}
@@ -1085,6 +1155,7 @@ fallback:
if (res != -1) {
res = linkat(parent->fd, path, dfd, name, 0);
unref_inode_lolocked(lo, parent, 1);
+ lo_inode_put(lo, &parent);
}
return res;
@@ -1095,6 +1166,7 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
{
int res;
struct lo_data *lo = lo_data(req);
+ struct lo_inode *parent_inode;
struct lo_inode *inode;
struct fuse_entry_param e;
int saverr;
@@ -1104,17 +1176,18 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
return;
}
+ parent_inode = lo_inode(req, parent);
inode = lo_inode(req, ino);
- if (!inode) {
- fuse_reply_err(req, EBADF);
- return;
+ if (!parent_inode || !inode) {
+ errno = EBADF;
+ goto out_err;
}
memset(&e, 0, sizeof(struct fuse_entry_param));
e.attr_timeout = lo->timeout;
e.entry_timeout = lo->timeout;
- res = linkat_empty_nofollow(lo, inode, lo_fd(req, parent), name);
+ res = linkat_empty_nofollow(lo, inode, parent_inode->fd, name);
if (res == -1) {
goto out_err;
}
@@ -1133,13 +1206,18 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
name, (unsigned long long)e.ino);
fuse_reply_entry(req, &e);
+ lo_inode_put(lo, &parent_inode);
+ lo_inode_put(lo, &inode);
return;
out_err:
saverr = errno;
+ lo_inode_put(lo, &parent_inode);
+ lo_inode_put(lo, &inode);
fuse_reply_err(req, saverr);
}
+/* Increments nlookup and caller must release refcount using lo_inode_put() */
static struct lo_inode *lookup_name(fuse_req_t req, fuse_ino_t parent,
const char *name)
{
@@ -1176,6 +1254,7 @@ static void lo_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
fuse_reply_err(req, res == -1 ? errno : 0);
unref_inode_lolocked(lo, inode, 1);
+ lo_inode_put(lo, &inode);
}
static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
@@ -1183,8 +1262,10 @@ static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
unsigned int flags)
{
int res;
- struct lo_inode *oldinode;
- struct lo_inode *newinode;
+ struct lo_inode *parent_inode;
+ struct lo_inode *newparent_inode;
+ struct lo_inode *oldinode = NULL;
+ struct lo_inode *newinode = NULL;
struct lo_data *lo = lo_data(req);
if (!is_safe_path_component(name) || !is_safe_path_component(newname)) {
@@ -1192,6 +1273,13 @@ static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
return;
}
+ parent_inode = lo_inode(req, parent);
+ newparent_inode = lo_inode(req, newparent);
+ if (!parent_inode || !newparent_inode) {
+ fuse_reply_err(req, EBADF);
+ goto out;
+ }
+
oldinode = lookup_name(req, parent, name);
newinode = lookup_name(req, newparent, newname);
@@ -1204,8 +1292,8 @@ static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
#ifndef SYS_renameat2
fuse_reply_err(req, EINVAL);
#else
- res = syscall(SYS_renameat2, lo_fd(req, parent), name,
- lo_fd(req, newparent), newname, flags);
+ res = syscall(SYS_renameat2, parent_inode->fd, name,
+ newparent_inode->fd, newname, flags);
if (res == -1 && errno == ENOSYS) {
fuse_reply_err(req, EINVAL);
} else {
@@ -1215,12 +1303,16 @@ static void lo_rename(fuse_req_t req, fuse_ino_t parent, const char *name,
goto out;
}
- res = renameat(lo_fd(req, parent), name, lo_fd(req, newparent), newname);
+ res = renameat(parent_inode->fd, name, newparent_inode->fd, newname);
fuse_reply_err(req, res == -1 ? errno : 0);
out:
unref_inode_lolocked(lo, oldinode, 1);
unref_inode_lolocked(lo, newinode, 1);
+ lo_inode_put(lo, &oldinode);
+ lo_inode_put(lo, &newinode);
+ lo_inode_put(lo, &parent_inode);
+ lo_inode_put(lo, &newparent_inode);
}
static void lo_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
@@ -1244,6 +1336,7 @@ static void lo_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
fuse_reply_err(req, res == -1 ? errno : 0);
unref_inode_lolocked(lo, inode, 1);
+ lo_inode_put(lo, &inode);
}
static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
@@ -1265,8 +1358,9 @@ static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
g_hash_table_destroy(inode->posix_locks);
pthread_mutex_destroy(&inode->plock_mutex);
pthread_mutex_unlock(&lo->mutex);
- close(inode->fd);
- free(inode);
+
+ /* Drop our refcount from lo_do_lookup() */
+ lo_inode_put(lo, &inode);
} else {
pthread_mutex_unlock(&lo->mutex);
}
@@ -1280,6 +1374,7 @@ static int unref_all_inodes_cb(gpointer key, gpointer value, gpointer user_data)
inode->nlookup = 0;
lo_map_remove(&lo->ino_map, inode->fuse_ino);
close(inode->fd);
+ lo_inode_put(lo, &inode); /* Drop our refcount from lo_do_lookup() */
return TRUE;
}
@@ -1306,6 +1401,7 @@ static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
(unsigned long long)nlookup);
unref_inode_lolocked(lo, inode, nlookup);
+ lo_inode_put(lo, &inode);
}
static void lo_forget(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
@@ -1537,6 +1633,7 @@ static void lo_do_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
err = 0;
error:
lo_dirp_put(&d);
+ lo_inode_put(lo, &dinode);
/*
* If there's an error, we can only signal it if we haven't stored
@@ -1595,6 +1692,7 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
{
int fd;
struct lo_data *lo = lo_data(req);
+ struct lo_inode *parent_inode;
struct fuse_entry_param e;
int err;
struct lo_cred old = {};
@@ -1607,12 +1705,18 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
return;
}
+ parent_inode = lo_inode(req, parent);
+ if (!parent_inode) {
+ fuse_reply_err(req, EBADF);
+ return;
+ }
+
err = lo_change_cred(req, &old);
if (err) {
goto out;
}
- fd = openat(lo_fd(req, parent), name, (fi->flags | O_CREAT) & ~O_NOFOLLOW,
+ fd = openat(parent_inode->fd, name, (fi->flags | O_CREAT) & ~O_NOFOLLOW,
mode);
err = fd == -1 ? errno : 0;
lo_restore_cred(&old);
@@ -1625,8 +1729,8 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
pthread_mutex_unlock(&lo->mutex);
if (fh == -1) {
close(fd);
- fuse_reply_err(req, ENOMEM);
- return;
+ err = ENOMEM;
+ goto out;
}
fi->fh = fh;
@@ -1639,6 +1743,8 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
}
out:
+ lo_inode_put(lo, &parent_inode);
+
if (err) {
fuse_reply_err(req, err);
} else {
@@ -1712,16 +1818,18 @@ static void lo_getlk(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
plock =
lookup_create_plock_ctx(lo, inode, fi->lock_owner, lock->l_pid, &ret);
if (!plock) {
- pthread_mutex_unlock(&inode->plock_mutex);
- fuse_reply_err(req, ret);
- return;
+ saverr = ret;
+ goto out;
}
ret = fcntl(plock->fd, F_OFD_GETLK, lock);
if (ret == -1) {
saverr = errno;
}
+
+out:
pthread_mutex_unlock(&inode->plock_mutex);
+ lo_inode_put(lo, &inode);
if (saverr) {
fuse_reply_err(req, saverr);
@@ -1761,9 +1869,8 @@ static void lo_setlk(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
lookup_create_plock_ctx(lo, inode, fi->lock_owner, lock->l_pid, &ret);
if (!plock) {
- pthread_mutex_unlock(&inode->plock_mutex);
- fuse_reply_err(req, ret);
- return;
+ saverr = ret;
+ goto out;
}
/* TODO: Is it alright to modify flock? */
@@ -1772,7 +1879,11 @@ static void lo_setlk(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,
if (ret == -1) {
saverr = errno;
}
+
+out:
pthread_mutex_unlock(&inode->plock_mutex);
+ lo_inode_put(lo, &inode);
+
fuse_reply_err(req, saverr);
}
@@ -1898,6 +2009,7 @@ static void lo_flush(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
pthread_mutex_unlock(&inode->plock_mutex);
res = close(dup(lo_fi_fd(req, fi)));
+ lo_inode_put(lo_data(req), &inode);
fuse_reply_err(req, res == -1 ? errno : 0);
}
@@ -2115,11 +2227,14 @@ out_free:
if (fd >= 0) {
close(fd);
}
+
+ lo_inode_put(lo, &inode);
return;
out_err:
saverr = errno;
out:
+ lo_inode_put(lo, &inode);
fuse_reply_err(req, saverr);
goto out_free;
}
@@ -2190,11 +2305,14 @@ out_free:
if (fd >= 0) {
close(fd);
}
+
+ lo_inode_put(lo, &inode);
return;
out_err:
saverr = errno;
out:
+ lo_inode_put(lo, &inode);
fuse_reply_err(req, saverr);
goto out_free;
}
@@ -2243,6 +2361,8 @@ out:
if (fd >= 0) {
close(fd);
}
+
+ lo_inode_put(lo, &inode);
fuse_reply_err(req, saverr);
}
@@ -2289,6 +2409,8 @@ out:
if (fd >= 0) {
close(fd);
}
+
+ lo_inode_put(lo, &inode);
fuse_reply_err(req, saverr);
}
@@ -2671,6 +2793,7 @@ static void setup_root(struct lo_data *lo, struct lo_inode *root)
root->key.ino = stat.st_ino;
root->key.dev = stat.st_dev;
root->nlookup = 2;
+ g_atomic_int_set(&root->refcount, 2);
}
static guint lo_key_hash(gconstpointer key)
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 094/108] virtiofsd: do not always set FUSE_FLOCK_LOCKS
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (92 preceding siblings ...)
2020-01-23 16:46 ` [PULL 093/108] virtiofsd: introduce inode refcount to prevent use-after-free Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 095/108] virtiofsd: convert more fprintf and perror to use fuse log infra Dr. David Alan Gilbert (git)
` (15 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Peng Tao <tao.peng@linux.alibaba.com>
Right now we always enable it regardless of given commandlines.
Fix it by setting the flag relying on the lo->flock bit.
Signed-off-by: Peng Tao <tao.peng@linux.alibaba.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: Sergio Lopez <slp@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 11 ++++++++---
1 file changed, 8 insertions(+), 3 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index ab1613586e..ccbbec18b0 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -546,9 +546,14 @@ static void lo_init(void *userdata, struct fuse_conn_info *conn)
fuse_log(FUSE_LOG_DEBUG, "lo_init: activating writeback\n");
conn->want |= FUSE_CAP_WRITEBACK_CACHE;
}
- if (lo->flock && conn->capable & FUSE_CAP_FLOCK_LOCKS) {
- fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
- conn->want |= FUSE_CAP_FLOCK_LOCKS;
+ if (conn->capable & FUSE_CAP_FLOCK_LOCKS) {
+ if (lo->flock) {
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
+ conn->want |= FUSE_CAP_FLOCK_LOCKS;
+ } else {
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: disabling flock locks\n");
+ conn->want &= ~FUSE_CAP_FLOCK_LOCKS;
+ }
}
if (conn->capable & FUSE_CAP_POSIX_LOCKS) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 095/108] virtiofsd: convert more fprintf and perror to use fuse log infra
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (93 preceding siblings ...)
2020-01-23 16:46 ` [PULL 094/108] virtiofsd: do not always set FUSE_FLOCK_LOCKS Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 096/108] virtiofsd: Reset O_DIRECT flag during file open Dr. David Alan Gilbert (git)
` (14 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Eryu Guan <eguan@linux.alibaba.com>
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_signals.c | 7 +++++--
tools/virtiofsd/helper.c | 9 ++++++---
2 files changed, 11 insertions(+), 5 deletions(-)
diff --git a/tools/virtiofsd/fuse_signals.c b/tools/virtiofsd/fuse_signals.c
index dc7c8ac025..f18625b6e2 100644
--- a/tools/virtiofsd/fuse_signals.c
+++ b/tools/virtiofsd/fuse_signals.c
@@ -12,6 +12,7 @@
#include "fuse_i.h"
#include "fuse_lowlevel.h"
+#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
@@ -47,13 +48,15 @@ static int set_one_signal_handler(int sig, void (*handler)(int), int remove)
sa.sa_flags = 0;
if (sigaction(sig, NULL, &old_sa) == -1) {
- perror("fuse: cannot get old signal handler");
+ fuse_log(FUSE_LOG_ERR, "fuse: cannot get old signal handler: %s\n",
+ strerror(errno));
return -1;
}
if (old_sa.sa_handler == (remove ? handler : SIG_DFL) &&
sigaction(sig, &sa, NULL) == -1) {
- perror("fuse: cannot set signal handler");
+ fuse_log(FUSE_LOG_ERR, "fuse: cannot set signal handler: %s\n",
+ strerror(errno));
return -1;
}
return 0;
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index 33749bfcb7..f98d8f2eb2 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -208,7 +208,8 @@ int fuse_daemonize(int foreground)
char completed;
if (pipe(waiter)) {
- perror("fuse_daemonize: pipe");
+ fuse_log(FUSE_LOG_ERR, "fuse_daemonize: pipe: %s\n",
+ strerror(errno));
return -1;
}
@@ -218,7 +219,8 @@ int fuse_daemonize(int foreground)
*/
switch (fork()) {
case -1:
- perror("fuse_daemonize: fork");
+ fuse_log(FUSE_LOG_ERR, "fuse_daemonize: fork: %s\n",
+ strerror(errno));
return -1;
case 0:
break;
@@ -228,7 +230,8 @@ int fuse_daemonize(int foreground)
}
if (setsid() == -1) {
- perror("fuse_daemonize: setsid");
+ fuse_log(FUSE_LOG_ERR, "fuse_daemonize: setsid: %s\n",
+ strerror(errno));
return -1;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 096/108] virtiofsd: Reset O_DIRECT flag during file open
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (94 preceding siblings ...)
2020-01-23 16:46 ` [PULL 095/108] virtiofsd: convert more fprintf and perror to use fuse log infra Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 097/108] virtiofsd: Fix data corruption with O_APPEND write in writeback mode Dr. David Alan Gilbert (git)
` (13 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Vivek Goyal <vgoyal@redhat.com>
If an application wants to do direct IO and opens a file with O_DIRECT
in guest, that does not necessarily mean that we need to bypass page
cache on host as well. So reset this flag on host.
If somebody needs to bypass page cache on host as well (and it is safe to
do so), we can add a knob in daemon later to control this behavior.
I check virtio-9p and they do reset O_DIRECT flag.
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index ccbbec18b0..948cb19c77 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1721,6 +1721,13 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
goto out;
}
+ /*
+ * O_DIRECT in guest should not necessarily mean bypassing page
+ * cache on host as well. If somebody needs that behavior, it
+ * probably should be a configuration knob in daemon.
+ */
+ fi->flags &= ~O_DIRECT;
+
fd = openat(parent_inode->fd, name, (fi->flags | O_CREAT) & ~O_NOFOLLOW,
mode);
err = fd == -1 ? errno : 0;
@@ -1950,6 +1957,13 @@ static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
fi->flags &= ~O_APPEND;
}
+ /*
+ * O_DIRECT in guest should not necessarily mean bypassing page
+ * cache on host as well. If somebody needs that behavior, it
+ * probably should be a configuration knob in daemon.
+ */
+ fi->flags &= ~O_DIRECT;
+
sprintf(buf, "%i", lo_fd(req, ino));
fd = openat(lo->proc_self_fd, buf, fi->flags & ~O_NOFOLLOW);
if (fd == -1) {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 097/108] virtiofsd: Fix data corruption with O_APPEND write in writeback mode
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (95 preceding siblings ...)
2020-01-23 16:46 ` [PULL 096/108] virtiofsd: Reset O_DIRECT flag during file open Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 098/108] virtiofsd: passthrough_ll: Use cache_readdir for directory open Dr. David Alan Gilbert (git)
` (12 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
When writeback mode is enabled (-o writeback), O_APPEND handling is
done in kernel. Therefore virtiofsd clears O_APPEND flag when open.
Otherwise O_APPEND flag takes precedence over pwrite() and write
data may corrupt.
Currently clearing O_APPEND flag is done in lo_open(), but we also
need the same operation in lo_create(). So, factor out the flag
update operation in lo_open() to update_open_flags() and call it
in both lo_open() and lo_create().
This fixes the failure of xfstest generic/069 in writeback mode
(which tests O_APPEND write data integrity).
Signed-off-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 66 ++++++++++++++++----------------
1 file changed, 33 insertions(+), 33 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 948cb19c77..4c61ac5065 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1692,6 +1692,37 @@ static void lo_releasedir(fuse_req_t req, fuse_ino_t ino,
fuse_reply_err(req, 0);
}
+static void update_open_flags(int writeback, struct fuse_file_info *fi)
+{
+ /*
+ * With writeback cache, kernel may send read requests even
+ * when userspace opened write-only
+ */
+ if (writeback && (fi->flags & O_ACCMODE) == O_WRONLY) {
+ fi->flags &= ~O_ACCMODE;
+ fi->flags |= O_RDWR;
+ }
+
+ /*
+ * With writeback cache, O_APPEND is handled by the kernel.
+ * This breaks atomicity (since the file may change in the
+ * underlying filesystem, so that the kernel's idea of the
+ * end of the file isn't accurate anymore). In this example,
+ * we just accept that. A more rigorous filesystem may want
+ * to return an error here
+ */
+ if (writeback && (fi->flags & O_APPEND)) {
+ fi->flags &= ~O_APPEND;
+ }
+
+ /*
+ * O_DIRECT in guest should not necessarily mean bypassing page
+ * cache on host as well. If somebody needs that behavior, it
+ * probably should be a configuration knob in daemon.
+ */
+ fi->flags &= ~O_DIRECT;
+}
+
static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
mode_t mode, struct fuse_file_info *fi)
{
@@ -1721,12 +1752,7 @@ static void lo_create(fuse_req_t req, fuse_ino_t parent, const char *name,
goto out;
}
- /*
- * O_DIRECT in guest should not necessarily mean bypassing page
- * cache on host as well. If somebody needs that behavior, it
- * probably should be a configuration knob in daemon.
- */
- fi->flags &= ~O_DIRECT;
+ update_open_flags(lo->writeback, fi);
fd = openat(parent_inode->fd, name, (fi->flags | O_CREAT) & ~O_NOFOLLOW,
mode);
@@ -1936,33 +1962,7 @@ static void lo_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
fuse_log(FUSE_LOG_DEBUG, "lo_open(ino=%" PRIu64 ", flags=%d)\n", ino,
fi->flags);
- /*
- * With writeback cache, kernel may send read requests even
- * when userspace opened write-only
- */
- if (lo->writeback && (fi->flags & O_ACCMODE) == O_WRONLY) {
- fi->flags &= ~O_ACCMODE;
- fi->flags |= O_RDWR;
- }
-
- /*
- * With writeback cache, O_APPEND is handled by the kernel.
- * This breaks atomicity (since the file may change in the
- * underlying filesystem, so that the kernel's idea of the
- * end of the file isn't accurate anymore). In this example,
- * we just accept that. A more rigorous filesystem may want
- * to return an error here
- */
- if (lo->writeback && (fi->flags & O_APPEND)) {
- fi->flags &= ~O_APPEND;
- }
-
- /*
- * O_DIRECT in guest should not necessarily mean bypassing page
- * cache on host as well. If somebody needs that behavior, it
- * probably should be a configuration knob in daemon.
- */
- fi->flags &= ~O_DIRECT;
+ update_open_flags(lo->writeback, fi);
sprintf(buf, "%i", lo_fd(req, ino));
fd = openat(lo->proc_self_fd, buf, fi->flags & ~O_NOFOLLOW);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 098/108] virtiofsd: passthrough_ll: Use cache_readdir for directory open
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (96 preceding siblings ...)
2020-01-23 16:46 ` [PULL 097/108] virtiofsd: Fix data corruption with O_APPEND write in writeback mode Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 099/108] virtiofsd: add definition of fuse_buf_writev() Dr. David Alan Gilbert (git)
` (11 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Since keep_cache(FOPEN_KEEP_CACHE) has no effect for directory as
described in fuse_common.h, use cache_readdir(FOPNE_CACHE_DIR) for
diretory open when cache=always mode.
Signed-off-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 4c61ac5065..79b8b71a4f 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1523,7 +1523,7 @@ static void lo_opendir(fuse_req_t req, fuse_ino_t ino,
fi->fh = fh;
if (lo->cache == CACHE_ALWAYS) {
- fi->keep_cache = 1;
+ fi->cache_readdir = 1;
}
fuse_reply_open(req, fi);
return;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 099/108] virtiofsd: add definition of fuse_buf_writev()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (97 preceding siblings ...)
2020-01-23 16:46 ` [PULL 098/108] virtiofsd: passthrough_ll: Use cache_readdir for directory open Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 100/108] virtiofsd: use fuse_buf_writev to replace fuse_buf_write for better performance Dr. David Alan Gilbert (git)
` (10 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: piaojun <piaojun@huawei.com>
Define fuse_buf_writev() which use pwritev and writev to improve io
bandwidth. Especially, the src bufs with 0 size should be skipped as
their mems are not *block_size* aligned which will cause writev failed
in direct io mode.
Signed-off-by: Jun Piao <piaojun@huawei.com>
Suggested-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/buffer.c | 38 ++++++++++++++++++++++++++++++++++++++
1 file changed, 38 insertions(+)
diff --git a/tools/virtiofsd/buffer.c b/tools/virtiofsd/buffer.c
index 42a608f6bd..37befebac2 100644
--- a/tools/virtiofsd/buffer.c
+++ b/tools/virtiofsd/buffer.c
@@ -14,6 +14,7 @@
#include "fuse_lowlevel.h"
#include <assert.h>
#include <errno.h>
+#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@@ -33,6 +34,43 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv)
return size;
}
+__attribute__((unused))
+static ssize_t fuse_buf_writev(struct fuse_buf *out_buf,
+ struct fuse_bufvec *in_buf)
+{
+ ssize_t res, i, j;
+ size_t iovcnt = in_buf->count;
+ struct iovec *iov;
+ int fd = out_buf->fd;
+
+ iov = calloc(iovcnt, sizeof(struct iovec));
+ if (!iov) {
+ return -ENOMEM;
+ }
+
+ for (i = 0, j = 0; i < iovcnt; i++) {
+ /* Skip the buf with 0 size */
+ if (in_buf->buf[i].size) {
+ iov[j].iov_base = in_buf->buf[i].mem;
+ iov[j].iov_len = in_buf->buf[i].size;
+ j++;
+ }
+ }
+
+ if (out_buf->flags & FUSE_BUF_FD_SEEK) {
+ res = pwritev(fd, iov, iovcnt, out_buf->pos);
+ } else {
+ res = writev(fd, iov, iovcnt);
+ }
+
+ if (res == -1) {
+ res = -errno;
+ }
+
+ free(iov);
+ return res;
+}
+
static size_t min_size(size_t s1, size_t s2)
{
return s1 < s2 ? s1 : s2;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 100/108] virtiofsd: use fuse_buf_writev to replace fuse_buf_write for better performance
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (98 preceding siblings ...)
2020-01-23 16:46 ` [PULL 099/108] virtiofsd: add definition of fuse_buf_writev() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 101/108] virtiofsd: process requests in a thread pool Dr. David Alan Gilbert (git)
` (9 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: piaojun <piaojun@huawei.com>
fuse_buf_writev() only handles the normal write in which src is buffer
and dest is fd. Specially if src buffer represents guest physical
address that can't be mapped by the daemon process, IO must be bounced
back to the VMM to do it by fuse_buf_copy().
Signed-off-by: Jun Piao <piaojun@huawei.com>
Suggested-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Suggested-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/buffer.c | 20 ++++++++++++++++++--
1 file changed, 18 insertions(+), 2 deletions(-)
diff --git a/tools/virtiofsd/buffer.c b/tools/virtiofsd/buffer.c
index 37befebac2..27c1377f22 100644
--- a/tools/virtiofsd/buffer.c
+++ b/tools/virtiofsd/buffer.c
@@ -34,7 +34,6 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv)
return size;
}
-__attribute__((unused))
static ssize_t fuse_buf_writev(struct fuse_buf *out_buf,
struct fuse_bufvec *in_buf)
{
@@ -262,12 +261,29 @@ static int fuse_bufvec_advance(struct fuse_bufvec *bufv, size_t len)
ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv)
{
- size_t copied = 0;
+ size_t copied = 0, i;
if (dstv == srcv) {
return fuse_buf_size(dstv);
}
+ /*
+ * use writev to improve bandwidth when all the
+ * src buffers already mapped by the daemon
+ * process
+ */
+ for (i = 0; i < srcv->count; i++) {
+ if (srcv->buf[i].flags & FUSE_BUF_IS_FD) {
+ break;
+ }
+ }
+ if ((i == srcv->count) && (dstv->count == 1) &&
+ (dstv->idx == 0) &&
+ (dstv->buf[0].flags & FUSE_BUF_IS_FD)) {
+ dstv->buf[0].pos += dstv->off;
+ return fuse_buf_writev(&dstv->buf[0], srcv);
+ }
+
for (;;) {
const struct fuse_buf *src = fuse_bufvec_current(srcv);
const struct fuse_buf *dst = fuse_bufvec_current(dstv);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 101/108] virtiofsd: process requests in a thread pool
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (99 preceding siblings ...)
2020-01-23 16:46 ` [PULL 100/108] virtiofsd: use fuse_buf_writev to replace fuse_buf_write for better performance Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 102/108] virtiofsd: prevent FUSE_INIT/FUSE_DESTROY races Dr. David Alan Gilbert (git)
` (8 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Introduce a thread pool so that fv_queue_thread() just pops
VuVirtqElements and hands them to the thread pool. For the time being
only one worker thread is allowed since passthrough_ll.c is not
thread-safe yet. Future patches will lift this restriction so that
multiple FUSE requests can be processed in parallel.
The main new concept is struct FVRequest, which contains both
VuVirtqElement and struct fuse_chan. We now have fv_VuDev for a device,
fv_QueueInfo for a virtqueue, and FVRequest for a request. Some of
fv_QueueInfo's fields are moved into FVRequest because they are
per-request. The name FVRequest conforms to QEMU coding style and I
expect the struct fv_* types will be renamed in a future refactoring.
This patch series is not optimal. fbuf reuse is dropped so each request
does malloc(se->bufsize), but there is no clean and cheap way to keep
this with a thread pool. The vq_lock mutex is held for longer than
necessary, especially during the eventfd_write() syscall. Performance
can be improved in the future.
prctl(2) had to be added to the seccomp whitelist because glib invokes
it.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_virtio.c | 359 +++++++++++++++++++---------------
1 file changed, 201 insertions(+), 158 deletions(-)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index f6242f9338..0dcf2ef57a 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -22,6 +22,7 @@
#include <assert.h>
#include <errno.h>
+#include <glib.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
@@ -37,17 +38,28 @@
struct fv_VuDev;
struct fv_QueueInfo {
pthread_t thread;
+ /*
+ * This lock protects the VuVirtq preventing races between
+ * fv_queue_thread() and fv_queue_worker().
+ */
+ pthread_mutex_t vq_lock;
+
struct fv_VuDev *virtio_dev;
/* Our queue index, corresponds to array position */
int qidx;
int kick_fd;
int kill_fd; /* For killing the thread */
+};
- /* The element for the command currently being processed */
- VuVirtqElement *qe;
+/* A FUSE request */
+typedef struct {
+ VuVirtqElement elem;
+ struct fuse_chan ch;
+
+ /* Used to complete requests that involve no reply */
bool reply_sent;
-};
+} FVRequest;
/*
* We pass the dev element into libvhost-user
@@ -191,8 +203,11 @@ static void copy_iov(struct iovec *src_iov, int src_count,
int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
struct iovec *iov, int count)
{
- VuVirtqElement *elem;
- VuVirtq *q;
+ FVRequest *req = container_of(ch, FVRequest, ch);
+ struct fv_QueueInfo *qi = ch->qi;
+ VuDev *dev = &se->virtio_dev->dev;
+ VuVirtq *q = vu_get_queue(dev, qi->qidx);
+ VuVirtqElement *elem = &req->elem;
int ret = 0;
assert(count >= 1);
@@ -205,11 +220,7 @@ int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
/* unique == 0 is notification, which we don't support */
assert(out->unique);
- /* For virtio we always have ch */
- assert(ch);
- assert(!ch->qi->reply_sent);
- elem = ch->qi->qe;
- q = &ch->qi->virtio_dev->dev.vq[ch->qi->qidx];
+ assert(!req->reply_sent);
/* The 'in' part of the elem is to qemu */
unsigned int in_num = elem->in_num;
@@ -236,9 +247,15 @@ int virtio_send_msg(struct fuse_session *se, struct fuse_chan *ch,
}
copy_iov(iov, count, in_sg, in_num, tosend_len);
- vu_queue_push(&se->virtio_dev->dev, q, elem, tosend_len);
- vu_queue_notify(&se->virtio_dev->dev, q);
- ch->qi->reply_sent = true;
+
+ pthread_rwlock_rdlock(&qi->virtio_dev->vu_dispatch_rwlock);
+ pthread_mutex_lock(&qi->vq_lock);
+ vu_queue_push(dev, q, elem, tosend_len);
+ vu_queue_notify(dev, q);
+ pthread_mutex_unlock(&qi->vq_lock);
+ pthread_rwlock_unlock(&qi->virtio_dev->vu_dispatch_rwlock);
+
+ req->reply_sent = true;
err:
return ret;
@@ -254,9 +271,12 @@ int virtio_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
struct iovec *iov, int count, struct fuse_bufvec *buf,
size_t len)
{
+ FVRequest *req = container_of(ch, FVRequest, ch);
+ struct fv_QueueInfo *qi = ch->qi;
+ VuDev *dev = &se->virtio_dev->dev;
+ VuVirtq *q = vu_get_queue(dev, qi->qidx);
+ VuVirtqElement *elem = &req->elem;
int ret = 0;
- VuVirtqElement *elem;
- VuVirtq *q;
assert(count >= 1);
assert(iov[0].iov_len >= sizeof(struct fuse_out_header));
@@ -275,11 +295,7 @@ int virtio_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
/* unique == 0 is notification which we don't support */
assert(out->unique);
- /* For virtio we always have ch */
- assert(ch);
- assert(!ch->qi->reply_sent);
- elem = ch->qi->qe;
- q = &ch->qi->virtio_dev->dev.vq[ch->qi->qidx];
+ assert(!req->reply_sent);
/* The 'in' part of the elem is to qemu */
unsigned int in_num = elem->in_num;
@@ -395,33 +411,175 @@ int virtio_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
ret = 0;
- vu_queue_push(&se->virtio_dev->dev, q, elem, tosend_len);
- vu_queue_notify(&se->virtio_dev->dev, q);
+ pthread_rwlock_rdlock(&qi->virtio_dev->vu_dispatch_rwlock);
+ pthread_mutex_lock(&qi->vq_lock);
+ vu_queue_push(dev, q, elem, tosend_len);
+ vu_queue_notify(dev, q);
+ pthread_mutex_unlock(&qi->vq_lock);
+ pthread_rwlock_unlock(&qi->virtio_dev->vu_dispatch_rwlock);
err:
if (ret == 0) {
- ch->qi->reply_sent = true;
+ req->reply_sent = true;
}
return ret;
}
+/* Process one FVRequest in a thread pool */
+static void fv_queue_worker(gpointer data, gpointer user_data)
+{
+ struct fv_QueueInfo *qi = user_data;
+ struct fuse_session *se = qi->virtio_dev->se;
+ struct VuDev *dev = &qi->virtio_dev->dev;
+ FVRequest *req = data;
+ VuVirtqElement *elem = &req->elem;
+ struct fuse_buf fbuf = {};
+ bool allocated_bufv = false;
+ struct fuse_bufvec bufv;
+ struct fuse_bufvec *pbufv;
+
+ assert(se->bufsize > sizeof(struct fuse_in_header));
+
+ /*
+ * An element contains one request and the space to send our response
+ * They're spread over multiple descriptors in a scatter/gather set
+ * and we can't trust the guest to keep them still; so copy in/out.
+ */
+ fbuf.mem = malloc(se->bufsize);
+ assert(fbuf.mem);
+
+ fuse_mutex_init(&req->ch.lock);
+ req->ch.fd = -1;
+ req->ch.qi = qi;
+
+ /* The 'out' part of the elem is from qemu */
+ unsigned int out_num = elem->out_num;
+ struct iovec *out_sg = elem->out_sg;
+ size_t out_len = iov_size(out_sg, out_num);
+ fuse_log(FUSE_LOG_DEBUG,
+ "%s: elem %d: with %d out desc of length %zd\n",
+ __func__, elem->index, out_num, out_len);
+
+ /*
+ * The elem should contain a 'fuse_in_header' (in to fuse)
+ * plus the data based on the len in the header.
+ */
+ if (out_len < sizeof(struct fuse_in_header)) {
+ fuse_log(FUSE_LOG_ERR, "%s: elem %d too short for in_header\n",
+ __func__, elem->index);
+ assert(0); /* TODO */
+ }
+ if (out_len > se->bufsize) {
+ fuse_log(FUSE_LOG_ERR, "%s: elem %d too large for buffer\n", __func__,
+ elem->index);
+ assert(0); /* TODO */
+ }
+ /* Copy just the first element and look at it */
+ copy_from_iov(&fbuf, 1, out_sg);
+
+ pbufv = NULL; /* Compiler thinks an unitialised path */
+ if (out_num > 2 &&
+ out_sg[0].iov_len == sizeof(struct fuse_in_header) &&
+ ((struct fuse_in_header *)fbuf.mem)->opcode == FUSE_WRITE &&
+ out_sg[1].iov_len == sizeof(struct fuse_write_in)) {
+ /*
+ * For a write we don't actually need to copy the
+ * data, we can just do it straight out of guest memory
+ * but we must still copy the headers in case the guest
+ * was nasty and changed them while we were using them.
+ */
+ fuse_log(FUSE_LOG_DEBUG, "%s: Write special case\n", __func__);
+
+ /* copy the fuse_write_in header afte rthe fuse_in_header */
+ fbuf.mem += out_sg->iov_len;
+ copy_from_iov(&fbuf, 1, out_sg + 1);
+ fbuf.mem -= out_sg->iov_len;
+ fbuf.size = out_sg[0].iov_len + out_sg[1].iov_len;
+
+ /* Allocate the bufv, with space for the rest of the iov */
+ pbufv = malloc(sizeof(struct fuse_bufvec) +
+ sizeof(struct fuse_buf) * (out_num - 2));
+ if (!pbufv) {
+ fuse_log(FUSE_LOG_ERR, "%s: pbufv malloc failed\n",
+ __func__);
+ goto out;
+ }
+
+ allocated_bufv = true;
+ pbufv->count = 1;
+ pbufv->buf[0] = fbuf;
+
+ size_t iovindex, pbufvindex;
+ iovindex = 2; /* 2 headers, separate iovs */
+ pbufvindex = 1; /* 2 headers, 1 fusebuf */
+
+ for (; iovindex < out_num; iovindex++, pbufvindex++) {
+ pbufv->count++;
+ pbufv->buf[pbufvindex].pos = ~0; /* Dummy */
+ pbufv->buf[pbufvindex].flags = 0;
+ pbufv->buf[pbufvindex].mem = out_sg[iovindex].iov_base;
+ pbufv->buf[pbufvindex].size = out_sg[iovindex].iov_len;
+ }
+ } else {
+ /* Normal (non fast write) path */
+
+ /* Copy the rest of the buffer */
+ fbuf.mem += out_sg->iov_len;
+ copy_from_iov(&fbuf, out_num - 1, out_sg + 1);
+ fbuf.mem -= out_sg->iov_len;
+ fbuf.size = out_len;
+
+ /* TODO! Endianness of header */
+
+ /* TODO: Add checks for fuse_session_exited */
+ bufv.buf[0] = fbuf;
+ bufv.count = 1;
+ pbufv = &bufv;
+ }
+ pbufv->idx = 0;
+ pbufv->off = 0;
+ fuse_session_process_buf_int(se, pbufv, &req->ch);
+
+out:
+ if (allocated_bufv) {
+ free(pbufv);
+ }
+
+ /* If the request has no reply, still recycle the virtqueue element */
+ if (!req->reply_sent) {
+ struct VuVirtq *q = vu_get_queue(dev, qi->qidx);
+
+ fuse_log(FUSE_LOG_DEBUG, "%s: elem %d no reply sent\n", __func__,
+ elem->index);
+
+ pthread_rwlock_rdlock(&qi->virtio_dev->vu_dispatch_rwlock);
+ pthread_mutex_lock(&qi->vq_lock);
+ vu_queue_push(dev, q, elem, 0);
+ vu_queue_notify(dev, q);
+ pthread_mutex_unlock(&qi->vq_lock);
+ pthread_rwlock_unlock(&qi->virtio_dev->vu_dispatch_rwlock);
+ }
+
+ pthread_mutex_destroy(&req->ch.lock);
+ free(fbuf.mem);
+ free(req);
+}
+
/* Thread function for individual queues, created when a queue is 'started' */
static void *fv_queue_thread(void *opaque)
{
struct fv_QueueInfo *qi = opaque;
struct VuDev *dev = &qi->virtio_dev->dev;
struct VuVirtq *q = vu_get_queue(dev, qi->qidx);
- struct fuse_session *se = qi->virtio_dev->se;
- struct fuse_chan ch;
- struct fuse_buf fbuf;
+ GThreadPool *pool;
- fbuf.mem = NULL;
- fbuf.flags = 0;
-
- fuse_mutex_init(&ch.lock);
- ch.fd = (int)0xdaff0d111;
- ch.qi = qi;
+ pool = g_thread_pool_new(fv_queue_worker, qi, 1 /* TODO max_threads */,
+ TRUE, NULL);
+ if (!pool) {
+ fuse_log(FUSE_LOG_ERR, "%s: g_thread_pool_new failed\n", __func__);
+ return NULL;
+ }
fuse_log(FUSE_LOG_INFO, "%s: Start for queue %d kick_fd %d\n", __func__,
qi->qidx, qi->kick_fd);
@@ -478,6 +636,7 @@ static void *fv_queue_thread(void *opaque)
/* Mutual exclusion with virtio_loop() */
ret = pthread_rwlock_rdlock(&qi->virtio_dev->vu_dispatch_rwlock);
assert(ret == 0); /* there is no possible error case */
+ pthread_mutex_lock(&qi->vq_lock);
/* out is from guest, in is too guest */
unsigned int in_bytes, out_bytes;
vu_queue_get_avail_bytes(dev, q, &in_bytes, &out_bytes, ~0, ~0);
@@ -486,141 +645,22 @@ static void *fv_queue_thread(void *opaque)
"%s: Queue %d gave evalue: %zx available: in: %u out: %u\n",
__func__, qi->qidx, (size_t)evalue, in_bytes, out_bytes);
-
while (1) {
- bool allocated_bufv = false;
- struct fuse_bufvec bufv;
- struct fuse_bufvec *pbufv;
-
- /*
- * An element contains one request and the space to send our
- * response They're spread over multiple descriptors in a
- * scatter/gather set and we can't trust the guest to keep them
- * still; so copy in/out.
- */
- VuVirtqElement *elem = vu_queue_pop(dev, q, sizeof(VuVirtqElement));
- if (!elem) {
+ FVRequest *req = vu_queue_pop(dev, q, sizeof(FVRequest));
+ if (!req) {
break;
}
- qi->qe = elem;
- qi->reply_sent = false;
+ req->reply_sent = false;
- if (!fbuf.mem) {
- fbuf.mem = malloc(se->bufsize);
- assert(fbuf.mem);
- assert(se->bufsize > sizeof(struct fuse_in_header));
- }
- /* The 'out' part of the elem is from qemu */
- unsigned int out_num = elem->out_num;
- struct iovec *out_sg = elem->out_sg;
- size_t out_len = iov_size(out_sg, out_num);
- fuse_log(FUSE_LOG_DEBUG,
- "%s: elem %d: with %d out desc of length %zd\n", __func__,
- elem->index, out_num, out_len);
-
- /*
- * The elem should contain a 'fuse_in_header' (in to fuse)
- * plus the data based on the len in the header.
- */
- if (out_len < sizeof(struct fuse_in_header)) {
- fuse_log(FUSE_LOG_ERR, "%s: elem %d too short for in_header\n",
- __func__, elem->index);
- assert(0); /* TODO */
- }
- if (out_len > se->bufsize) {
- fuse_log(FUSE_LOG_ERR, "%s: elem %d too large for buffer\n",
- __func__, elem->index);
- assert(0); /* TODO */
- }
- /* Copy just the first element and look at it */
- copy_from_iov(&fbuf, 1, out_sg);
-
- if (out_num > 2 &&
- out_sg[0].iov_len == sizeof(struct fuse_in_header) &&
- ((struct fuse_in_header *)fbuf.mem)->opcode == FUSE_WRITE &&
- out_sg[1].iov_len == sizeof(struct fuse_write_in)) {
- /*
- * For a write we don't actually need to copy the
- * data, we can just do it straight out of guest memory
- * but we must still copy the headers in case the guest
- * was nasty and changed them while we were using them.
- */
- fuse_log(FUSE_LOG_DEBUG, "%s: Write special case\n", __func__);
-
- /* copy the fuse_write_in header after the fuse_in_header */
- fbuf.mem += out_sg->iov_len;
- copy_from_iov(&fbuf, 1, out_sg + 1);
- fbuf.mem -= out_sg->iov_len;
- fbuf.size = out_sg[0].iov_len + out_sg[1].iov_len;
-
- /* Allocate the bufv, with space for the rest of the iov */
- allocated_bufv = true;
- pbufv = malloc(sizeof(struct fuse_bufvec) +
- sizeof(struct fuse_buf) * (out_num - 2));
- if (!pbufv) {
- vu_queue_unpop(dev, q, elem, 0);
- free(elem);
- fuse_log(FUSE_LOG_ERR, "%s: pbufv malloc failed\n",
- __func__);
- goto out;
- }
-
- pbufv->count = 1;
- pbufv->buf[0] = fbuf;
-
- size_t iovindex, pbufvindex;
- iovindex = 2; /* 2 headers, separate iovs */
- pbufvindex = 1; /* 2 headers, 1 fusebuf */
-
- for (; iovindex < out_num; iovindex++, pbufvindex++) {
- pbufv->count++;
- pbufv->buf[pbufvindex].pos = ~0; /* Dummy */
- pbufv->buf[pbufvindex].flags = 0;
- pbufv->buf[pbufvindex].mem = out_sg[iovindex].iov_base;
- pbufv->buf[pbufvindex].size = out_sg[iovindex].iov_len;
- }
- } else {
- /* Normal (non fast write) path */
-
- /* Copy the rest of the buffer */
- fbuf.mem += out_sg->iov_len;
- copy_from_iov(&fbuf, out_num - 1, out_sg + 1);
- fbuf.mem -= out_sg->iov_len;
- fbuf.size = out_len;
-
- /* TODO! Endianness of header */
-
- /* TODO: Add checks for fuse_session_exited */
- bufv.buf[0] = fbuf;
- bufv.count = 1;
- pbufv = &bufv;
- }
- pbufv->idx = 0;
- pbufv->off = 0;
- fuse_session_process_buf_int(se, pbufv, &ch);
-
- if (allocated_bufv) {
- free(pbufv);
- }
-
- if (!qi->reply_sent) {
- fuse_log(FUSE_LOG_DEBUG, "%s: elem %d no reply sent\n",
- __func__, elem->index);
- /* I think we've still got to recycle the element */
- vu_queue_push(dev, q, elem, 0);
- vu_queue_notify(dev, q);
- }
- qi->qe = NULL;
- free(elem);
- elem = NULL;
+ g_thread_pool_push(pool, req, NULL);
}
+ pthread_mutex_unlock(&qi->vq_lock);
pthread_rwlock_unlock(&qi->virtio_dev->vu_dispatch_rwlock);
}
-out:
- pthread_mutex_destroy(&ch.lock);
- free(fbuf.mem);
+
+ g_thread_pool_free(pool, FALSE, TRUE);
return NULL;
}
@@ -643,6 +683,7 @@ static void fv_queue_cleanup_thread(struct fv_VuDev *vud, int qidx)
fuse_log(FUSE_LOG_ERR, "%s: Failed to join thread idx %d err %d\n",
__func__, qidx, ret);
}
+ pthread_mutex_destroy(&ourqi->vq_lock);
close(ourqi->kill_fd);
ourqi->kick_fd = -1;
free(vud->qi[qidx]);
@@ -696,6 +737,8 @@ static void fv_queue_set_started(VuDev *dev, int qidx, bool started)
ourqi->kill_fd = eventfd(0, EFD_CLOEXEC | EFD_SEMAPHORE);
assert(ourqi->kill_fd != -1);
+ pthread_mutex_init(&ourqi->vq_lock, NULL);
+
if (pthread_create(&ourqi->thread, NULL, fv_queue_thread, ourqi)) {
fuse_log(FUSE_LOG_ERR, "%s: Failed to create thread for queue %d\n",
__func__, qidx);
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 102/108] virtiofsd: prevent FUSE_INIT/FUSE_DESTROY races
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (100 preceding siblings ...)
2020-01-23 16:46 ` [PULL 101/108] virtiofsd: process requests in a thread pool Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 103/108] virtiofsd: fix lo_destroy() resource leaks Dr. David Alan Gilbert (git)
` (7 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
When running with multiple threads it can be tricky to handle
FUSE_INIT/FUSE_DESTROY in parallel with other request types or in
parallel with themselves. Serialize FUSE_INIT and FUSE_DESTROY so that
malicious clients cannot trigger race conditions.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_i.h | 1 +
tools/virtiofsd/fuse_lowlevel.c | 18 ++++++++++++++++++
2 files changed, 19 insertions(+)
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index a20854f1c4..1447d86866 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -61,6 +61,7 @@ struct fuse_session {
struct fuse_req list;
struct fuse_req interrupts;
pthread_mutex_t lock;
+ pthread_rwlock_t init_rwlock;
int got_destroy;
int broken_splice_nonblock;
uint64_t notify_ctr;
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index dab6a31e08..79a4031266 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -2428,6 +2428,19 @@ void fuse_session_process_buf_int(struct fuse_session *se,
req->ctx.pid = in->pid;
req->ch = ch;
+ /*
+ * INIT and DESTROY requests are serialized, all other request types
+ * run in parallel. This prevents races between FUSE_INIT and ordinary
+ * requests, FUSE_INIT and FUSE_INIT, FUSE_INIT and FUSE_DESTROY, and
+ * FUSE_DESTROY and FUSE_DESTROY.
+ */
+ if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT ||
+ in->opcode == FUSE_DESTROY) {
+ pthread_rwlock_wrlock(&se->init_rwlock);
+ } else {
+ pthread_rwlock_rdlock(&se->init_rwlock);
+ }
+
err = EIO;
if (!se->got_init) {
enum fuse_opcode expected;
@@ -2485,10 +2498,13 @@ void fuse_session_process_buf_int(struct fuse_session *se,
} else {
fuse_ll_ops[in->opcode].func(req, in->nodeid, &iter);
}
+
+ pthread_rwlock_unlock(&se->init_rwlock);
return;
reply_err:
fuse_reply_err(req, err);
+ pthread_rwlock_unlock(&se->init_rwlock);
}
#define LL_OPTION(n, o, v) \
@@ -2531,6 +2547,7 @@ void fuse_session_destroy(struct fuse_session *se)
se->op.destroy(se->userdata);
}
}
+ pthread_rwlock_destroy(&se->init_rwlock);
pthread_mutex_destroy(&se->lock);
free(se->cuse_data);
if (se->fd != -1) {
@@ -2610,6 +2627,7 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
list_init_req(&se->list);
list_init_req(&se->interrupts);
fuse_mutex_init(&se->lock);
+ pthread_rwlock_init(&se->init_rwlock, NULL);
memcpy(&se->op, op, op_size);
se->owner = getuid();
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 103/108] virtiofsd: fix lo_destroy() resource leaks
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (101 preceding siblings ...)
2020-01-23 16:46 ` [PULL 102/108] virtiofsd: prevent FUSE_INIT/FUSE_DESTROY races Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 104/108] virtiofsd: add --thread-pool-size=NUM option Dr. David Alan Gilbert (git)
` (6 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Now that lo_destroy() is serialized we can call unref_inode() so that
all inode resources are freed.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 41 ++++++++++++++++----------------
1 file changed, 20 insertions(+), 21 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index 79b8b71a4f..eb001b9d1e 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1371,26 +1371,6 @@ static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
}
}
-static int unref_all_inodes_cb(gpointer key, gpointer value, gpointer user_data)
-{
- struct lo_inode *inode = value;
- struct lo_data *lo = user_data;
-
- inode->nlookup = 0;
- lo_map_remove(&lo->ino_map, inode->fuse_ino);
- close(inode->fd);
- lo_inode_put(lo, &inode); /* Drop our refcount from lo_do_lookup() */
-
- return TRUE;
-}
-
-static void unref_all_inodes(struct lo_data *lo)
-{
- pthread_mutex_lock(&lo->mutex);
- g_hash_table_foreach_remove(lo->inodes, unref_all_inodes_cb, lo);
- pthread_mutex_unlock(&lo->mutex);
-}
-
static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{
struct lo_data *lo = lo_data(req);
@@ -2477,7 +2457,26 @@ static void lo_lseek(fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
static void lo_destroy(void *userdata)
{
struct lo_data *lo = (struct lo_data *)userdata;
- unref_all_inodes(lo);
+
+ /*
+ * Normally lo->mutex must be taken when traversing lo->inodes but
+ * lo_destroy() is a serialized request so no races are possible here.
+ *
+ * In addition, we cannot acquire lo->mutex since unref_inode() takes it
+ * too and this would result in a recursive lock.
+ */
+ while (true) {
+ GHashTableIter iter;
+ gpointer key, value;
+
+ g_hash_table_iter_init(&iter, lo->inodes);
+ if (!g_hash_table_iter_next(&iter, &key, &value)) {
+ break;
+ }
+
+ struct lo_inode *inode = value;
+ unref_inode_lolocked(lo, inode, inode->nlookup);
+ }
}
static struct fuse_lowlevel_ops lo_oper = {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 104/108] virtiofsd: add --thread-pool-size=NUM option
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (102 preceding siblings ...)
2020-01-23 16:46 ` [PULL 103/108] virtiofsd: fix lo_destroy() resource leaks Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 105/108] virtiofsd: Convert lo_destroy to take the lo->mutex lock itself Dr. David Alan Gilbert (git)
` (5 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Stefan Hajnoczi <stefanha@redhat.com>
Add an option to control the size of the thread pool. Requests are now
processed in parallel by default.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_i.h | 1 +
tools/virtiofsd/fuse_lowlevel.c | 7 ++++++-
tools/virtiofsd/fuse_virtio.c | 5 +++--
3 files changed, 10 insertions(+), 3 deletions(-)
diff --git a/tools/virtiofsd/fuse_i.h b/tools/virtiofsd/fuse_i.h
index 1447d86866..4e47e5880d 100644
--- a/tools/virtiofsd/fuse_i.h
+++ b/tools/virtiofsd/fuse_i.h
@@ -72,6 +72,7 @@ struct fuse_session {
int vu_listen_fd;
int vu_socketfd;
struct fv_VuDev *virtio_dev;
+ int thread_pool_size;
};
struct fuse_chan {
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
index 79a4031266..de2e2e0c65 100644
--- a/tools/virtiofsd/fuse_lowlevel.c
+++ b/tools/virtiofsd/fuse_lowlevel.c
@@ -28,6 +28,7 @@
#include <sys/file.h>
#include <unistd.h>
+#define THREAD_POOL_SIZE 64
#define OFFSET_MAX 0x7fffffffffffffffLL
@@ -2519,6 +2520,7 @@ static const struct fuse_opt fuse_ll_opts[] = {
LL_OPTION("allow_root", deny_others, 1),
LL_OPTION("--socket-path=%s", vu_socket_path, 0),
LL_OPTION("--fd=%d", vu_listen_fd, 0),
+ LL_OPTION("--thread-pool-size=%d", thread_pool_size, 0),
FUSE_OPT_END
};
@@ -2537,7 +2539,9 @@ void fuse_lowlevel_help(void)
printf(
" -o allow_root allow access by root\n"
" --socket-path=PATH path for the vhost-user socket\n"
- " --fd=FDNUM fd number of vhost-user socket\n");
+ " --fd=FDNUM fd number of vhost-user socket\n"
+ " --thread-pool-size=NUM thread pool size limit (default %d)\n",
+ THREAD_POOL_SIZE);
}
void fuse_session_destroy(struct fuse_session *se)
@@ -2591,6 +2595,7 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
}
se->fd = -1;
se->vu_listen_fd = -1;
+ se->thread_pool_size = THREAD_POOL_SIZE;
se->conn.max_write = UINT_MAX;
se->conn.max_readahead = UINT_MAX;
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 0dcf2ef57a..9f6582343c 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -572,10 +572,11 @@ static void *fv_queue_thread(void *opaque)
struct fv_QueueInfo *qi = opaque;
struct VuDev *dev = &qi->virtio_dev->dev;
struct VuVirtq *q = vu_get_queue(dev, qi->qidx);
+ struct fuse_session *se = qi->virtio_dev->se;
GThreadPool *pool;
- pool = g_thread_pool_new(fv_queue_worker, qi, 1 /* TODO max_threads */,
- TRUE, NULL);
+ pool = g_thread_pool_new(fv_queue_worker, qi, se->thread_pool_size, TRUE,
+ NULL);
if (!pool) {
fuse_log(FUSE_LOG_ERR, "%s: g_thread_pool_new failed\n", __func__);
return NULL;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 105/108] virtiofsd: Convert lo_destroy to take the lo->mutex lock itself
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (103 preceding siblings ...)
2020-01-23 16:46 ` [PULL 104/108] virtiofsd: add --thread-pool-size=NUM option Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 106/108] virtiofsd/passthrough_ll: Pass errno to fuse_reply_err() Dr. David Alan Gilbert (git)
` (4 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
lo_destroy was relying on some implicit knowledge of the locking;
we can avoid this if we create an unref_inode that doesn't take
the lock and then grab it for the whole of the lo_destroy.
Suggested-by: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 31 +++++++++++++++++--------------
1 file changed, 17 insertions(+), 14 deletions(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index eb001b9d1e..fc15d61510 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -1344,14 +1344,13 @@ static void lo_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
lo_inode_put(lo, &inode);
}
-static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
- uint64_t n)
+/* To be called with lo->mutex held */
+static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n)
{
if (!inode) {
return;
}
- pthread_mutex_lock(&lo->mutex);
assert(inode->nlookup >= n);
inode->nlookup -= n;
if (!inode->nlookup) {
@@ -1362,15 +1361,24 @@ static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
}
g_hash_table_destroy(inode->posix_locks);
pthread_mutex_destroy(&inode->plock_mutex);
- pthread_mutex_unlock(&lo->mutex);
/* Drop our refcount from lo_do_lookup() */
lo_inode_put(lo, &inode);
- } else {
- pthread_mutex_unlock(&lo->mutex);
}
}
+static void unref_inode_lolocked(struct lo_data *lo, struct lo_inode *inode,
+ uint64_t n)
+{
+ if (!inode) {
+ return;
+ }
+
+ pthread_mutex_lock(&lo->mutex);
+ unref_inode(lo, inode, n);
+ pthread_mutex_unlock(&lo->mutex);
+}
+
static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{
struct lo_data *lo = lo_data(req);
@@ -2458,13 +2466,7 @@ static void lo_destroy(void *userdata)
{
struct lo_data *lo = (struct lo_data *)userdata;
- /*
- * Normally lo->mutex must be taken when traversing lo->inodes but
- * lo_destroy() is a serialized request so no races are possible here.
- *
- * In addition, we cannot acquire lo->mutex since unref_inode() takes it
- * too and this would result in a recursive lock.
- */
+ pthread_mutex_lock(&lo->mutex);
while (true) {
GHashTableIter iter;
gpointer key, value;
@@ -2475,8 +2477,9 @@ static void lo_destroy(void *userdata)
}
struct lo_inode *inode = value;
- unref_inode_lolocked(lo, inode, inode->nlookup);
+ unref_inode(lo, inode, inode->nlookup);
}
+ pthread_mutex_unlock(&lo->mutex);
}
static struct fuse_lowlevel_ops lo_oper = {
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 106/108] virtiofsd/passthrough_ll: Pass errno to fuse_reply_err()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (104 preceding siblings ...)
2020-01-23 16:46 ` [PULL 105/108] virtiofsd: Convert lo_destroy to take the lo->mutex lock itself Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 107/108] virtiofsd: stop all queue threads on exit in virtio_loop() Dr. David Alan Gilbert (git)
` (3 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Xiao Yang <yangx.jy@cn.fujitsu.com>
lo_copy_file_range() passes -errno to fuse_reply_err() and then fuse_reply_err()
changes it to errno again, so that subsequent fuse_send_reply_iov_nofree() catches
the wrong errno.(i.e. reports "fuse: bad error value: ...").
Make fuse_send_reply_iov_nofree() accept the correct -errno by passing errno
directly in lo_copy_file_range().
Signed-off-by: Xiao Yang <yangx.jy@cn.fujitsu.com>
Reviewed-by: Eryu Guan <eguan@linux.alibaba.com>
dgilbert: Sent upstream and now Merged as aa1185e153f774f1df65
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/passthrough_ll.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/tools/virtiofsd/passthrough_ll.c b/tools/virtiofsd/passthrough_ll.c
index fc15d61510..e6f2399efc 100644
--- a/tools/virtiofsd/passthrough_ll.c
+++ b/tools/virtiofsd/passthrough_ll.c
@@ -2441,7 +2441,7 @@ static void lo_copy_file_range(fuse_req_t req, fuse_ino_t ino_in, off_t off_in,
res = copy_file_range(in_fd, &off_in, out_fd, &off_out, len, flags);
if (res < 0) {
- fuse_reply_err(req, -errno);
+ fuse_reply_err(req, errno);
} else {
fuse_reply_write(req, res);
}
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 107/108] virtiofsd: stop all queue threads on exit in virtio_loop()
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (105 preceding siblings ...)
2020-01-23 16:46 ` [PULL 106/108] virtiofsd/passthrough_ll: Pass errno to fuse_reply_err() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 16:46 ` [PULL 108/108] virtiofsd: add some options to the help message Dr. David Alan Gilbert (git)
` (2 subsequent siblings)
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Eryu Guan <eguan@linux.alibaba.com>
On guest graceful shutdown, virtiofsd receives VHOST_USER_GET_VRING_BASE
request from VMM and shuts down virtqueues by calling fv_set_started(),
which joins fv_queue_thread() threads. So when virtio_loop() returns,
there should be no thread is still accessing data in fuse session and/or
virtio dev.
But on abnormal exit, e.g. guest got killed for whatever reason,
vhost-user socket is closed and virtio_loop() breaks out the main loop
and returns to main(). But it's possible fv_queue_worker()s are still
working and accessing fuse session and virtio dev, which results in
crash or use-after-free.
Fix it by stopping fv_queue_thread()s before virtio_loop() returns,
to make sure there's no-one could access fuse session and virtio dev.
Reported-by: Qingming Su <qingming.su@linux.alibaba.com>
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/fuse_virtio.c | 13 +++++++++++++
1 file changed, 13 insertions(+)
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index 9f6582343c..80a6e929df 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -815,6 +815,19 @@ int virtio_loop(struct fuse_session *se)
}
}
+ /*
+ * Make sure all fv_queue_thread()s quit on exit, as we're about to
+ * free virtio dev and fuse session, no one should access them anymore.
+ */
+ for (int i = 0; i < se->virtio_dev->nqueues; i++) {
+ if (!se->virtio_dev->qi[i]) {
+ continue;
+ }
+
+ fuse_log(FUSE_LOG_INFO, "%s: Stopping queue %d thread\n", __func__, i);
+ fv_queue_cleanup_thread(se->virtio_dev, i);
+ }
+
fuse_log(FUSE_LOG_INFO, "%s: Exit\n", __func__);
return 0;
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* [PULL 108/108] virtiofsd: add some options to the help message
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (106 preceding siblings ...)
2020-01-23 16:46 ` [PULL 107/108] virtiofsd: stop all queue threads on exit in virtio_loop() Dr. David Alan Gilbert (git)
@ 2020-01-23 16:46 ` Dr. David Alan Gilbert (git)
2020-01-23 19:32 ` [PULL 000/108] virtiofs queue Dr. David Alan Gilbert
2020-01-23 21:18 ` no-reply
109 siblings, 0 replies; 113+ messages in thread
From: Dr. David Alan Gilbert (git) @ 2020-01-23 16:46 UTC (permalink / raw)
To: qemu-devel, stefanha
From: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Add following options to the help message:
- cache
- flock|no_flock
- norace
- posix_lock|no_posix_lock
- readdirplus|no_readdirplus
- timeout
- writeback|no_writeback
- xattr|no_xattr
Signed-off-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
dgilbert: Split cache, norace, posix_lock, readdirplus off
into our own earlier patches that added the options
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Misono Tomohiro <misono.tomohiro@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
tools/virtiofsd/helper.c | 10 +++++++++-
1 file changed, 9 insertions(+), 1 deletion(-)
diff --git a/tools/virtiofsd/helper.c b/tools/virtiofsd/helper.c
index f98d8f2eb2..0801cf752c 100644
--- a/tools/virtiofsd/helper.c
+++ b/tools/virtiofsd/helper.c
@@ -148,6 +148,8 @@ void fuse_cmdline_help(void)
" -o cache=<mode> cache mode. could be one of \"auto, "
"always, none\"\n"
" default: auto\n"
+ " -o flock|no_flock enable/disable flock\n"
+ " default: no_flock\n"
" -o log_level=<level> log level, default to \"info\"\n"
" level could be one of \"debug, "
"info, warn, err\"\n"
@@ -163,7 +165,13 @@ void fuse_cmdline_help(void)
" enable/disable readirplus\n"
" default: readdirplus except with "
"cache=none\n"
- );
+ " -o timeout=<number> I/O timeout (second)\n"
+ " default: depends on cache= option.\n"
+ " -o writeback|no_writeback enable/disable writeback cache\n"
+ " default: no_writeback\n"
+ " -o xattr|no_xattr enable/disable xattr\n"
+ " default: no_xattr\n"
+ );
}
static int fuse_helper_opt_proc(void *data, const char *arg, int key,
--
2.24.1
^ permalink raw reply related [flat|nested] 113+ messages in thread* Re: [PULL 000/108] virtiofs queue
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (107 preceding siblings ...)
2020-01-23 16:46 ` [PULL 108/108] virtiofsd: add some options to the help message Dr. David Alan Gilbert (git)
@ 2020-01-23 19:32 ` Dr. David Alan Gilbert
2020-01-24 11:06 ` Peter Maydell
2020-01-23 21:18 ` no-reply
109 siblings, 1 reply; 113+ messages in thread
From: Dr. David Alan Gilbert @ 2020-01-23 19:32 UTC (permalink / raw)
To: qemu-devel, stefanha, peter.maydell
* Dr. David Alan Gilbert (git) (dgilbert@redhat.com) wrote:
> From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
>
> The following changes since commit b7c359c748a2e3ccb97a184b9739feb2cd48de2f:
>
> Merge remote-tracking branch 'remotes/vivier2/tags/linux-user-for-5.0-pull-request' into staging (2020-01-23 14:38:43 +0000)
>
> are available in the Git repository at:
>
> git@gitlab.com:dagrh/qemu.git tags/pull-virtiofs-20200123b
Note the public URI is:
https://gitlab.com/dagrh/qemu.git
Dave
> for you to fetch changes up to 1d59b1b210d7c3b0bdf4b10ebe0bb1fccfcb8b95:
>
> virtiofsd: add some options to the help message (2020-01-23 16:41:37 +0000)
>
> ----------------------------------------------------------------
> virtiofsd first pull v2
>
> Import our virtiofsd.
> This pulls in the daemon to drive a file system connected to the
> existing qemu virtiofsd device.
> It's derived from upstream libfuse with lots of changes (and a lot
> trimmed out).
> The daemon lives in the newly created qemu/tools/virtiofsd
>
> Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
>
> v2
> drop the docs while we discuss where they should live
> and we need to redo the manpage in anything but texi
>
> ----------------------------------------------------------------
> Dr. David Alan Gilbert (34):
> virtiofsd: Pull in upstream headers
> virtiofsd: Pull in kernel's fuse.h
> virtiofsd: Add auxiliary .c's
> virtiofsd: Add fuse_lowlevel.c
> virtiofsd: Add passthrough_ll
> virtiofsd: Trim down imported files
> virtiofsd: Format imported files to qemu style
> virtiofsd: Fix fuse_daemonize ignored return values
> virtiofsd: Fix common header and define for QEMU builds
> virtiofsd: Trim out compatibility code
> virtiofsd: Add options for virtio
> virtiofsd: Open vhost connection instead of mounting
> virtiofsd: Start wiring up vhost-user
> virtiofsd: Add main virtio loop
> virtiofsd: get/set features callbacks
> virtiofsd: Start queue threads
> virtiofsd: Poll kick_fd for queue
> virtiofsd: Start reading commands from queue
> virtiofsd: Send replies to messages
> virtiofsd: Keep track of replies
> virtiofsd: Add Makefile wiring for virtiofsd contrib
> virtiofsd: Fast path for virtio read
> virtiofs: Add maintainers entry
> virtiofsd: Plumb fuse_bufvec through to do_write_buf
> virtiofsd: Pass write iov's all the way through
> virtiofsd: cap-ng helpers
> virtiofsd: Handle reinit
> virtiofsd: Handle hard reboot
> virtiofsd: Kill threads when queues are stopped
> vhost-user: Print unexpected slave message types
> contrib/libvhost-user: Protect slave fd with mutex
> virtiofsd: Clean up inodes on destroy
> libvhost-user: Fix some memtable remap cases
> virtiofsd: Convert lo_destroy to take the lo->mutex lock itself
>
> Eric Ren (1):
> virtiofsd: fix incorrect error handling in lo_do_lookup
>
> Eryu Guan (3):
> virtiofsd: print log only when priority is high enough
> virtiofsd: convert more fprintf and perror to use fuse log infra
> virtiofsd: stop all queue threads on exit in virtio_loop()
>
> Jiufei Xue (1):
> virtiofsd: support nanosecond resolution for file timestamp
>
> Liu Bo (6):
> virtiofsd: fix error handling in main()
> virtiofsd: cleanup allocated resource in se
> virtiofsd: fix memory leak on lo.source
> virtiofsd: add helper for lo_data cleanup
> virtiofsd: enable PARALLEL_DIROPS during INIT
> Virtiofsd: fix memory leak on fuse queueinfo
>
> Masayoshi Mizuma (4):
> virtiofsd: Add ID to the log with FUSE_LOG_DEBUG level
> virtiofsd: Add timestamp to the log with FUSE_LOG_DEBUG level
> virtiofsd: Prevent multiply running with same vhost_user_socket
> virtiofsd: add some options to the help message
>
> Miklos Szeredi (10):
> virtiofsd: passthrough_ll: add fallback for racy ops
> virtiofsd: passthrough_ll: add renameat2 support
> virtiofsd: passthrough_ll: disable readdirplus on cache=never
> virtiofsd: passthrough_ll: control readdirplus
> virtiofsd: rename unref_inode() to unref_inode_lolocked()
> virtiofsd: fail when parent inode isn't known in lo_do_lookup()
> virtiofsd: extract root inode init into setup_root()
> virtiofsd: passthrough_ll: clean up cache related options
> virtiofsd: passthrough_ll: use hashtable
> virtiofsd: passthrough_ll: fix refcounting on remove/rename
>
> Misono Tomohiro (2):
> virtiofsd: Fix data corruption with O_APPEND write in writeback mode
> virtiofsd: passthrough_ll: Use cache_readdir for directory open
>
> Peng Tao (1):
> virtiofsd: do not always set FUSE_FLOCK_LOCKS
>
> Stefan Hajnoczi (35):
> virtiofsd: remove mountpoint dummy argument
> virtiofsd: remove unused notify reply support
> virtiofsd: add -o source=PATH to help output
> virtiofsd: add --fd=FDNUM fd passing option
> virtiofsd: make -f (foreground) the default
> virtiofsd: add vhost-user.json file
> virtiofsd: add --print-capabilities option
> virtiofsd: passthrough_ll: add lo_map for ino/fh indirection
> virtiofsd: passthrough_ll: add ino_map to hide lo_inode pointers
> virtiofsd: passthrough_ll: add dirp_map to hide lo_dirp pointers
> virtiofsd: passthrough_ll: add fd_map to hide file descriptors
> virtiofsd: validate path components
> virtiofsd: add fuse_mbuf_iter API
> virtiofsd: validate input buffer sizes in do_write_buf()
> virtiofsd: check input buffer size in fuse_lowlevel.c ops
> virtiofsd: prevent ".." escape in lo_do_lookup()
> virtiofsd: prevent ".." escape in lo_do_readdir()
> virtiofsd: use /proc/self/fd/ O_PATH file descriptor
> virtiofsd: sandbox mount namespace
> virtiofsd: move to an empty network namespace
> virtiofsd: move to a new pid namespace
> virtiofsd: add seccomp whitelist
> virtiofsd: set maximum RLIMIT_NOFILE limit
> virtiofsd: fix libfuse information leaks
> virtiofsd: add --syslog command-line option
> virtiofsd: use fuse_lowlevel_is_virtio() in fuse_session_destroy()
> virtiofsd: prevent fv_queue_thread() vs virtio_loop() races
> virtiofsd: make lo_release() atomic
> virtiofsd: prevent races with lo_dirp_put()
> virtiofsd: rename inode->refcount to inode->nlookup
> virtiofsd: introduce inode refcount to prevent use-after-free
> virtiofsd: process requests in a thread pool
> virtiofsd: prevent FUSE_INIT/FUSE_DESTROY races
> virtiofsd: fix lo_destroy() resource leaks
> virtiofsd: add --thread-pool-size=NUM option
>
> Vivek Goyal (6):
> virtiofsd: Make fsync work even if only inode is passed in
> virtiofsd: passthrough_ll: create new files in caller's context
> virtiofsd: Parse flag FUSE_WRITE_KILL_PRIV
> virtiofsd: Drop CAP_FSETID if client asked for it
> virtiofsd: Support remote posix locks
> virtiofsd: Reset O_DIRECT flag during file open
>
> Xiao Yang (3):
> virtiofsd: Remove unused enum fuse_buf_copy_flags
> vitriofsd/passthrough_ll: fix fallocate() ifdefs
> virtiofsd/passthrough_ll: Pass errno to fuse_reply_err()
>
> piaojun (2):
> virtiofsd: add definition of fuse_buf_writev()
> virtiofsd: use fuse_buf_writev to replace fuse_buf_write for better performance
>
> .gitignore | 1 +
> MAINTAINERS | 8 +
> Makefile | 12 +
> Makefile.objs | 1 +
> configure | 16 +
> contrib/libvhost-user/libvhost-user.c | 57 +-
> contrib/libvhost-user/libvhost-user.h | 6 +
> docs/interop/vhost-user.json | 4 +-
> hw/virtio/vhost-user.c | 2 +-
> include/standard-headers/linux/fuse.h | 891 +++++++++
> scripts/update-linux-headers.sh | 1 +
> tools/virtiofsd/50-qemu-virtiofsd.json.in | 5 +
> tools/virtiofsd/Makefile.objs | 12 +
> tools/virtiofsd/buffer.c | 351 ++++
> tools/virtiofsd/fuse.h | 1249 ++++++++++++
> tools/virtiofsd/fuse_common.h | 816 ++++++++
> tools/virtiofsd/fuse_i.h | 115 ++
> tools/virtiofsd/fuse_log.c | 41 +
> tools/virtiofsd/fuse_log.h | 74 +
> tools/virtiofsd/fuse_lowlevel.c | 2761 ++++++++++++++++++++++++++
> tools/virtiofsd/fuse_lowlevel.h | 1991 +++++++++++++++++++
> tools/virtiofsd/fuse_misc.h | 60 +
> tools/virtiofsd/fuse_opt.c | 450 +++++
> tools/virtiofsd/fuse_opt.h | 272 +++
> tools/virtiofsd/fuse_signals.c | 98 +
> tools/virtiofsd/fuse_virtio.c | 986 ++++++++++
> tools/virtiofsd/fuse_virtio.h | 33 +
> tools/virtiofsd/helper.c | 349 ++++
> tools/virtiofsd/passthrough_helpers.h | 51 +
> tools/virtiofsd/passthrough_ll.c | 3006 +++++++++++++++++++++++++++++
> tools/virtiofsd/seccomp.c | 165 ++
> tools/virtiofsd/seccomp.h | 16 +
> 32 files changed, 13886 insertions(+), 14 deletions(-)
> create mode 100644 include/standard-headers/linux/fuse.h
> create mode 100644 tools/virtiofsd/50-qemu-virtiofsd.json.in
> create mode 100644 tools/virtiofsd/Makefile.objs
> create mode 100644 tools/virtiofsd/buffer.c
> create mode 100644 tools/virtiofsd/fuse.h
> create mode 100644 tools/virtiofsd/fuse_common.h
> create mode 100644 tools/virtiofsd/fuse_i.h
> create mode 100644 tools/virtiofsd/fuse_log.c
> create mode 100644 tools/virtiofsd/fuse_log.h
> create mode 100644 tools/virtiofsd/fuse_lowlevel.c
> create mode 100644 tools/virtiofsd/fuse_lowlevel.h
> create mode 100644 tools/virtiofsd/fuse_misc.h
> create mode 100644 tools/virtiofsd/fuse_opt.c
> create mode 100644 tools/virtiofsd/fuse_opt.h
> create mode 100644 tools/virtiofsd/fuse_signals.c
> create mode 100644 tools/virtiofsd/fuse_virtio.c
> create mode 100644 tools/virtiofsd/fuse_virtio.h
> create mode 100644 tools/virtiofsd/helper.c
> create mode 100644 tools/virtiofsd/passthrough_helpers.h
> create mode 100644 tools/virtiofsd/passthrough_ll.c
> create mode 100644 tools/virtiofsd/seccomp.c
> create mode 100644 tools/virtiofsd/seccomp.h
>
>
--
Dr. David Alan Gilbert / dgilbert@redhat.com / Manchester, UK
^ permalink raw reply [flat|nested] 113+ messages in thread* Re: [PULL 000/108] virtiofs queue
2020-01-23 19:32 ` [PULL 000/108] virtiofs queue Dr. David Alan Gilbert
@ 2020-01-24 11:06 ` Peter Maydell
0 siblings, 0 replies; 113+ messages in thread
From: Peter Maydell @ 2020-01-24 11:06 UTC (permalink / raw)
To: Dr. David Alan Gilbert; +Cc: QEMU Developers, Stefan Hajnoczi
On Thu, 23 Jan 2020 at 19:32, Dr. David Alan Gilbert
<dgilbert@redhat.com> wrote:
>
> * Dr. David Alan Gilbert (git) (dgilbert@redhat.com) wrote:
> > From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
> >
> > The following changes since commit b7c359c748a2e3ccb97a184b9739feb2cd48de2f:
> >
> > Merge remote-tracking branch 'remotes/vivier2/tags/linux-user-for-5.0-pull-request' into staging (2020-01-23 14:38:43 +0000)
> >
> > are available in the Git repository at:
> >
> > git@gitlab.com:dagrh/qemu.git tags/pull-virtiofs-20200123b
>
> Note the public URI is:
>
> https://gitlab.com/dagrh/qemu.git
Applied, thanks.
Please update the changelog at https://wiki.qemu.org/ChangeLog/5.0
for any user-visible changes.
-- PMM
^ permalink raw reply [flat|nested] 113+ messages in thread
* Re: [PULL 000/108] virtiofs queue
2020-01-23 16:44 [PULL 000/108] virtiofs queue Dr. David Alan Gilbert (git)
` (108 preceding siblings ...)
2020-01-23 19:32 ` [PULL 000/108] virtiofs queue Dr. David Alan Gilbert
@ 2020-01-23 21:18 ` no-reply
109 siblings, 0 replies; 113+ messages in thread
From: no-reply @ 2020-01-23 21:18 UTC (permalink / raw)
To: dgilbert; +Cc: qemu-devel, stefanha
Patchew URL: https://patchew.org/QEMU/20200123164630.91498-1-dgilbert@redhat.com/
Hi,
This series seems to have some coding style problems. See output below for
more information:
Type: series
Message-id: 20200123164630.91498-1-dgilbert@redhat.com
Subject: [PULL 000/108] virtiofs queue
=== TEST SCRIPT BEGIN ===
#!/bin/bash
git rev-parse base > /dev/null || exit 0
git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram
./scripts/checkpatch.pl --mailback base..
=== TEST SCRIPT END ===
Updating 3c8cf5a9c21ff8782164d1def7f44bd888713384
From https://github.com/patchew-project/qemu
- [tag update] patchew/20200123170544.30117-1-kwolf@redhat.com -> patchew/20200123170544.30117-1-kwolf@redhat.com
Switched to a new branch 'test'
02e4c6d virtiofsd: add some options to the help message
91b9210 virtiofsd: stop all queue threads on exit in virtio_loop()
9325310 virtiofsd/passthrough_ll: Pass errno to fuse_reply_err()
698292e virtiofsd: Convert lo_destroy to take the lo->mutex lock itself
72ece8f virtiofsd: add --thread-pool-size=NUM option
87504eb virtiofsd: fix lo_destroy() resource leaks
b573bdd virtiofsd: prevent FUSE_INIT/FUSE_DESTROY races
322bbdc virtiofsd: process requests in a thread pool
0e583a1 virtiofsd: use fuse_buf_writev to replace fuse_buf_write for better performance
4fda6a6 virtiofsd: add definition of fuse_buf_writev()
1f67fb7 virtiofsd: passthrough_ll: Use cache_readdir for directory open
9e739a1 virtiofsd: Fix data corruption with O_APPEND write in writeback mode
e5ee594 virtiofsd: Reset O_DIRECT flag during file open
269002e virtiofsd: convert more fprintf and perror to use fuse log infra
649aa49 virtiofsd: do not always set FUSE_FLOCK_LOCKS
a769832 virtiofsd: introduce inode refcount to prevent use-after-free
c70b7ee virtiofsd: passthrough_ll: fix refcounting on remove/rename
604298d libvhost-user: Fix some memtable remap cases
2ad1f55 virtiofsd: rename inode->refcount to inode->nlookup
f00cb4e virtiofsd: prevent races with lo_dirp_put()
b6ff58c virtiofsd: make lo_release() atomic
c1c535a virtiofsd: prevent fv_queue_thread() vs virtio_loop() races
aead534 virtiofsd: use fuse_lowlevel_is_virtio() in fuse_session_destroy()
b76abf5 virtiofsd: Support remote posix locks
6902eb8 Virtiofsd: fix memory leak on fuse queueinfo
be5097a virtiofsd: fix incorrect error handling in lo_do_lookup
9006657 virtiofsd: enable PARALLEL_DIROPS during INIT
4706f46 virtiofsd: Prevent multiply running with same vhost_user_socket
f211a36 virtiofsd: add helper for lo_data cleanup
38200c6 virtiofsd: fix memory leak on lo.source
7f99afc virtiofsd: cleanup allocated resource in se
a1522ea virtiofsd: fix error handling in main()
f0e3fbc virtiofsd: support nanosecond resolution for file timestamp
0220aed virtiofsd: Clean up inodes on destroy
7a380f3 virtiofsd: passthrough_ll: use hashtable
1e21a9c virtiofsd: passthrough_ll: clean up cache related options
1b05316 virtiofsd: extract root inode init into setup_root()
1c063c8 virtiofsd: fail when parent inode isn't known in lo_do_lookup()
7ddb8e2 virtiofsd: rename unref_inode() to unref_inode_lolocked()
4dd6c3a virtiofsd: passthrough_ll: control readdirplus
b9097c9 virtiofsd: passthrough_ll: disable readdirplus on cache=never
c0279a6 virtiofsd: passthrough_ll: add renameat2 support
824a1db contrib/libvhost-user: Protect slave fd with mutex
851e8ec vhost-user: Print unexpected slave message types
818e2fc virtiofsd: Kill threads when queues are stopped
f04fe35 virtiofsd: Handle hard reboot
4002eb6 virtiofsd: Handle reinit
c257992 virtiofsd: Add timestamp to the log with FUSE_LOG_DEBUG level
fb926ee virtiofsd: Add ID to the log with FUSE_LOG_DEBUG level
776503c virtiofsd: print log only when priority is high enough
d19e062 virtiofsd: add --syslog command-line option
788d319 virtiofsd: fix libfuse information leaks
8b61e80 virtiofsd: set maximum RLIMIT_NOFILE limit
e137992 virtiofsd: Drop CAP_FSETID if client asked for it
9cc34cc virtiofsd: cap-ng helpers
7a02936 virtiofsd: Parse flag FUSE_WRITE_KILL_PRIV
95d60ee virtiofsd: add seccomp whitelist
eb214a7 virtiofsd: move to a new pid namespace
3228cd4 virtiofsd: move to an empty network namespace
f20606a virtiofsd: sandbox mount namespace
b8b6552 virtiofsd: use /proc/self/fd/ O_PATH file descriptor
c3f5b07 virtiofsd: prevent ".." escape in lo_do_readdir()
3cb4463 virtiofsd: prevent ".." escape in lo_do_lookup()
3d11f12 virtiofsd: check input buffer size in fuse_lowlevel.c ops
38b34ea virtiofsd: validate input buffer sizes in do_write_buf()
9c34b09 virtiofsd: add fuse_mbuf_iter API
6b7914f virtiofsd: Pass write iov's all the way through
78d7979 virtiofsd: Plumb fuse_bufvec through to do_write_buf
408f8a1 virtiofsd: validate path components
bca92ad virtiofsd: passthrough_ll: add fallback for racy ops
3ed5357 virtiofsd: passthrough_ll: add fd_map to hide file descriptors
fad5ec7 virtiofsd: passthrough_ll: add dirp_map to hide lo_dirp pointers
db71a83 virtiofsd: passthrough_ll: add ino_map to hide lo_inode pointers
5a8812e virtiofsd: passthrough_ll: add lo_map for ino/fh indirection
d66da85 virtiofsd: passthrough_ll: create new files in caller's context
cffa2ea virtiofs: Add maintainers entry
c317252 virtiofsd: add --print-capabilities option
f437f8d virtiofsd: add vhost-user.json file
bd6c9f4 virtiofsd: make -f (foreground) the default
312e7d4 virtiofsd: add --fd=FDNUM fd passing option
52a2eec virtiofsd: Fast path for virtio read
ca3b0f6 virtiofsd: Add Makefile wiring for virtiofsd contrib
9e7093d virtiofsd: Keep track of replies
5bece7b virtiofsd: Send replies to messages
1372ebd virtiofsd: Start reading commands from queue
36e6c52 virtiofsd: Poll kick_fd for queue
440938d virtiofsd: Start queue threads
ad8b170 virtiofsd: get/set features callbacks
287b48c virtiofsd: Add main virtio loop
fef307e virtiofsd: Start wiring up vhost-user
0839049 virtiofsd: Open vhost connection instead of mounting
87cb3ca virtiofsd: add -o source=PATH to help output
a6f8a68 virtiofsd: Add options for virtio
01b4a15 virtiofsd: Make fsync work even if only inode is passed in
674d18b vitriofsd/passthrough_ll: fix fallocate() ifdefs
afdaf8e virtiofsd: Trim out compatibility code
85d350a virtiofsd: Fix common header and define for QEMU builds
470bf03 virtiofsd: Fix fuse_daemonize ignored return values
988582c virtiofsd: Remove unused enum fuse_buf_copy_flags
e0ade3b virtiofsd: remove unused notify reply support
40408f0 virtiofsd: remove mountpoint dummy argument
c695a07 virtiofsd: Format imported files to qemu style
4de66b5 virtiofsd: Trim down imported files
b0e9634 virtiofsd: Add passthrough_ll
dcd7ad1 virtiofsd: Add fuse_lowlevel.c
40b6782 virtiofsd: Add auxiliary .c's
63a5daf virtiofsd: Pull in kernel's fuse.h
ed88b1c virtiofsd: Pull in upstream headers
=== OUTPUT BEGIN ===
1/108 Checking commit ed88b1c5bf93 (virtiofsd: Pull in upstream headers)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#16:
new file mode 100644
WARNING: Block comments use * on subsequent lines
#22: FILE: tools/virtiofsd/fuse.h:2:
+/*
+ FUSE: Filesystem in Userspace
WARNING: Block comments use a leading /* on a separate line
#32: FILE: tools/virtiofsd/fuse.h:12:
+/** @file
WARNING: architecture specific defines should be avoided
#48: FILE: tools/virtiofsd/fuse.h:28:
+#ifdef __cplusplus
WARNING: Block comments use a leading /* on a separate line
#52: FILE: tools/virtiofsd/fuse.h:32:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#53: FILE: tools/virtiofsd/fuse.h:33:
+ * Basic FUSE API^I^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#54: FILE: tools/virtiofsd/fuse.h:34:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#63: FILE: tools/virtiofsd/fuse.h:43:
+^I/**$
ERROR: code indent should never use tabs
#64: FILE: tools/virtiofsd/fuse.h:44:
+^I * "Plus" mode.$
ERROR: code indent should never use tabs
#65: FILE: tools/virtiofsd/fuse.h:45:
+^I *$
ERROR: code indent should never use tabs
#66: FILE: tools/virtiofsd/fuse.h:46:
+^I * The kernel wants to prefill the inode cache during readdir. The$
ERROR: code indent should never use tabs
#67: FILE: tools/virtiofsd/fuse.h:47:
+^I * filesystem may honour this by filling in the attributes and setting$
ERROR: code indent should never use tabs
#68: FILE: tools/virtiofsd/fuse.h:48:
+^I * FUSE_FILL_DIR_FLAGS for the filler function. The filesystem may also$
ERROR: code indent should never use tabs
#69: FILE: tools/virtiofsd/fuse.h:49:
+^I * just ignore this flag completely.$
ERROR: code indent should never use tabs
#70: FILE: tools/virtiofsd/fuse.h:50:
+^I */$
ERROR: code indent should never use tabs
#71: FILE: tools/virtiofsd/fuse.h:51:
+^IFUSE_READDIR_PLUS = (1 << 0),$
ERROR: code indent should never use tabs
#75: FILE: tools/virtiofsd/fuse.h:55:
+^I/**$
ERROR: code indent should never use tabs
#76: FILE: tools/virtiofsd/fuse.h:56:
+^I * "Plus" mode: all file attributes are valid$
ERROR: code indent should never use tabs
#77: FILE: tools/virtiofsd/fuse.h:57:
+^I *$
ERROR: code indent should never use tabs
#78: FILE: tools/virtiofsd/fuse.h:58:
+^I * The attributes are used by the kernel to prefill the inode cache$
ERROR: code indent should never use tabs
#79: FILE: tools/virtiofsd/fuse.h:59:
+^I * during a readdir.$
ERROR: code indent should never use tabs
#80: FILE: tools/virtiofsd/fuse.h:60:
+^I *$
ERROR: code indent should never use tabs
#81: FILE: tools/virtiofsd/fuse.h:61:
+^I * It is okay to set FUSE_FILL_DIR_PLUS if FUSE_READDIR_PLUS is not set$
ERROR: code indent should never use tabs
#82: FILE: tools/virtiofsd/fuse.h:62:
+^I * and vice versa.$
ERROR: code indent should never use tabs
#83: FILE: tools/virtiofsd/fuse.h:63:
+^I */$
ERROR: code indent should never use tabs
#84: FILE: tools/virtiofsd/fuse.h:64:
+^IFUSE_FILL_DIR_PLUS = (1 << 1),$
WARNING: Block comments use a leading /* on a separate line
#87: FILE: tools/virtiofsd/fuse.h:67:
+/** Function to add an entry in a readdir() operation
ERROR: trailing whitespace
#94: FILE: tools/virtiofsd/fuse.h:74:
+ * $
ERROR: code indent should never use tabs
#103: FILE: tools/virtiofsd/fuse.h:83:
+^I^I^I^Iconst struct stat *stbuf, off_t off,$
ERROR: code indent should never use tabs
#104: FILE: tools/virtiofsd/fuse.h:84:
+^I^I^I^Ienum fuse_fill_dir_flags flags);$
ERROR: code indent should never use tabs
#114: FILE: tools/virtiofsd/fuse.h:94:
+^I/**$
ERROR: code indent should never use tabs
#115: FILE: tools/virtiofsd/fuse.h:95:
+^I * If `set_gid` is non-zero, the st_gid attribute of each file$
ERROR: code indent should never use tabs
#116: FILE: tools/virtiofsd/fuse.h:96:
+^I * is overwritten with the value of `gid`.$
ERROR: code indent should never use tabs
#117: FILE: tools/virtiofsd/fuse.h:97:
+^I */$
ERROR: code indent should never use tabs
#118: FILE: tools/virtiofsd/fuse.h:98:
+^Iint set_gid;$
ERROR: code indent should never use tabs
#119: FILE: tools/virtiofsd/fuse.h:99:
+^Iunsigned int gid;$
ERROR: code indent should never use tabs
#121: FILE: tools/virtiofsd/fuse.h:101:
+^I/**$
ERROR: code indent should never use tabs
#122: FILE: tools/virtiofsd/fuse.h:102:
+^I * If `set_uid` is non-zero, the st_uid attribute of each file$
ERROR: code indent should never use tabs
#123: FILE: tools/virtiofsd/fuse.h:103:
+^I * is overwritten with the value of `uid`.$
ERROR: code indent should never use tabs
#124: FILE: tools/virtiofsd/fuse.h:104:
+^I */$
ERROR: code indent should never use tabs
#125: FILE: tools/virtiofsd/fuse.h:105:
+^Iint set_uid;$
ERROR: code indent should never use tabs
#126: FILE: tools/virtiofsd/fuse.h:106:
+^Iunsigned int uid;$
ERROR: code indent should never use tabs
#128: FILE: tools/virtiofsd/fuse.h:108:
+^I/**$
ERROR: code indent should never use tabs
#129: FILE: tools/virtiofsd/fuse.h:109:
+^I * If `set_mode` is non-zero, the any permissions bits set in$
ERROR: code indent should never use tabs
#130: FILE: tools/virtiofsd/fuse.h:110:
+^I * `umask` are unset in the st_mode attribute of each file.$
ERROR: code indent should never use tabs
#131: FILE: tools/virtiofsd/fuse.h:111:
+^I */$
ERROR: code indent should never use tabs
#132: FILE: tools/virtiofsd/fuse.h:112:
+^Iint set_mode;$
ERROR: code indent should never use tabs
#133: FILE: tools/virtiofsd/fuse.h:113:
+^Iunsigned int umask;$
ERROR: code indent should never use tabs
#135: FILE: tools/virtiofsd/fuse.h:115:
+^I/**$
ERROR: code indent should never use tabs
#136: FILE: tools/virtiofsd/fuse.h:116:
+^I * The timeout in seconds for which name lookups will be$
ERROR: code indent should never use tabs
#137: FILE: tools/virtiofsd/fuse.h:117:
+^I * cached.$
ERROR: code indent should never use tabs
#138: FILE: tools/virtiofsd/fuse.h:118:
+^I */$
ERROR: code indent should never use tabs
#139: FILE: tools/virtiofsd/fuse.h:119:
+^Idouble entry_timeout;$
ERROR: code indent should never use tabs
#141: FILE: tools/virtiofsd/fuse.h:121:
+^I/**$
ERROR: code indent should never use tabs
#142: FILE: tools/virtiofsd/fuse.h:122:
+^I * The timeout in seconds for which a negative lookup will be$
ERROR: code indent should never use tabs
#143: FILE: tools/virtiofsd/fuse.h:123:
+^I * cached. This means, that if file did not exist (lookup$
ERROR: code indent should never use tabs
#144: FILE: tools/virtiofsd/fuse.h:124:
+^I * retuned ENOENT), the lookup will only be redone after the$
ERROR: code indent should never use tabs
#145: FILE: tools/virtiofsd/fuse.h:125:
+^I * timeout, and the file/directory will be assumed to not$
ERROR: code indent should never use tabs
#146: FILE: tools/virtiofsd/fuse.h:126:
+^I * exist until then. A value of zero means that negative$
ERROR: code indent should never use tabs
#147: FILE: tools/virtiofsd/fuse.h:127:
+^I * lookups are not cached.$
ERROR: code indent should never use tabs
#148: FILE: tools/virtiofsd/fuse.h:128:
+^I */$
ERROR: code indent should never use tabs
#149: FILE: tools/virtiofsd/fuse.h:129:
+^Idouble negative_timeout;$
ERROR: code indent should never use tabs
#151: FILE: tools/virtiofsd/fuse.h:131:
+^I/**$
ERROR: code indent should never use tabs
#152: FILE: tools/virtiofsd/fuse.h:132:
+^I * The timeout in seconds for which file/directory attributes$
ERROR: code indent should never use tabs
#153: FILE: tools/virtiofsd/fuse.h:133:
+^I * (as returned by e.g. the `getattr` handler) are cached.$
ERROR: code indent should never use tabs
#154: FILE: tools/virtiofsd/fuse.h:134:
+^I */$
ERROR: code indent should never use tabs
#155: FILE: tools/virtiofsd/fuse.h:135:
+^Idouble attr_timeout;$
ERROR: code indent should never use tabs
#157: FILE: tools/virtiofsd/fuse.h:137:
+^I/**$
ERROR: code indent should never use tabs
#158: FILE: tools/virtiofsd/fuse.h:138:
+^I * Allow requests to be interrupted$
ERROR: code indent should never use tabs
#159: FILE: tools/virtiofsd/fuse.h:139:
+^I */$
ERROR: code indent should never use tabs
#160: FILE: tools/virtiofsd/fuse.h:140:
+^Iint intr;$
ERROR: code indent should never use tabs
#162: FILE: tools/virtiofsd/fuse.h:142:
+^I/**$
ERROR: code indent should never use tabs
#163: FILE: tools/virtiofsd/fuse.h:143:
+^I * Specify which signal number to send to the filesystem when$
ERROR: code indent should never use tabs
#164: FILE: tools/virtiofsd/fuse.h:144:
+^I * a request is interrupted. The default is hardcoded to$
ERROR: code indent should never use tabs
#165: FILE: tools/virtiofsd/fuse.h:145:
+^I * USR1.$
ERROR: code indent should never use tabs
#166: FILE: tools/virtiofsd/fuse.h:146:
+^I */$
ERROR: code indent should never use tabs
#167: FILE: tools/virtiofsd/fuse.h:147:
+^Iint intr_signal;$
ERROR: code indent should never use tabs
#169: FILE: tools/virtiofsd/fuse.h:149:
+^I/**$
ERROR: code indent should never use tabs
#170: FILE: tools/virtiofsd/fuse.h:150:
+^I * Normally, FUSE assigns inodes to paths only for as long as$
ERROR: code indent should never use tabs
#171: FILE: tools/virtiofsd/fuse.h:151:
+^I * the kernel is aware of them. With this option inodes are$
ERROR: code indent should never use tabs
#172: FILE: tools/virtiofsd/fuse.h:152:
+^I * instead remembered for at least this many seconds. This$
ERROR: code indent should never use tabs
#173: FILE: tools/virtiofsd/fuse.h:153:
+^I * will require more memory, but may be necessary when using$
ERROR: code indent should never use tabs
#174: FILE: tools/virtiofsd/fuse.h:154:
+^I * applications that make use of inode numbers.$
ERROR: code indent should never use tabs
#175: FILE: tools/virtiofsd/fuse.h:155:
+^I *$
ERROR: code indent should never use tabs
#176: FILE: tools/virtiofsd/fuse.h:156:
+^I * A number of -1 means that inodes will be remembered for the$
ERROR: code indent should never use tabs
#177: FILE: tools/virtiofsd/fuse.h:157:
+^I * entire life-time of the file-system process.$
ERROR: code indent should never use tabs
#178: FILE: tools/virtiofsd/fuse.h:158:
+^I */$
ERROR: code indent should never use tabs
#179: FILE: tools/virtiofsd/fuse.h:159:
+^Iint remember;$
ERROR: code indent should never use tabs
#181: FILE: tools/virtiofsd/fuse.h:161:
+^I/**$
ERROR: code indent should never use tabs
#182: FILE: tools/virtiofsd/fuse.h:162:
+^I * The default behavior is that if an open file is deleted,$
ERROR: code indent should never use tabs
#183: FILE: tools/virtiofsd/fuse.h:163:
+^I * the file is renamed to a hidden file (.fuse_hiddenXXX), and$
ERROR: code indent should never use tabs
#184: FILE: tools/virtiofsd/fuse.h:164:
+^I * only removed when the file is finally released. This$
ERROR: code indent should never use tabs
#185: FILE: tools/virtiofsd/fuse.h:165:
+^I * relieves the filesystem implementation of having to deal$
ERROR: code indent should never use tabs
#186: FILE: tools/virtiofsd/fuse.h:166:
+^I * with this problem. This option disables the hiding$
ERROR: code indent should never use tabs
#187: FILE: tools/virtiofsd/fuse.h:167:
+^I * behavior, and files are removed immediately in an unlink$
ERROR: code indent should never use tabs
#188: FILE: tools/virtiofsd/fuse.h:168:
+^I * operation (or in a rename operation which overwrites an$
ERROR: code indent should never use tabs
#189: FILE: tools/virtiofsd/fuse.h:169:
+^I * existing file).$
ERROR: code indent should never use tabs
#190: FILE: tools/virtiofsd/fuse.h:170:
+^I *$
ERROR: code indent should never use tabs
#191: FILE: tools/virtiofsd/fuse.h:171:
+^I * It is recommended that you not use the hard_remove$
ERROR: code indent should never use tabs
#192: FILE: tools/virtiofsd/fuse.h:172:
+^I * option. When hard_remove is set, the following libc$
ERROR: code indent should never use tabs
#193: FILE: tools/virtiofsd/fuse.h:173:
+^I * functions fail on unlinked files (returning errno of$
ERROR: code indent should never use tabs
#194: FILE: tools/virtiofsd/fuse.h:174:
+^I * ENOENT): read(2), write(2), fsync(2), close(2), f*xattr(2),$
ERROR: code indent should never use tabs
#195: FILE: tools/virtiofsd/fuse.h:175:
+^I * ftruncate(2), fstat(2), fchmod(2), fchown(2)$
ERROR: code indent should never use tabs
#196: FILE: tools/virtiofsd/fuse.h:176:
+^I */$
ERROR: code indent should never use tabs
#197: FILE: tools/virtiofsd/fuse.h:177:
+^Iint hard_remove;$
ERROR: code indent should never use tabs
#199: FILE: tools/virtiofsd/fuse.h:179:
+^I/**$
ERROR: code indent should never use tabs
#200: FILE: tools/virtiofsd/fuse.h:180:
+^I * Honor the st_ino field in the functions getattr() and$
ERROR: code indent should never use tabs
#201: FILE: tools/virtiofsd/fuse.h:181:
+^I * fill_dir(). This value is used to fill in the st_ino field$
ERROR: code indent should never use tabs
#202: FILE: tools/virtiofsd/fuse.h:182:
+^I * in the stat(2), lstat(2), fstat(2) functions and the d_ino$
ERROR: code indent should never use tabs
#203: FILE: tools/virtiofsd/fuse.h:183:
+^I * field in the readdir(2) function. The filesystem does not$
ERROR: code indent should never use tabs
#204: FILE: tools/virtiofsd/fuse.h:184:
+^I * have to guarantee uniqueness, however some applications$
ERROR: code indent should never use tabs
#205: FILE: tools/virtiofsd/fuse.h:185:
+^I * rely on this value being unique for the whole filesystem.$
ERROR: code indent should never use tabs
#206: FILE: tools/virtiofsd/fuse.h:186:
+^I *$
ERROR: trailing whitespace
#207: FILE: tools/virtiofsd/fuse.h:187:
+^I * Note that this does *not* affect the inode that libfuse $
ERROR: code indent should never use tabs
#207: FILE: tools/virtiofsd/fuse.h:187:
+^I * Note that this does *not* affect the inode that libfuse $
ERROR: code indent should never use tabs
#208: FILE: tools/virtiofsd/fuse.h:188:
+^I * and the kernel use internally (also called the "nodeid").$
ERROR: code indent should never use tabs
#209: FILE: tools/virtiofsd/fuse.h:189:
+^I */$
ERROR: code indent should never use tabs
#210: FILE: tools/virtiofsd/fuse.h:190:
+^Iint use_ino;$
ERROR: code indent should never use tabs
#212: FILE: tools/virtiofsd/fuse.h:192:
+^I/**$
ERROR: code indent should never use tabs
#213: FILE: tools/virtiofsd/fuse.h:193:
+^I * If use_ino option is not given, still try to fill in the$
ERROR: code indent should never use tabs
#214: FILE: tools/virtiofsd/fuse.h:194:
+^I * d_ino field in readdir(2). If the name was previously$
ERROR: code indent should never use tabs
#215: FILE: tools/virtiofsd/fuse.h:195:
+^I * looked up, and is still in the cache, the inode number$
ERROR: code indent should never use tabs
#216: FILE: tools/virtiofsd/fuse.h:196:
+^I * found there will be used. Otherwise it will be set to -1.$
ERROR: code indent should never use tabs
#217: FILE: tools/virtiofsd/fuse.h:197:
+^I * If use_ino option is given, this option is ignored.$
ERROR: code indent should never use tabs
#218: FILE: tools/virtiofsd/fuse.h:198:
+^I */$
ERROR: code indent should never use tabs
#219: FILE: tools/virtiofsd/fuse.h:199:
+^Iint readdir_ino;$
ERROR: code indent should never use tabs
#221: FILE: tools/virtiofsd/fuse.h:201:
+^I/**$
ERROR: code indent should never use tabs
#222: FILE: tools/virtiofsd/fuse.h:202:
+^I * This option disables the use of page cache (file content cache)$
ERROR: code indent should never use tabs
#223: FILE: tools/virtiofsd/fuse.h:203:
+^I * in the kernel for this filesystem. This has several affects:$
ERROR: code indent should never use tabs
#224: FILE: tools/virtiofsd/fuse.h:204:
+^I *$
ERROR: code indent should never use tabs
#225: FILE: tools/virtiofsd/fuse.h:205:
+^I * 1. Each read(2) or write(2) system call will initiate one$
ERROR: code indent should never use tabs
#226: FILE: tools/virtiofsd/fuse.h:206:
+^I * or more read or write operations, data will not be$
ERROR: code indent should never use tabs
#227: FILE: tools/virtiofsd/fuse.h:207:
+^I * cached in the kernel.$
ERROR: code indent should never use tabs
#228: FILE: tools/virtiofsd/fuse.h:208:
+^I *$
ERROR: code indent should never use tabs
#229: FILE: tools/virtiofsd/fuse.h:209:
+^I * 2. The return value of the read() and write() system calls$
ERROR: code indent should never use tabs
#230: FILE: tools/virtiofsd/fuse.h:210:
+^I * will correspond to the return values of the read and$
ERROR: code indent should never use tabs
#231: FILE: tools/virtiofsd/fuse.h:211:
+^I * write operations. This is useful for example if the$
ERROR: code indent should never use tabs
#232: FILE: tools/virtiofsd/fuse.h:212:
+^I * file size is not known in advance (before reading it).$
ERROR: code indent should never use tabs
#233: FILE: tools/virtiofsd/fuse.h:213:
+^I *$
ERROR: code indent should never use tabs
#234: FILE: tools/virtiofsd/fuse.h:214:
+^I * Internally, enabling this option causes fuse to set the$
ERROR: code indent should never use tabs
#235: FILE: tools/virtiofsd/fuse.h:215:
+^I * `direct_io` field of `struct fuse_file_info` - overwriting$
ERROR: code indent should never use tabs
#236: FILE: tools/virtiofsd/fuse.h:216:
+^I * any value that was put there by the file system.$
ERROR: code indent should never use tabs
#237: FILE: tools/virtiofsd/fuse.h:217:
+^I */$
ERROR: code indent should never use tabs
#238: FILE: tools/virtiofsd/fuse.h:218:
+^Iint direct_io;$
ERROR: code indent should never use tabs
#240: FILE: tools/virtiofsd/fuse.h:220:
+^I/**$
ERROR: code indent should never use tabs
#241: FILE: tools/virtiofsd/fuse.h:221:
+^I * This option disables flushing the cache of the file$
ERROR: code indent should never use tabs
#242: FILE: tools/virtiofsd/fuse.h:222:
+^I * contents on every open(2). This should only be enabled on$
ERROR: code indent should never use tabs
#243: FILE: tools/virtiofsd/fuse.h:223:
+^I * filesystems where the file data is never changed$
ERROR: code indent should never use tabs
#244: FILE: tools/virtiofsd/fuse.h:224:
+^I * externally (not through the mounted FUSE filesystem). Thus$
ERROR: code indent should never use tabs
#245: FILE: tools/virtiofsd/fuse.h:225:
+^I * it is not suitable for network filesystems and other$
ERROR: code indent should never use tabs
#246: FILE: tools/virtiofsd/fuse.h:226:
+^I * intermediate filesystems.$
ERROR: code indent should never use tabs
#247: FILE: tools/virtiofsd/fuse.h:227:
+^I *$
ERROR: code indent should never use tabs
#248: FILE: tools/virtiofsd/fuse.h:228:
+^I * NOTE: if this option is not specified (and neither$
ERROR: code indent should never use tabs
#249: FILE: tools/virtiofsd/fuse.h:229:
+^I * direct_io) data is still cached after the open(2), so a$
ERROR: code indent should never use tabs
#250: FILE: tools/virtiofsd/fuse.h:230:
+^I * read(2) system call will not always initiate a read$
ERROR: code indent should never use tabs
#251: FILE: tools/virtiofsd/fuse.h:231:
+^I * operation.$
ERROR: code indent should never use tabs
#252: FILE: tools/virtiofsd/fuse.h:232:
+^I *$
ERROR: code indent should never use tabs
#253: FILE: tools/virtiofsd/fuse.h:233:
+^I * Internally, enabling this option causes fuse to set the$
ERROR: code indent should never use tabs
#254: FILE: tools/virtiofsd/fuse.h:234:
+^I * `keep_cache` field of `struct fuse_file_info` - overwriting$
ERROR: code indent should never use tabs
#255: FILE: tools/virtiofsd/fuse.h:235:
+^I * any value that was put there by the file system.$
ERROR: code indent should never use tabs
#256: FILE: tools/virtiofsd/fuse.h:236:
+^I */$
ERROR: code indent should never use tabs
#257: FILE: tools/virtiofsd/fuse.h:237:
+^Iint kernel_cache;$
ERROR: code indent should never use tabs
#259: FILE: tools/virtiofsd/fuse.h:239:
+^I/**$
ERROR: code indent should never use tabs
#260: FILE: tools/virtiofsd/fuse.h:240:
+^I * This option is an alternative to `kernel_cache`. Instead of$
ERROR: code indent should never use tabs
#261: FILE: tools/virtiofsd/fuse.h:241:
+^I * unconditionally keeping cached data, the cached data is$
ERROR: code indent should never use tabs
#262: FILE: tools/virtiofsd/fuse.h:242:
+^I * invalidated on open(2) if if the modification time or the$
ERROR: code indent should never use tabs
#263: FILE: tools/virtiofsd/fuse.h:243:
+^I * size of the file has changed since it was last opened.$
ERROR: code indent should never use tabs
#264: FILE: tools/virtiofsd/fuse.h:244:
+^I */$
ERROR: code indent should never use tabs
#265: FILE: tools/virtiofsd/fuse.h:245:
+^Iint auto_cache;$
ERROR: code indent should never use tabs
#267: FILE: tools/virtiofsd/fuse.h:247:
+^I/**$
ERROR: code indent should never use tabs
#268: FILE: tools/virtiofsd/fuse.h:248:
+^I * The timeout in seconds for which file attributes are cached$
ERROR: code indent should never use tabs
#269: FILE: tools/virtiofsd/fuse.h:249:
+^I * for the purpose of checking if auto_cache should flush the$
ERROR: code indent should never use tabs
#270: FILE: tools/virtiofsd/fuse.h:250:
+^I * file data on open.$
ERROR: code indent should never use tabs
#271: FILE: tools/virtiofsd/fuse.h:251:
+^I */$
ERROR: code indent should never use tabs
#272: FILE: tools/virtiofsd/fuse.h:252:
+^Iint ac_attr_timeout_set;$
ERROR: code indent should never use tabs
#273: FILE: tools/virtiofsd/fuse.h:253:
+^Idouble ac_attr_timeout;$
ERROR: code indent should never use tabs
#275: FILE: tools/virtiofsd/fuse.h:255:
+^I/**$
ERROR: code indent should never use tabs
#276: FILE: tools/virtiofsd/fuse.h:256:
+^I * If this option is given the file-system handlers for the$
ERROR: code indent should never use tabs
#277: FILE: tools/virtiofsd/fuse.h:257:
+^I * following operations will not receive path information:$
ERROR: code indent should never use tabs
#278: FILE: tools/virtiofsd/fuse.h:258:
+^I * read, write, flush, release, fsync, readdir, releasedir,$
ERROR: code indent should never use tabs
#279: FILE: tools/virtiofsd/fuse.h:259:
+^I * fsyncdir, lock, ioctl and poll.$
ERROR: code indent should never use tabs
#280: FILE: tools/virtiofsd/fuse.h:260:
+^I *$
ERROR: code indent should never use tabs
#281: FILE: tools/virtiofsd/fuse.h:261:
+^I * For the truncate, getattr, chmod, chown and utimens$
ERROR: code indent should never use tabs
#282: FILE: tools/virtiofsd/fuse.h:262:
+^I * operations the path will be provided only if the struct$
ERROR: code indent should never use tabs
#283: FILE: tools/virtiofsd/fuse.h:263:
+^I * fuse_file_info argument is NULL.$
ERROR: code indent should never use tabs
#284: FILE: tools/virtiofsd/fuse.h:264:
+^I */$
ERROR: code indent should never use tabs
#285: FILE: tools/virtiofsd/fuse.h:265:
+^Iint nullpath_ok;$
ERROR: code indent should never use tabs
#287: FILE: tools/virtiofsd/fuse.h:267:
+^I/**$
ERROR: code indent should never use tabs
#288: FILE: tools/virtiofsd/fuse.h:268:
+^I * The remaining options are used by libfuse internally and$
ERROR: code indent should never use tabs
#289: FILE: tools/virtiofsd/fuse.h:269:
+^I * should not be touched.$
ERROR: code indent should never use tabs
#290: FILE: tools/virtiofsd/fuse.h:270:
+^I */$
ERROR: code indent should never use tabs
#291: FILE: tools/virtiofsd/fuse.h:271:
+^Iint show_help;$
ERROR: code indent should never use tabs
#292: FILE: tools/virtiofsd/fuse.h:272:
+^Ichar *modules;$
ERROR: code indent should never use tabs
#293: FILE: tools/virtiofsd/fuse.h:273:
+^Iint debug;$
ERROR: code indent should never use tabs
#320: FILE: tools/virtiofsd/fuse.h:300:
+^I/** Get file attributes.$
WARNING: Block comments use a leading /* on a separate line
#320: FILE: tools/virtiofsd/fuse.h:300:
+ /** Get file attributes.
ERROR: code indent should never use tabs
#321: FILE: tools/virtiofsd/fuse.h:301:
+^I *$
ERROR: code indent should never use tabs
#322: FILE: tools/virtiofsd/fuse.h:302:
+^I * Similar to stat(). The 'st_dev' and 'st_blksize' fields are$
ERROR: code indent should never use tabs
#323: FILE: tools/virtiofsd/fuse.h:303:
+^I * ignored. The 'st_ino' field is ignored except if the 'use_ino'$
ERROR: code indent should never use tabs
#324: FILE: tools/virtiofsd/fuse.h:304:
+^I * mount option is given. In that case it is passed to userspace,$
ERROR: code indent should never use tabs
#325: FILE: tools/virtiofsd/fuse.h:305:
+^I * but libfuse and the kernel will still assign a different$
ERROR: code indent should never use tabs
#326: FILE: tools/virtiofsd/fuse.h:306:
+^I * inode for internal use (called the "nodeid").$
ERROR: code indent should never use tabs
#327: FILE: tools/virtiofsd/fuse.h:307:
+^I *$
ERROR: code indent should never use tabs
#328: FILE: tools/virtiofsd/fuse.h:308:
+^I * `fi` will always be NULL if the file is not currently open, but$
ERROR: code indent should never use tabs
#329: FILE: tools/virtiofsd/fuse.h:309:
+^I * may also be NULL if the file is open.$
ERROR: code indent should never use tabs
#330: FILE: tools/virtiofsd/fuse.h:310:
+^I */$
ERROR: code indent should never use tabs
#331: FILE: tools/virtiofsd/fuse.h:311:
+^Iint (*getattr) (const char *, struct stat *, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#333: FILE: tools/virtiofsd/fuse.h:313:
+^I/** Read the target of a symbolic link$
WARNING: Block comments use a leading /* on a separate line
#333: FILE: tools/virtiofsd/fuse.h:313:
+ /** Read the target of a symbolic link
ERROR: code indent should never use tabs
#334: FILE: tools/virtiofsd/fuse.h:314:
+^I *$
ERROR: code indent should never use tabs
#335: FILE: tools/virtiofsd/fuse.h:315:
+^I * The buffer should be filled with a null terminated string. The$
ERROR: code indent should never use tabs
#336: FILE: tools/virtiofsd/fuse.h:316:
+^I * buffer size argument includes the space for the terminating$
ERROR: code indent should never use tabs
#337: FILE: tools/virtiofsd/fuse.h:317:
+^I * null character.^IIf the linkname is too long to fit in the$
ERROR: code indent should never use tabs
#338: FILE: tools/virtiofsd/fuse.h:318:
+^I * buffer, it should be truncated.^IThe return value should be 0$
ERROR: code indent should never use tabs
#339: FILE: tools/virtiofsd/fuse.h:319:
+^I * for success.$
ERROR: code indent should never use tabs
#340: FILE: tools/virtiofsd/fuse.h:320:
+^I */$
ERROR: code indent should never use tabs
#341: FILE: tools/virtiofsd/fuse.h:321:
+^Iint (*readlink) (const char *, char *, size_t);$
ERROR: code indent should never use tabs
#343: FILE: tools/virtiofsd/fuse.h:323:
+^I/** Create a file node$
WARNING: Block comments use a leading /* on a separate line
#343: FILE: tools/virtiofsd/fuse.h:323:
+ /** Create a file node
ERROR: code indent should never use tabs
#344: FILE: tools/virtiofsd/fuse.h:324:
+^I *$
ERROR: code indent should never use tabs
#345: FILE: tools/virtiofsd/fuse.h:325:
+^I * This is called for creation of all non-directory, non-symlink$
ERROR: code indent should never use tabs
#346: FILE: tools/virtiofsd/fuse.h:326:
+^I * nodes. If the filesystem defines a create() method, then for$
ERROR: code indent should never use tabs
#347: FILE: tools/virtiofsd/fuse.h:327:
+^I * regular files that will be called instead.$
ERROR: code indent should never use tabs
#348: FILE: tools/virtiofsd/fuse.h:328:
+^I */$
ERROR: code indent should never use tabs
#349: FILE: tools/virtiofsd/fuse.h:329:
+^Iint (*mknod) (const char *, mode_t, dev_t);$
ERROR: code indent should never use tabs
#351: FILE: tools/virtiofsd/fuse.h:331:
+^I/** Create a directory$
WARNING: Block comments use a leading /* on a separate line
#351: FILE: tools/virtiofsd/fuse.h:331:
+ /** Create a directory
ERROR: code indent should never use tabs
#352: FILE: tools/virtiofsd/fuse.h:332:
+^I *$
ERROR: code indent should never use tabs
#353: FILE: tools/virtiofsd/fuse.h:333:
+^I * Note that the mode argument may not have the type specification$
ERROR: code indent should never use tabs
#354: FILE: tools/virtiofsd/fuse.h:334:
+^I * bits set, i.e. S_ISDIR(mode) can be false. To obtain the$
ERROR: code indent should never use tabs
#355: FILE: tools/virtiofsd/fuse.h:335:
+^I * correct directory type bits use mode|S_IFDIR$
ERROR: code indent should never use tabs
#356: FILE: tools/virtiofsd/fuse.h:336:
+^I * */$
WARNING: Block comments use a trailing */ on a separate line
#356: FILE: tools/virtiofsd/fuse.h:336:
+ * */
ERROR: code indent should never use tabs
#357: FILE: tools/virtiofsd/fuse.h:337:
+^Iint (*mkdir) (const char *, mode_t);$
ERROR: code indent should never use tabs
#359: FILE: tools/virtiofsd/fuse.h:339:
+^I/** Remove a file */$
ERROR: code indent should never use tabs
#360: FILE: tools/virtiofsd/fuse.h:340:
+^Iint (*unlink) (const char *);$
ERROR: code indent should never use tabs
#362: FILE: tools/virtiofsd/fuse.h:342:
+^I/** Remove a directory */$
ERROR: code indent should never use tabs
#363: FILE: tools/virtiofsd/fuse.h:343:
+^Iint (*rmdir) (const char *);$
ERROR: code indent should never use tabs
#365: FILE: tools/virtiofsd/fuse.h:345:
+^I/** Create a symbolic link */$
ERROR: code indent should never use tabs
#366: FILE: tools/virtiofsd/fuse.h:346:
+^Iint (*symlink) (const char *, const char *);$
ERROR: code indent should never use tabs
#368: FILE: tools/virtiofsd/fuse.h:348:
+^I/** Rename a file$
WARNING: Block comments use a leading /* on a separate line
#368: FILE: tools/virtiofsd/fuse.h:348:
+ /** Rename a file
ERROR: code indent should never use tabs
#369: FILE: tools/virtiofsd/fuse.h:349:
+^I *$
ERROR: code indent should never use tabs
#370: FILE: tools/virtiofsd/fuse.h:350:
+^I * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If$
ERROR: code indent should never use tabs
#371: FILE: tools/virtiofsd/fuse.h:351:
+^I * RENAME_NOREPLACE is specified, the filesystem must not$
ERROR: code indent should never use tabs
#372: FILE: tools/virtiofsd/fuse.h:352:
+^I * overwrite *newname* if it exists and return an error$
ERROR: code indent should never use tabs
#373: FILE: tools/virtiofsd/fuse.h:353:
+^I * instead. If `RENAME_EXCHANGE` is specified, the filesystem$
ERROR: code indent should never use tabs
#374: FILE: tools/virtiofsd/fuse.h:354:
+^I * must atomically exchange the two files, i.e. both must$
ERROR: code indent should never use tabs
#375: FILE: tools/virtiofsd/fuse.h:355:
+^I * exist and neither may be deleted.$
ERROR: code indent should never use tabs
#376: FILE: tools/virtiofsd/fuse.h:356:
+^I */$
ERROR: code indent should never use tabs
#377: FILE: tools/virtiofsd/fuse.h:357:
+^Iint (*rename) (const char *, const char *, unsigned int flags);$
ERROR: code indent should never use tabs
#379: FILE: tools/virtiofsd/fuse.h:359:
+^I/** Create a hard link to a file */$
ERROR: code indent should never use tabs
#380: FILE: tools/virtiofsd/fuse.h:360:
+^Iint (*link) (const char *, const char *);$
ERROR: code indent should never use tabs
#382: FILE: tools/virtiofsd/fuse.h:362:
+^I/** Change the permission bits of a file$
WARNING: Block comments use a leading /* on a separate line
#382: FILE: tools/virtiofsd/fuse.h:362:
+ /** Change the permission bits of a file
ERROR: code indent should never use tabs
#383: FILE: tools/virtiofsd/fuse.h:363:
+^I *$
ERROR: code indent should never use tabs
#384: FILE: tools/virtiofsd/fuse.h:364:
+^I * `fi` will always be NULL if the file is not currenlty open, but$
ERROR: code indent should never use tabs
#385: FILE: tools/virtiofsd/fuse.h:365:
+^I * may also be NULL if the file is open.$
ERROR: code indent should never use tabs
#386: FILE: tools/virtiofsd/fuse.h:366:
+^I */$
ERROR: code indent should never use tabs
#387: FILE: tools/virtiofsd/fuse.h:367:
+^Iint (*chmod) (const char *, mode_t, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#389: FILE: tools/virtiofsd/fuse.h:369:
+^I/** Change the owner and group of a file$
WARNING: Block comments use a leading /* on a separate line
#389: FILE: tools/virtiofsd/fuse.h:369:
+ /** Change the owner and group of a file
ERROR: code indent should never use tabs
#390: FILE: tools/virtiofsd/fuse.h:370:
+^I *$
ERROR: code indent should never use tabs
#391: FILE: tools/virtiofsd/fuse.h:371:
+^I * `fi` will always be NULL if the file is not currenlty open, but$
ERROR: code indent should never use tabs
#392: FILE: tools/virtiofsd/fuse.h:372:
+^I * may also be NULL if the file is open.$
ERROR: code indent should never use tabs
#393: FILE: tools/virtiofsd/fuse.h:373:
+^I *$
ERROR: code indent should never use tabs
#394: FILE: tools/virtiofsd/fuse.h:374:
+^I * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is$
ERROR: code indent should never use tabs
#395: FILE: tools/virtiofsd/fuse.h:375:
+^I * expected to reset the setuid and setgid bits.$
ERROR: code indent should never use tabs
#396: FILE: tools/virtiofsd/fuse.h:376:
+^I */$
ERROR: code indent should never use tabs
#397: FILE: tools/virtiofsd/fuse.h:377:
+^Iint (*chown) (const char *, uid_t, gid_t, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#399: FILE: tools/virtiofsd/fuse.h:379:
+^I/** Change the size of a file$
WARNING: Block comments use a leading /* on a separate line
#399: FILE: tools/virtiofsd/fuse.h:379:
+ /** Change the size of a file
ERROR: code indent should never use tabs
#400: FILE: tools/virtiofsd/fuse.h:380:
+^I *$
ERROR: code indent should never use tabs
#401: FILE: tools/virtiofsd/fuse.h:381:
+^I * `fi` will always be NULL if the file is not currenlty open, but$
ERROR: code indent should never use tabs
#402: FILE: tools/virtiofsd/fuse.h:382:
+^I * may also be NULL if the file is open.$
ERROR: code indent should never use tabs
#403: FILE: tools/virtiofsd/fuse.h:383:
+^I *$
ERROR: code indent should never use tabs
#404: FILE: tools/virtiofsd/fuse.h:384:
+^I * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is$
ERROR: code indent should never use tabs
#405: FILE: tools/virtiofsd/fuse.h:385:
+^I * expected to reset the setuid and setgid bits.$
ERROR: code indent should never use tabs
#406: FILE: tools/virtiofsd/fuse.h:386:
+^I */$
ERROR: code indent should never use tabs
#407: FILE: tools/virtiofsd/fuse.h:387:
+^Iint (*truncate) (const char *, off_t, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#409: FILE: tools/virtiofsd/fuse.h:389:
+^I/** Open a file$
WARNING: Block comments use a leading /* on a separate line
#409: FILE: tools/virtiofsd/fuse.h:389:
+ /** Open a file
ERROR: code indent should never use tabs
#410: FILE: tools/virtiofsd/fuse.h:390:
+^I *$
ERROR: code indent should never use tabs
#411: FILE: tools/virtiofsd/fuse.h:391:
+^I * Open flags are available in fi->flags. The following rules$
ERROR: code indent should never use tabs
#412: FILE: tools/virtiofsd/fuse.h:392:
+^I * apply.$
ERROR: code indent should never use tabs
#413: FILE: tools/virtiofsd/fuse.h:393:
+^I *$
ERROR: code indent should never use tabs
#414: FILE: tools/virtiofsd/fuse.h:394:
+^I * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be$
ERROR: code indent should never use tabs
#415: FILE: tools/virtiofsd/fuse.h:395:
+^I * filtered out / handled by the kernel.$
ERROR: code indent should never use tabs
#416: FILE: tools/virtiofsd/fuse.h:396:
+^I *$
ERROR: code indent should never use tabs
#417: FILE: tools/virtiofsd/fuse.h:397:
+^I * - Access modes (O_RDONLY, O_WRONLY, O_RDWR, O_EXEC, O_SEARCH)$
ERROR: code indent should never use tabs
#418: FILE: tools/virtiofsd/fuse.h:398:
+^I * should be used by the filesystem to check if the operation is$
ERROR: code indent should never use tabs
#419: FILE: tools/virtiofsd/fuse.h:399:
+^I * permitted. If the ``-o default_permissions`` mount option is$
ERROR: code indent should never use tabs
#420: FILE: tools/virtiofsd/fuse.h:400:
+^I * given, this check is already done by the kernel before calling$
ERROR: code indent should never use tabs
#421: FILE: tools/virtiofsd/fuse.h:401:
+^I * open() and may thus be omitted by the filesystem.$
ERROR: code indent should never use tabs
#422: FILE: tools/virtiofsd/fuse.h:402:
+^I *$
ERROR: code indent should never use tabs
#423: FILE: tools/virtiofsd/fuse.h:403:
+^I * - When writeback caching is enabled, the kernel may send$
ERROR: code indent should never use tabs
#424: FILE: tools/virtiofsd/fuse.h:404:
+^I * read requests even for files opened with O_WRONLY. The$
ERROR: code indent should never use tabs
#425: FILE: tools/virtiofsd/fuse.h:405:
+^I * filesystem should be prepared to handle this.$
ERROR: code indent should never use tabs
#426: FILE: tools/virtiofsd/fuse.h:406:
+^I *$
ERROR: code indent should never use tabs
#427: FILE: tools/virtiofsd/fuse.h:407:
+^I * - When writeback caching is disabled, the filesystem is$
ERROR: code indent should never use tabs
#428: FILE: tools/virtiofsd/fuse.h:408:
+^I * expected to properly handle the O_APPEND flag and ensure$
ERROR: code indent should never use tabs
#429: FILE: tools/virtiofsd/fuse.h:409:
+^I * that each write is appending to the end of the file.$
ERROR: trailing whitespace
#430: FILE: tools/virtiofsd/fuse.h:410:
+^I * $
ERROR: code indent should never use tabs
#430: FILE: tools/virtiofsd/fuse.h:410:
+^I * $
ERROR: code indent should never use tabs
#432: FILE: tools/virtiofsd/fuse.h:412:
+^I * handle O_APPEND. However, unless all changes to the file$
ERROR: code indent should never use tabs
#433: FILE: tools/virtiofsd/fuse.h:413:
+^I * come through the kernel this will not work reliably. The$
ERROR: code indent should never use tabs
#434: FILE: tools/virtiofsd/fuse.h:414:
+^I * filesystem should thus either ignore the O_APPEND flag$
ERROR: code indent should never use tabs
#435: FILE: tools/virtiofsd/fuse.h:415:
+^I * (and let the kernel handle it), or return an error$
ERROR: code indent should never use tabs
#436: FILE: tools/virtiofsd/fuse.h:416:
+^I * (indicating that reliably O_APPEND is not available).$
ERROR: code indent should never use tabs
#437: FILE: tools/virtiofsd/fuse.h:417:
+^I *$
ERROR: code indent should never use tabs
#438: FILE: tools/virtiofsd/fuse.h:418:
+^I * Filesystem may store an arbitrary file handle (pointer,$
ERROR: code indent should never use tabs
#439: FILE: tools/virtiofsd/fuse.h:419:
+^I * index, etc) in fi->fh, and use this in other all other file$
ERROR: code indent should never use tabs
#440: FILE: tools/virtiofsd/fuse.h:420:
+^I * operations (read, write, flush, release, fsync).$
ERROR: code indent should never use tabs
#441: FILE: tools/virtiofsd/fuse.h:421:
+^I *$
ERROR: code indent should never use tabs
#442: FILE: tools/virtiofsd/fuse.h:422:
+^I * Filesystem may also implement stateless file I/O and not store$
ERROR: code indent should never use tabs
#443: FILE: tools/virtiofsd/fuse.h:423:
+^I * anything in fi->fh.$
ERROR: code indent should never use tabs
#444: FILE: tools/virtiofsd/fuse.h:424:
+^I *$
ERROR: code indent should never use tabs
#445: FILE: tools/virtiofsd/fuse.h:425:
+^I * There are also some flags (direct_io, keep_cache) which the$
ERROR: code indent should never use tabs
#446: FILE: tools/virtiofsd/fuse.h:426:
+^I * filesystem may set in fi, to change the way the file is opened.$
ERROR: code indent should never use tabs
#447: FILE: tools/virtiofsd/fuse.h:427:
+^I * See fuse_file_info structure in <fuse_common.h> for more details.$
ERROR: code indent should never use tabs
#448: FILE: tools/virtiofsd/fuse.h:428:
+^I *$
ERROR: code indent should never use tabs
#449: FILE: tools/virtiofsd/fuse.h:429:
+^I * If this request is answered with an error code of ENOSYS$
ERROR: code indent should never use tabs
#450: FILE: tools/virtiofsd/fuse.h:430:
+^I * and FUSE_CAP_NO_OPEN_SUPPORT is set in$
ERROR: code indent should never use tabs
#451: FILE: tools/virtiofsd/fuse.h:431:
+^I * `fuse_conn_info.capable`, this is treated as success and$
ERROR: code indent should never use tabs
#452: FILE: tools/virtiofsd/fuse.h:432:
+^I * future calls to open will also succeed without being send$
ERROR: code indent should never use tabs
#453: FILE: tools/virtiofsd/fuse.h:433:
+^I * to the filesystem process.$
ERROR: code indent should never use tabs
#454: FILE: tools/virtiofsd/fuse.h:434:
+^I *$
ERROR: code indent should never use tabs
#455: FILE: tools/virtiofsd/fuse.h:435:
+^I */$
ERROR: code indent should never use tabs
#456: FILE: tools/virtiofsd/fuse.h:436:
+^Iint (*open) (const char *, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#458: FILE: tools/virtiofsd/fuse.h:438:
+^I/** Read data from an open file$
WARNING: Block comments use a leading /* on a separate line
#458: FILE: tools/virtiofsd/fuse.h:438:
+ /** Read data from an open file
ERROR: code indent should never use tabs
#459: FILE: tools/virtiofsd/fuse.h:439:
+^I *$
ERROR: code indent should never use tabs
#460: FILE: tools/virtiofsd/fuse.h:440:
+^I * Read should return exactly the number of bytes requested except$
ERROR: code indent should never use tabs
#461: FILE: tools/virtiofsd/fuse.h:441:
+^I * on EOF or error, otherwise the rest of the data will be$
ERROR: code indent should never use tabs
#462: FILE: tools/virtiofsd/fuse.h:442:
+^I * substituted with zeroes.^I An exception to this is when the$
ERROR: code indent should never use tabs
#463: FILE: tools/virtiofsd/fuse.h:443:
+^I * 'direct_io' mount option is specified, in which case the return$
ERROR: code indent should never use tabs
#464: FILE: tools/virtiofsd/fuse.h:444:
+^I * value of the read system call will reflect the return value of$
ERROR: code indent should never use tabs
#465: FILE: tools/virtiofsd/fuse.h:445:
+^I * this operation.$
ERROR: code indent should never use tabs
#466: FILE: tools/virtiofsd/fuse.h:446:
+^I */$
ERROR: code indent should never use tabs
#467: FILE: tools/virtiofsd/fuse.h:447:
+^Iint (*read) (const char *, char *, size_t, off_t,$
ERROR: code indent should never use tabs
#468: FILE: tools/virtiofsd/fuse.h:448:
+^I^I struct fuse_file_info *);$
ERROR: code indent should never use tabs
#470: FILE: tools/virtiofsd/fuse.h:450:
+^I/** Write data to an open file$
WARNING: Block comments use a leading /* on a separate line
#470: FILE: tools/virtiofsd/fuse.h:450:
+ /** Write data to an open file
ERROR: code indent should never use tabs
#471: FILE: tools/virtiofsd/fuse.h:451:
+^I *$
ERROR: code indent should never use tabs
#472: FILE: tools/virtiofsd/fuse.h:452:
+^I * Write should return exactly the number of bytes requested$
ERROR: code indent should never use tabs
#473: FILE: tools/virtiofsd/fuse.h:453:
+^I * except on error.^I An exception to this is when the 'direct_io'$
ERROR: code indent should never use tabs
#474: FILE: tools/virtiofsd/fuse.h:454:
+^I * mount option is specified (see read operation).$
ERROR: code indent should never use tabs
#475: FILE: tools/virtiofsd/fuse.h:455:
+^I *$
ERROR: code indent should never use tabs
#476: FILE: tools/virtiofsd/fuse.h:456:
+^I * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is$
ERROR: code indent should never use tabs
#477: FILE: tools/virtiofsd/fuse.h:457:
+^I * expected to reset the setuid and setgid bits.$
ERROR: code indent should never use tabs
#478: FILE: tools/virtiofsd/fuse.h:458:
+^I */$
ERROR: code indent should never use tabs
#479: FILE: tools/virtiofsd/fuse.h:459:
+^Iint (*write) (const char *, const char *, size_t, off_t,$
ERROR: code indent should never use tabs
#480: FILE: tools/virtiofsd/fuse.h:460:
+^I^I struct fuse_file_info *);$
ERROR: code indent should never use tabs
#482: FILE: tools/virtiofsd/fuse.h:462:
+^I/** Get file system statistics$
WARNING: Block comments use a leading /* on a separate line
#482: FILE: tools/virtiofsd/fuse.h:462:
+ /** Get file system statistics
ERROR: code indent should never use tabs
#483: FILE: tools/virtiofsd/fuse.h:463:
+^I *$
ERROR: code indent should never use tabs
#484: FILE: tools/virtiofsd/fuse.h:464:
+^I * The 'f_favail', 'f_fsid' and 'f_flag' fields are ignored$
ERROR: code indent should never use tabs
#485: FILE: tools/virtiofsd/fuse.h:465:
+^I */$
ERROR: code indent should never use tabs
#486: FILE: tools/virtiofsd/fuse.h:466:
+^Iint (*statfs) (const char *, struct statvfs *);$
ERROR: code indent should never use tabs
#488: FILE: tools/virtiofsd/fuse.h:468:
+^I/** Possibly flush cached data$
WARNING: Block comments use a leading /* on a separate line
#488: FILE: tools/virtiofsd/fuse.h:468:
+ /** Possibly flush cached data
ERROR: code indent should never use tabs
#489: FILE: tools/virtiofsd/fuse.h:469:
+^I *$
ERROR: code indent should never use tabs
#490: FILE: tools/virtiofsd/fuse.h:470:
+^I * BIG NOTE: This is not equivalent to fsync(). It's not a$
ERROR: code indent should never use tabs
#491: FILE: tools/virtiofsd/fuse.h:471:
+^I * request to sync dirty data.$
ERROR: code indent should never use tabs
#492: FILE: tools/virtiofsd/fuse.h:472:
+^I *$
ERROR: code indent should never use tabs
#493: FILE: tools/virtiofsd/fuse.h:473:
+^I * Flush is called on each close() of a file descriptor, as opposed to$
ERROR: code indent should never use tabs
#494: FILE: tools/virtiofsd/fuse.h:474:
+^I * release which is called on the close of the last file descriptor for$
ERROR: trailing whitespace
#495: FILE: tools/virtiofsd/fuse.h:475:
+^I * a file. Under Linux, errors returned by flush() will be passed to $
ERROR: code indent should never use tabs
#495: FILE: tools/virtiofsd/fuse.h:475:
+^I * a file. Under Linux, errors returned by flush() will be passed to $
ERROR: code indent should never use tabs
#496: FILE: tools/virtiofsd/fuse.h:476:
+^I * userspace as errors from close(), so flush() is a good place to write$
ERROR: trailing whitespace
#497: FILE: tools/virtiofsd/fuse.h:477:
+^I * back any cached dirty data. However, many applications ignore errors $
ERROR: code indent should never use tabs
#497: FILE: tools/virtiofsd/fuse.h:477:
+^I * back any cached dirty data. However, many applications ignore errors $
WARNING: line over 80 characters
#498: FILE: tools/virtiofsd/fuse.h:478:
+ * on close(), and on non-Linux systems, close() may succeed even if flush()
ERROR: code indent should never use tabs
#498: FILE: tools/virtiofsd/fuse.h:478:
+^I * on close(), and on non-Linux systems, close() may succeed even if flush()$
ERROR: code indent should never use tabs
#499: FILE: tools/virtiofsd/fuse.h:479:
+^I * returns an error. For these reasons, filesystems should not assume$
ERROR: code indent should never use tabs
#500: FILE: tools/virtiofsd/fuse.h:480:
+^I * that errors returned by flush will ever be noticed or even$
ERROR: code indent should never use tabs
#501: FILE: tools/virtiofsd/fuse.h:481:
+^I * delivered.$
ERROR: code indent should never use tabs
#502: FILE: tools/virtiofsd/fuse.h:482:
+^I *$
ERROR: code indent should never use tabs
#503: FILE: tools/virtiofsd/fuse.h:483:
+^I * NOTE: The flush() method may be called more than once for each$
ERROR: code indent should never use tabs
#504: FILE: tools/virtiofsd/fuse.h:484:
+^I * open(). This happens if more than one file descriptor refers to an$
ERROR: code indent should never use tabs
#505: FILE: tools/virtiofsd/fuse.h:485:
+^I * open file handle, e.g. due to dup(), dup2() or fork() calls. It is$
ERROR: code indent should never use tabs
#506: FILE: tools/virtiofsd/fuse.h:486:
+^I * not possible to determine if a flush is final, so each flush should$
ERROR: code indent should never use tabs
#507: FILE: tools/virtiofsd/fuse.h:487:
+^I * be treated equally. Multiple write-flush sequences are relatively$
ERROR: code indent should never use tabs
#508: FILE: tools/virtiofsd/fuse.h:488:
+^I * rare, so this shouldn't be a problem.$
ERROR: code indent should never use tabs
#509: FILE: tools/virtiofsd/fuse.h:489:
+^I *$
ERROR: code indent should never use tabs
#510: FILE: tools/virtiofsd/fuse.h:490:
+^I * Filesystems shouldn't assume that flush will be called at any$
ERROR: code indent should never use tabs
#511: FILE: tools/virtiofsd/fuse.h:491:
+^I * particular point. It may be called more times than expected, or not$
ERROR: code indent should never use tabs
#512: FILE: tools/virtiofsd/fuse.h:492:
+^I * at all.$
ERROR: code indent should never use tabs
#513: FILE: tools/virtiofsd/fuse.h:493:
+^I *$
WARNING: line over 80 characters
#514: FILE: tools/virtiofsd/fuse.h:494:
+ * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
ERROR: code indent should never use tabs
#514: FILE: tools/virtiofsd/fuse.h:494:
+^I * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html$
ERROR: code indent should never use tabs
#515: FILE: tools/virtiofsd/fuse.h:495:
+^I */$
ERROR: code indent should never use tabs
#516: FILE: tools/virtiofsd/fuse.h:496:
+^Iint (*flush) (const char *, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#518: FILE: tools/virtiofsd/fuse.h:498:
+^I/** Release an open file$
WARNING: Block comments use a leading /* on a separate line
#518: FILE: tools/virtiofsd/fuse.h:498:
+ /** Release an open file
ERROR: code indent should never use tabs
#519: FILE: tools/virtiofsd/fuse.h:499:
+^I *$
ERROR: code indent should never use tabs
#520: FILE: tools/virtiofsd/fuse.h:500:
+^I * Release is called when there are no more references to an open$
ERROR: code indent should never use tabs
#521: FILE: tools/virtiofsd/fuse.h:501:
+^I * file: all file descriptors are closed and all memory mappings$
ERROR: code indent should never use tabs
#522: FILE: tools/virtiofsd/fuse.h:502:
+^I * are unmapped.$
ERROR: code indent should never use tabs
#523: FILE: tools/virtiofsd/fuse.h:503:
+^I *$
ERROR: code indent should never use tabs
#524: FILE: tools/virtiofsd/fuse.h:504:
+^I * For every open() call there will be exactly one release() call$
ERROR: code indent should never use tabs
#525: FILE: tools/virtiofsd/fuse.h:505:
+^I * with the same flags and file handle. It is possible to$
ERROR: code indent should never use tabs
#526: FILE: tools/virtiofsd/fuse.h:506:
+^I * have a file opened more than once, in which case only the last$
ERROR: code indent should never use tabs
#527: FILE: tools/virtiofsd/fuse.h:507:
+^I * release will mean, that no more reads/writes will happen on the$
ERROR: code indent should never use tabs
#528: FILE: tools/virtiofsd/fuse.h:508:
+^I * file. The return value of release is ignored.$
ERROR: code indent should never use tabs
#529: FILE: tools/virtiofsd/fuse.h:509:
+^I */$
ERROR: code indent should never use tabs
#530: FILE: tools/virtiofsd/fuse.h:510:
+^Iint (*release) (const char *, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#532: FILE: tools/virtiofsd/fuse.h:512:
+^I/** Synchronize file contents$
WARNING: Block comments use a leading /* on a separate line
#532: FILE: tools/virtiofsd/fuse.h:512:
+ /** Synchronize file contents
ERROR: code indent should never use tabs
#533: FILE: tools/virtiofsd/fuse.h:513:
+^I *$
ERROR: code indent should never use tabs
#534: FILE: tools/virtiofsd/fuse.h:514:
+^I * If the datasync parameter is non-zero, then only the user data$
ERROR: code indent should never use tabs
#535: FILE: tools/virtiofsd/fuse.h:515:
+^I * should be flushed, not the meta data.$
ERROR: code indent should never use tabs
#536: FILE: tools/virtiofsd/fuse.h:516:
+^I */$
ERROR: code indent should never use tabs
#537: FILE: tools/virtiofsd/fuse.h:517:
+^Iint (*fsync) (const char *, int, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#539: FILE: tools/virtiofsd/fuse.h:519:
+^I/** Set extended attributes */$
ERROR: code indent should never use tabs
#540: FILE: tools/virtiofsd/fuse.h:520:
+^Iint (*setxattr) (const char *, const char *, const char *, size_t, int);$
ERROR: code indent should never use tabs
#542: FILE: tools/virtiofsd/fuse.h:522:
+^I/** Get extended attributes */$
ERROR: code indent should never use tabs
#543: FILE: tools/virtiofsd/fuse.h:523:
+^Iint (*getxattr) (const char *, const char *, char *, size_t);$
ERROR: code indent should never use tabs
#545: FILE: tools/virtiofsd/fuse.h:525:
+^I/** List extended attributes */$
ERROR: code indent should never use tabs
#546: FILE: tools/virtiofsd/fuse.h:526:
+^Iint (*listxattr) (const char *, char *, size_t);$
ERROR: code indent should never use tabs
#548: FILE: tools/virtiofsd/fuse.h:528:
+^I/** Remove extended attributes */$
ERROR: code indent should never use tabs
#549: FILE: tools/virtiofsd/fuse.h:529:
+^Iint (*removexattr) (const char *, const char *);$
ERROR: code indent should never use tabs
#551: FILE: tools/virtiofsd/fuse.h:531:
+^I/** Open directory$
WARNING: Block comments use a leading /* on a separate line
#551: FILE: tools/virtiofsd/fuse.h:531:
+ /** Open directory
ERROR: code indent should never use tabs
#552: FILE: tools/virtiofsd/fuse.h:532:
+^I *$
ERROR: code indent should never use tabs
#553: FILE: tools/virtiofsd/fuse.h:533:
+^I * Unless the 'default_permissions' mount option is given,$
ERROR: code indent should never use tabs
#554: FILE: tools/virtiofsd/fuse.h:534:
+^I * this method should check if opendir is permitted for this$
ERROR: code indent should never use tabs
#555: FILE: tools/virtiofsd/fuse.h:535:
+^I * directory. Optionally opendir may also return an arbitrary$
ERROR: code indent should never use tabs
#556: FILE: tools/virtiofsd/fuse.h:536:
+^I * filehandle in the fuse_file_info structure, which will be$
ERROR: code indent should never use tabs
#557: FILE: tools/virtiofsd/fuse.h:537:
+^I * passed to readdir, releasedir and fsyncdir.$
ERROR: code indent should never use tabs
#558: FILE: tools/virtiofsd/fuse.h:538:
+^I */$
ERROR: code indent should never use tabs
#559: FILE: tools/virtiofsd/fuse.h:539:
+^Iint (*opendir) (const char *, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#561: FILE: tools/virtiofsd/fuse.h:541:
+^I/** Read directory$
WARNING: Block comments use a leading /* on a separate line
#561: FILE: tools/virtiofsd/fuse.h:541:
+ /** Read directory
ERROR: code indent should never use tabs
#562: FILE: tools/virtiofsd/fuse.h:542:
+^I *$
ERROR: code indent should never use tabs
#563: FILE: tools/virtiofsd/fuse.h:543:
+^I * The filesystem may choose between two modes of operation:$
ERROR: code indent should never use tabs
#564: FILE: tools/virtiofsd/fuse.h:544:
+^I *$
ERROR: code indent should never use tabs
#565: FILE: tools/virtiofsd/fuse.h:545:
+^I * 1) The readdir implementation ignores the offset parameter, and$
ERROR: code indent should never use tabs
#566: FILE: tools/virtiofsd/fuse.h:546:
+^I * passes zero to the filler function's offset. The filler$
ERROR: code indent should never use tabs
#567: FILE: tools/virtiofsd/fuse.h:547:
+^I * function will not return '1' (unless an error happens), so the$
ERROR: code indent should never use tabs
#568: FILE: tools/virtiofsd/fuse.h:548:
+^I * whole directory is read in a single readdir operation.$
ERROR: code indent should never use tabs
#569: FILE: tools/virtiofsd/fuse.h:549:
+^I *$
ERROR: code indent should never use tabs
#570: FILE: tools/virtiofsd/fuse.h:550:
+^I * 2) The readdir implementation keeps track of the offsets of the$
ERROR: code indent should never use tabs
#571: FILE: tools/virtiofsd/fuse.h:551:
+^I * directory entries. It uses the offset parameter and always$
ERROR: code indent should never use tabs
#572: FILE: tools/virtiofsd/fuse.h:552:
+^I * passes non-zero offset to the filler function. When the buffer$
ERROR: code indent should never use tabs
#573: FILE: tools/virtiofsd/fuse.h:553:
+^I * is full (or an error happens) the filler function will return$
ERROR: code indent should never use tabs
#574: FILE: tools/virtiofsd/fuse.h:554:
+^I * '1'.$
ERROR: code indent should never use tabs
#575: FILE: tools/virtiofsd/fuse.h:555:
+^I */$
ERROR: code indent should never use tabs
#576: FILE: tools/virtiofsd/fuse.h:556:
+^Iint (*readdir) (const char *, void *, fuse_fill_dir_t, off_t,$
ERROR: code indent should never use tabs
#577: FILE: tools/virtiofsd/fuse.h:557:
+^I^I^Istruct fuse_file_info *, enum fuse_readdir_flags);$
ERROR: code indent should never use tabs
#579: FILE: tools/virtiofsd/fuse.h:559:
+^I/** Release directory$
WARNING: Block comments use a leading /* on a separate line
#579: FILE: tools/virtiofsd/fuse.h:559:
+ /** Release directory
ERROR: code indent should never use tabs
#580: FILE: tools/virtiofsd/fuse.h:560:
+^I */$
ERROR: code indent should never use tabs
#581: FILE: tools/virtiofsd/fuse.h:561:
+^Iint (*releasedir) (const char *, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#583: FILE: tools/virtiofsd/fuse.h:563:
+^I/** Synchronize directory contents$
WARNING: Block comments use a leading /* on a separate line
#583: FILE: tools/virtiofsd/fuse.h:563:
+ /** Synchronize directory contents
ERROR: code indent should never use tabs
#584: FILE: tools/virtiofsd/fuse.h:564:
+^I *$
ERROR: code indent should never use tabs
#585: FILE: tools/virtiofsd/fuse.h:565:
+^I * If the datasync parameter is non-zero, then only the user data$
ERROR: code indent should never use tabs
#586: FILE: tools/virtiofsd/fuse.h:566:
+^I * should be flushed, not the meta data$
ERROR: code indent should never use tabs
#587: FILE: tools/virtiofsd/fuse.h:567:
+^I */$
ERROR: code indent should never use tabs
#588: FILE: tools/virtiofsd/fuse.h:568:
+^Iint (*fsyncdir) (const char *, int, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#590: FILE: tools/virtiofsd/fuse.h:570:
+^I/**$
ERROR: code indent should never use tabs
#591: FILE: tools/virtiofsd/fuse.h:571:
+^I * Initialize filesystem$
ERROR: code indent should never use tabs
#592: FILE: tools/virtiofsd/fuse.h:572:
+^I *$
ERROR: code indent should never use tabs
#593: FILE: tools/virtiofsd/fuse.h:573:
+^I * The return value will passed in the `private_data` field of$
ERROR: code indent should never use tabs
#594: FILE: tools/virtiofsd/fuse.h:574:
+^I * `struct fuse_context` to all file operations, and as a$
ERROR: code indent should never use tabs
#595: FILE: tools/virtiofsd/fuse.h:575:
+^I * parameter to the destroy() method. It overrides the initial$
ERROR: code indent should never use tabs
#596: FILE: tools/virtiofsd/fuse.h:576:
+^I * value provided to fuse_main() / fuse_new().$
ERROR: code indent should never use tabs
#597: FILE: tools/virtiofsd/fuse.h:577:
+^I */$
ERROR: code indent should never use tabs
#598: FILE: tools/virtiofsd/fuse.h:578:
+^Ivoid *(*init) (struct fuse_conn_info *conn,$
ERROR: code indent should never use tabs
#599: FILE: tools/virtiofsd/fuse.h:579:
+^I^I struct fuse_config *cfg);$
ERROR: code indent should never use tabs
#601: FILE: tools/virtiofsd/fuse.h:581:
+^I/**$
ERROR: code indent should never use tabs
#602: FILE: tools/virtiofsd/fuse.h:582:
+^I * Clean up filesystem$
ERROR: code indent should never use tabs
#603: FILE: tools/virtiofsd/fuse.h:583:
+^I *$
ERROR: code indent should never use tabs
#604: FILE: tools/virtiofsd/fuse.h:584:
+^I * Called on filesystem exit.$
ERROR: code indent should never use tabs
#605: FILE: tools/virtiofsd/fuse.h:585:
+^I */$
ERROR: code indent should never use tabs
#606: FILE: tools/virtiofsd/fuse.h:586:
+^Ivoid (*destroy) (void *private_data);$
ERROR: code indent should never use tabs
#608: FILE: tools/virtiofsd/fuse.h:588:
+^I/**$
ERROR: code indent should never use tabs
#609: FILE: tools/virtiofsd/fuse.h:589:
+^I * Check file access permissions$
ERROR: code indent should never use tabs
#610: FILE: tools/virtiofsd/fuse.h:590:
+^I *$
ERROR: code indent should never use tabs
#611: FILE: tools/virtiofsd/fuse.h:591:
+^I * This will be called for the access() system call. If the$
ERROR: code indent should never use tabs
#612: FILE: tools/virtiofsd/fuse.h:592:
+^I * 'default_permissions' mount option is given, this method is not$
ERROR: code indent should never use tabs
#613: FILE: tools/virtiofsd/fuse.h:593:
+^I * called.$
ERROR: code indent should never use tabs
#614: FILE: tools/virtiofsd/fuse.h:594:
+^I *$
ERROR: code indent should never use tabs
#615: FILE: tools/virtiofsd/fuse.h:595:
+^I * This method is not called under Linux kernel versions 2.4.x$
ERROR: code indent should never use tabs
#616: FILE: tools/virtiofsd/fuse.h:596:
+^I */$
ERROR: code indent should never use tabs
#617: FILE: tools/virtiofsd/fuse.h:597:
+^Iint (*access) (const char *, int);$
ERROR: code indent should never use tabs
#619: FILE: tools/virtiofsd/fuse.h:599:
+^I/**$
ERROR: code indent should never use tabs
#620: FILE: tools/virtiofsd/fuse.h:600:
+^I * Create and open a file$
ERROR: code indent should never use tabs
#621: FILE: tools/virtiofsd/fuse.h:601:
+^I *$
ERROR: code indent should never use tabs
#622: FILE: tools/virtiofsd/fuse.h:602:
+^I * If the file does not exist, first create it with the specified$
ERROR: code indent should never use tabs
#623: FILE: tools/virtiofsd/fuse.h:603:
+^I * mode, and then open it.$
ERROR: code indent should never use tabs
#624: FILE: tools/virtiofsd/fuse.h:604:
+^I *$
ERROR: code indent should never use tabs
#625: FILE: tools/virtiofsd/fuse.h:605:
+^I * If this method is not implemented or under Linux kernel$
ERROR: code indent should never use tabs
#626: FILE: tools/virtiofsd/fuse.h:606:
+^I * versions earlier than 2.6.15, the mknod() and open() methods$
ERROR: code indent should never use tabs
#627: FILE: tools/virtiofsd/fuse.h:607:
+^I * will be called instead.$
ERROR: code indent should never use tabs
#628: FILE: tools/virtiofsd/fuse.h:608:
+^I */$
ERROR: code indent should never use tabs
#629: FILE: tools/virtiofsd/fuse.h:609:
+^Iint (*create) (const char *, mode_t, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#631: FILE: tools/virtiofsd/fuse.h:611:
+^I/**$
ERROR: code indent should never use tabs
#632: FILE: tools/virtiofsd/fuse.h:612:
+^I * Perform POSIX file locking operation$
ERROR: code indent should never use tabs
#633: FILE: tools/virtiofsd/fuse.h:613:
+^I *$
ERROR: code indent should never use tabs
#634: FILE: tools/virtiofsd/fuse.h:614:
+^I * The cmd argument will be either F_GETLK, F_SETLK or F_SETLKW.$
ERROR: code indent should never use tabs
#635: FILE: tools/virtiofsd/fuse.h:615:
+^I *$
ERROR: code indent should never use tabs
#636: FILE: tools/virtiofsd/fuse.h:616:
+^I * For the meaning of fields in 'struct flock' see the man page$
ERROR: code indent should never use tabs
#637: FILE: tools/virtiofsd/fuse.h:617:
+^I * for fcntl(2). The l_whence field will always be set to$
ERROR: code indent should never use tabs
#638: FILE: tools/virtiofsd/fuse.h:618:
+^I * SEEK_SET.$
ERROR: code indent should never use tabs
#639: FILE: tools/virtiofsd/fuse.h:619:
+^I *$
ERROR: code indent should never use tabs
#640: FILE: tools/virtiofsd/fuse.h:620:
+^I * For checking lock ownership, the 'fuse_file_info->owner'$
ERROR: code indent should never use tabs
#641: FILE: tools/virtiofsd/fuse.h:621:
+^I * argument must be used.$
ERROR: code indent should never use tabs
#642: FILE: tools/virtiofsd/fuse.h:622:
+^I *$
ERROR: code indent should never use tabs
#643: FILE: tools/virtiofsd/fuse.h:623:
+^I * For F_GETLK operation, the library will first check currently$
ERROR: code indent should never use tabs
#644: FILE: tools/virtiofsd/fuse.h:624:
+^I * held locks, and if a conflicting lock is found it will return$
ERROR: code indent should never use tabs
#645: FILE: tools/virtiofsd/fuse.h:625:
+^I * information without calling this method.^I This ensures, that$
ERROR: code indent should never use tabs
#646: FILE: tools/virtiofsd/fuse.h:626:
+^I * for local locks the l_pid field is correctly filled in.^IThe$
ERROR: code indent should never use tabs
#647: FILE: tools/virtiofsd/fuse.h:627:
+^I * results may not be accurate in case of race conditions and in$
ERROR: code indent should never use tabs
#648: FILE: tools/virtiofsd/fuse.h:628:
+^I * the presence of hard links, but it's unlikely that an$
ERROR: code indent should never use tabs
#649: FILE: tools/virtiofsd/fuse.h:629:
+^I * application would rely on accurate GETLK results in these$
ERROR: code indent should never use tabs
#650: FILE: tools/virtiofsd/fuse.h:630:
+^I * cases. If a conflicting lock is not found, this method will be$
ERROR: code indent should never use tabs
#651: FILE: tools/virtiofsd/fuse.h:631:
+^I * called, and the filesystem may fill out l_pid by a meaningful$
ERROR: code indent should never use tabs
#652: FILE: tools/virtiofsd/fuse.h:632:
+^I * value, or it may leave this field zero.$
ERROR: code indent should never use tabs
#653: FILE: tools/virtiofsd/fuse.h:633:
+^I *$
ERROR: code indent should never use tabs
#654: FILE: tools/virtiofsd/fuse.h:634:
+^I * For F_SETLK and F_SETLKW the l_pid field will be set to the pid$
ERROR: code indent should never use tabs
#655: FILE: tools/virtiofsd/fuse.h:635:
+^I * of the process performing the locking operation.$
ERROR: code indent should never use tabs
#656: FILE: tools/virtiofsd/fuse.h:636:
+^I *$
ERROR: code indent should never use tabs
#657: FILE: tools/virtiofsd/fuse.h:637:
+^I * Note: if this method is not implemented, the kernel will still$
ERROR: code indent should never use tabs
#658: FILE: tools/virtiofsd/fuse.h:638:
+^I * allow file locking to work locally. Hence it is only$
ERROR: code indent should never use tabs
#659: FILE: tools/virtiofsd/fuse.h:639:
+^I * interesting for network filesystems and similar.$
ERROR: code indent should never use tabs
#660: FILE: tools/virtiofsd/fuse.h:640:
+^I */$
ERROR: code indent should never use tabs
#661: FILE: tools/virtiofsd/fuse.h:641:
+^Iint (*lock) (const char *, struct fuse_file_info *, int cmd,$
ERROR: code indent should never use tabs
#662: FILE: tools/virtiofsd/fuse.h:642:
+^I^I struct flock *);$
ERROR: code indent should never use tabs
#664: FILE: tools/virtiofsd/fuse.h:644:
+^I/**$
ERROR: code indent should never use tabs
#665: FILE: tools/virtiofsd/fuse.h:645:
+^I * Change the access and modification times of a file with$
ERROR: code indent should never use tabs
#666: FILE: tools/virtiofsd/fuse.h:646:
+^I * nanosecond resolution$
ERROR: code indent should never use tabs
#667: FILE: tools/virtiofsd/fuse.h:647:
+^I *$
ERROR: code indent should never use tabs
#668: FILE: tools/virtiofsd/fuse.h:648:
+^I * This supersedes the old utime() interface. New applications$
ERROR: code indent should never use tabs
#669: FILE: tools/virtiofsd/fuse.h:649:
+^I * should use this.$
ERROR: code indent should never use tabs
#670: FILE: tools/virtiofsd/fuse.h:650:
+^I *$
ERROR: code indent should never use tabs
#671: FILE: tools/virtiofsd/fuse.h:651:
+^I * `fi` will always be NULL if the file is not currenlty open, but$
ERROR: code indent should never use tabs
#672: FILE: tools/virtiofsd/fuse.h:652:
+^I * may also be NULL if the file is open.$
ERROR: code indent should never use tabs
#673: FILE: tools/virtiofsd/fuse.h:653:
+^I *$
ERROR: code indent should never use tabs
#674: FILE: tools/virtiofsd/fuse.h:654:
+^I * See the utimensat(2) man page for details.$
ERROR: code indent should never use tabs
#675: FILE: tools/virtiofsd/fuse.h:655:
+^I */$
ERROR: code indent should never use tabs
#676: FILE: tools/virtiofsd/fuse.h:656:
+^I int (*utimens) (const char *, const struct timespec tv[2],$
ERROR: code indent should never use tabs
#677: FILE: tools/virtiofsd/fuse.h:657:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#679: FILE: tools/virtiofsd/fuse.h:659:
+^I/**$
ERROR: code indent should never use tabs
#680: FILE: tools/virtiofsd/fuse.h:660:
+^I * Map block index within file to block index within device$
ERROR: code indent should never use tabs
#681: FILE: tools/virtiofsd/fuse.h:661:
+^I *$
ERROR: code indent should never use tabs
#682: FILE: tools/virtiofsd/fuse.h:662:
+^I * Note: This makes sense only for block device backed filesystems$
ERROR: code indent should never use tabs
#683: FILE: tools/virtiofsd/fuse.h:663:
+^I * mounted with the 'blkdev' option$
ERROR: code indent should never use tabs
#684: FILE: tools/virtiofsd/fuse.h:664:
+^I */$
ERROR: code indent should never use tabs
#685: FILE: tools/virtiofsd/fuse.h:665:
+^Iint (*bmap) (const char *, size_t blocksize, uint64_t *idx);$
ERROR: code indent should never use tabs
#687: FILE: tools/virtiofsd/fuse.h:667:
+^I/**$
ERROR: code indent should never use tabs
#688: FILE: tools/virtiofsd/fuse.h:668:
+^I * Ioctl$
ERROR: code indent should never use tabs
#689: FILE: tools/virtiofsd/fuse.h:669:
+^I *$
ERROR: code indent should never use tabs
#690: FILE: tools/virtiofsd/fuse.h:670:
+^I * flags will have FUSE_IOCTL_COMPAT set for 32bit ioctls in$
ERROR: code indent should never use tabs
#691: FILE: tools/virtiofsd/fuse.h:671:
+^I * 64bit environment. The size and direction of data is$
ERROR: code indent should never use tabs
#692: FILE: tools/virtiofsd/fuse.h:672:
+^I * determined by _IOC_*() decoding of cmd. For _IOC_NONE,$
ERROR: code indent should never use tabs
#693: FILE: tools/virtiofsd/fuse.h:673:
+^I * data will be NULL, for _IOC_WRITE data is out area, for$
ERROR: code indent should never use tabs
#694: FILE: tools/virtiofsd/fuse.h:674:
+^I * _IOC_READ in area and if both are set in/out area. In all$
ERROR: code indent should never use tabs
#695: FILE: tools/virtiofsd/fuse.h:675:
+^I * non-NULL cases, the area is of _IOC_SIZE(cmd) bytes.$
ERROR: code indent should never use tabs
#696: FILE: tools/virtiofsd/fuse.h:676:
+^I *$
ERROR: code indent should never use tabs
#697: FILE: tools/virtiofsd/fuse.h:677:
+^I * If flags has FUSE_IOCTL_DIR then the fuse_file_info refers to a$
ERROR: code indent should never use tabs
#698: FILE: tools/virtiofsd/fuse.h:678:
+^I * directory file handle.$
ERROR: code indent should never use tabs
#699: FILE: tools/virtiofsd/fuse.h:679:
+^I *$
ERROR: code indent should never use tabs
#700: FILE: tools/virtiofsd/fuse.h:680:
+^I * Note : the unsigned long request submitted by the application$
ERROR: code indent should never use tabs
#701: FILE: tools/virtiofsd/fuse.h:681:
+^I * is truncated to 32 bits.$
ERROR: code indent should never use tabs
#702: FILE: tools/virtiofsd/fuse.h:682:
+^I */$
ERROR: code indent should never use tabs
#703: FILE: tools/virtiofsd/fuse.h:683:
+^Iint (*ioctl) (const char *, unsigned int cmd, void *arg,$
ERROR: code indent should never use tabs
#704: FILE: tools/virtiofsd/fuse.h:684:
+^I^I struct fuse_file_info *, unsigned int flags, void *data);$
ERROR: code indent should never use tabs
#706: FILE: tools/virtiofsd/fuse.h:686:
+^I/**$
ERROR: code indent should never use tabs
#707: FILE: tools/virtiofsd/fuse.h:687:
+^I * Poll for IO readiness events$
ERROR: code indent should never use tabs
#708: FILE: tools/virtiofsd/fuse.h:688:
+^I *$
ERROR: code indent should never use tabs
#709: FILE: tools/virtiofsd/fuse.h:689:
+^I * Note: If ph is non-NULL, the client should notify$
ERROR: code indent should never use tabs
#710: FILE: tools/virtiofsd/fuse.h:690:
+^I * when IO readiness events occur by calling$
ERROR: code indent should never use tabs
#711: FILE: tools/virtiofsd/fuse.h:691:
+^I * fuse_notify_poll() with the specified ph.$
ERROR: code indent should never use tabs
#712: FILE: tools/virtiofsd/fuse.h:692:
+^I *$
ERROR: code indent should never use tabs
#713: FILE: tools/virtiofsd/fuse.h:693:
+^I * Regardless of the number of times poll with a non-NULL ph$
ERROR: code indent should never use tabs
#714: FILE: tools/virtiofsd/fuse.h:694:
+^I * is received, single notification is enough to clear all.$
ERROR: code indent should never use tabs
#715: FILE: tools/virtiofsd/fuse.h:695:
+^I * Notifying more times incurs overhead but doesn't harm$
ERROR: code indent should never use tabs
#716: FILE: tools/virtiofsd/fuse.h:696:
+^I * correctness.$
ERROR: code indent should never use tabs
#717: FILE: tools/virtiofsd/fuse.h:697:
+^I *$
ERROR: code indent should never use tabs
#718: FILE: tools/virtiofsd/fuse.h:698:
+^I * The callee is responsible for destroying ph with$
ERROR: code indent should never use tabs
#719: FILE: tools/virtiofsd/fuse.h:699:
+^I * fuse_pollhandle_destroy() when no longer in use.$
ERROR: code indent should never use tabs
#720: FILE: tools/virtiofsd/fuse.h:700:
+^I */$
ERROR: code indent should never use tabs
#721: FILE: tools/virtiofsd/fuse.h:701:
+^Iint (*poll) (const char *, struct fuse_file_info *,$
ERROR: code indent should never use tabs
#722: FILE: tools/virtiofsd/fuse.h:702:
+^I^I struct fuse_pollhandle *ph, unsigned *reventsp);$
ERROR: code indent should never use tabs
#724: FILE: tools/virtiofsd/fuse.h:704:
+^I/** Write contents of buffer to an open file$
WARNING: Block comments use a leading /* on a separate line
#724: FILE: tools/virtiofsd/fuse.h:704:
+ /** Write contents of buffer to an open file
ERROR: code indent should never use tabs
#725: FILE: tools/virtiofsd/fuse.h:705:
+^I *$
ERROR: code indent should never use tabs
#726: FILE: tools/virtiofsd/fuse.h:706:
+^I * Similar to the write() method, but data is supplied in a$
ERROR: code indent should never use tabs
#727: FILE: tools/virtiofsd/fuse.h:707:
+^I * generic buffer. Use fuse_buf_copy() to transfer data to$
ERROR: code indent should never use tabs
#728: FILE: tools/virtiofsd/fuse.h:708:
+^I * the destination.$
ERROR: code indent should never use tabs
#729: FILE: tools/virtiofsd/fuse.h:709:
+^I *$
ERROR: code indent should never use tabs
#730: FILE: tools/virtiofsd/fuse.h:710:
+^I * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is$
ERROR: code indent should never use tabs
#731: FILE: tools/virtiofsd/fuse.h:711:
+^I * expected to reset the setuid and setgid bits.$
ERROR: code indent should never use tabs
#732: FILE: tools/virtiofsd/fuse.h:712:
+^I */$
ERROR: code indent should never use tabs
#733: FILE: tools/virtiofsd/fuse.h:713:
+^Iint (*write_buf) (const char *, struct fuse_bufvec *buf, off_t off,$
ERROR: code indent should never use tabs
#734: FILE: tools/virtiofsd/fuse.h:714:
+^I^I^I struct fuse_file_info *);$
ERROR: code indent should never use tabs
#736: FILE: tools/virtiofsd/fuse.h:716:
+^I/** Store data from an open file in a buffer$
WARNING: Block comments use a leading /* on a separate line
#736: FILE: tools/virtiofsd/fuse.h:716:
+ /** Store data from an open file in a buffer
ERROR: code indent should never use tabs
#737: FILE: tools/virtiofsd/fuse.h:717:
+^I *$
ERROR: code indent should never use tabs
#738: FILE: tools/virtiofsd/fuse.h:718:
+^I * Similar to the read() method, but data is stored and$
ERROR: code indent should never use tabs
#739: FILE: tools/virtiofsd/fuse.h:719:
+^I * returned in a generic buffer.$
ERROR: code indent should never use tabs
#740: FILE: tools/virtiofsd/fuse.h:720:
+^I *$
ERROR: code indent should never use tabs
#741: FILE: tools/virtiofsd/fuse.h:721:
+^I * No actual copying of data has to take place, the source$
ERROR: code indent should never use tabs
#742: FILE: tools/virtiofsd/fuse.h:722:
+^I * file descriptor may simply be stored in the buffer for$
ERROR: code indent should never use tabs
#743: FILE: tools/virtiofsd/fuse.h:723:
+^I * later data transfer.$
ERROR: code indent should never use tabs
#744: FILE: tools/virtiofsd/fuse.h:724:
+^I *$
ERROR: code indent should never use tabs
#745: FILE: tools/virtiofsd/fuse.h:725:
+^I * The buffer must be allocated dynamically and stored at the$
ERROR: code indent should never use tabs
#746: FILE: tools/virtiofsd/fuse.h:726:
+^I * location pointed to by bufp. If the buffer contains memory$
ERROR: code indent should never use tabs
#747: FILE: tools/virtiofsd/fuse.h:727:
+^I * regions, they too must be allocated using malloc(). The$
ERROR: code indent should never use tabs
#748: FILE: tools/virtiofsd/fuse.h:728:
+^I * allocated memory will be freed by the caller.$
ERROR: code indent should never use tabs
#749: FILE: tools/virtiofsd/fuse.h:729:
+^I */$
ERROR: code indent should never use tabs
#750: FILE: tools/virtiofsd/fuse.h:730:
+^Iint (*read_buf) (const char *, struct fuse_bufvec **bufp,$
ERROR: code indent should never use tabs
#751: FILE: tools/virtiofsd/fuse.h:731:
+^I^I^I size_t size, off_t off, struct fuse_file_info *);$
ERROR: code indent should never use tabs
#752: FILE: tools/virtiofsd/fuse.h:732:
+^I/**$
ERROR: code indent should never use tabs
#753: FILE: tools/virtiofsd/fuse.h:733:
+^I * Perform BSD file locking operation$
ERROR: code indent should never use tabs
#754: FILE: tools/virtiofsd/fuse.h:734:
+^I *$
ERROR: code indent should never use tabs
#755: FILE: tools/virtiofsd/fuse.h:735:
+^I * The op argument will be either LOCK_SH, LOCK_EX or LOCK_UN$
ERROR: code indent should never use tabs
#756: FILE: tools/virtiofsd/fuse.h:736:
+^I *$
ERROR: code indent should never use tabs
#757: FILE: tools/virtiofsd/fuse.h:737:
+^I * Nonblocking requests will be indicated by ORing LOCK_NB to$
ERROR: code indent should never use tabs
#758: FILE: tools/virtiofsd/fuse.h:738:
+^I * the above operations$
ERROR: code indent should never use tabs
#759: FILE: tools/virtiofsd/fuse.h:739:
+^I *$
ERROR: code indent should never use tabs
#760: FILE: tools/virtiofsd/fuse.h:740:
+^I * For more information see the flock(2) manual page.$
ERROR: code indent should never use tabs
#761: FILE: tools/virtiofsd/fuse.h:741:
+^I *$
ERROR: code indent should never use tabs
#762: FILE: tools/virtiofsd/fuse.h:742:
+^I * Additionally fi->owner will be set to a value unique to$
ERROR: code indent should never use tabs
#763: FILE: tools/virtiofsd/fuse.h:743:
+^I * this open file. This same value will be supplied to$
ERROR: code indent should never use tabs
#764: FILE: tools/virtiofsd/fuse.h:744:
+^I * ->release() when the file is released.$
ERROR: code indent should never use tabs
#765: FILE: tools/virtiofsd/fuse.h:745:
+^I *$
ERROR: code indent should never use tabs
#766: FILE: tools/virtiofsd/fuse.h:746:
+^I * Note: if this method is not implemented, the kernel will still$
ERROR: code indent should never use tabs
#767: FILE: tools/virtiofsd/fuse.h:747:
+^I * allow file locking to work locally. Hence it is only$
ERROR: code indent should never use tabs
#768: FILE: tools/virtiofsd/fuse.h:748:
+^I * interesting for network filesystems and similar.$
ERROR: code indent should never use tabs
#769: FILE: tools/virtiofsd/fuse.h:749:
+^I */$
ERROR: code indent should never use tabs
#770: FILE: tools/virtiofsd/fuse.h:750:
+^Iint (*flock) (const char *, struct fuse_file_info *, int op);$
ERROR: code indent should never use tabs
#772: FILE: tools/virtiofsd/fuse.h:752:
+^I/**$
ERROR: code indent should never use tabs
#773: FILE: tools/virtiofsd/fuse.h:753:
+^I * Allocates space for an open file$
ERROR: code indent should never use tabs
#774: FILE: tools/virtiofsd/fuse.h:754:
+^I *$
ERROR: code indent should never use tabs
#775: FILE: tools/virtiofsd/fuse.h:755:
+^I * This function ensures that required space is allocated for specified$
ERROR: code indent should never use tabs
#776: FILE: tools/virtiofsd/fuse.h:756:
+^I * file. If this function returns success then any subsequent write$
ERROR: code indent should never use tabs
#777: FILE: tools/virtiofsd/fuse.h:757:
+^I * request to specified range is guaranteed not to fail because of lack$
ERROR: code indent should never use tabs
#778: FILE: tools/virtiofsd/fuse.h:758:
+^I * of space on the file system media.$
ERROR: code indent should never use tabs
#779: FILE: tools/virtiofsd/fuse.h:759:
+^I */$
ERROR: code indent should never use tabs
#780: FILE: tools/virtiofsd/fuse.h:760:
+^Iint (*fallocate) (const char *, int, off_t, off_t,$
ERROR: code indent should never use tabs
#781: FILE: tools/virtiofsd/fuse.h:761:
+^I^I^I struct fuse_file_info *);$
ERROR: code indent should never use tabs
#783: FILE: tools/virtiofsd/fuse.h:763:
+^I/**$
ERROR: code indent should never use tabs
#784: FILE: tools/virtiofsd/fuse.h:764:
+^I * Copy a range of data from one file to another$
ERROR: code indent should never use tabs
#785: FILE: tools/virtiofsd/fuse.h:765:
+^I *$
ERROR: code indent should never use tabs
#786: FILE: tools/virtiofsd/fuse.h:766:
+^I * Performs an optimized copy between two file descriptors without the$
ERROR: code indent should never use tabs
#787: FILE: tools/virtiofsd/fuse.h:767:
+^I * additional cost of transferring data through the FUSE kernel module$
ERROR: code indent should never use tabs
#788: FILE: tools/virtiofsd/fuse.h:768:
+^I * to user space (glibc) and then back into the FUSE filesystem again.$
ERROR: code indent should never use tabs
#789: FILE: tools/virtiofsd/fuse.h:769:
+^I *$
ERROR: code indent should never use tabs
#790: FILE: tools/virtiofsd/fuse.h:770:
+^I * In case this method is not implemented, glibc falls back to reading$
ERROR: code indent should never use tabs
#791: FILE: tools/virtiofsd/fuse.h:771:
+^I * data from the source and writing to the destination. Effectively$
ERROR: code indent should never use tabs
#792: FILE: tools/virtiofsd/fuse.h:772:
+^I * doing an inefficient copy of the data.$
ERROR: code indent should never use tabs
#793: FILE: tools/virtiofsd/fuse.h:773:
+^I */$
ERROR: code indent should never use tabs
#794: FILE: tools/virtiofsd/fuse.h:774:
+^Issize_t (*copy_file_range) (const char *path_in,$
ERROR: code indent should never use tabs
#795: FILE: tools/virtiofsd/fuse.h:775:
+^I^I^I^I struct fuse_file_info *fi_in,$
ERROR: code indent should never use tabs
#796: FILE: tools/virtiofsd/fuse.h:776:
+^I^I^I^I off_t offset_in, const char *path_out,$
ERROR: code indent should never use tabs
#797: FILE: tools/virtiofsd/fuse.h:777:
+^I^I^I^I struct fuse_file_info *fi_out,$
ERROR: code indent should never use tabs
#798: FILE: tools/virtiofsd/fuse.h:778:
+^I^I^I^I off_t offset_out, size_t size, int flags);$
ERROR: code indent should never use tabs
#800: FILE: tools/virtiofsd/fuse.h:780:
+^I/**$
ERROR: code indent should never use tabs
#801: FILE: tools/virtiofsd/fuse.h:781:
+^I * Find next data or hole after the specified offset$
ERROR: code indent should never use tabs
#802: FILE: tools/virtiofsd/fuse.h:782:
+^I */$
WARNING: line over 80 characters
#803: FILE: tools/virtiofsd/fuse.h:783:
+ off_t (*lseek) (const char *, off_t off, int whence, struct fuse_file_info *);
ERROR: code indent should never use tabs
#803: FILE: tools/virtiofsd/fuse.h:783:
+^Ioff_t (*lseek) (const char *, off_t off, int whence, struct fuse_file_info *);$
WARNING: Block comments use a leading /* on a separate line
#806: FILE: tools/virtiofsd/fuse.h:786:
+/** Extra context that may be needed by some filesystems
ERROR: code indent should never use tabs
#812: FILE: tools/virtiofsd/fuse.h:792:
+^I/** Pointer to the fuse object */$
ERROR: code indent should never use tabs
#813: FILE: tools/virtiofsd/fuse.h:793:
+^Istruct fuse *fuse;$
ERROR: code indent should never use tabs
#815: FILE: tools/virtiofsd/fuse.h:795:
+^I/** User ID of the calling process */$
ERROR: code indent should never use tabs
#816: FILE: tools/virtiofsd/fuse.h:796:
+^Iuid_t uid;$
ERROR: code indent should never use tabs
#818: FILE: tools/virtiofsd/fuse.h:798:
+^I/** Group ID of the calling process */$
ERROR: code indent should never use tabs
#819: FILE: tools/virtiofsd/fuse.h:799:
+^Igid_t gid;$
ERROR: code indent should never use tabs
#821: FILE: tools/virtiofsd/fuse.h:801:
+^I/** Process ID of the calling thread */$
ERROR: code indent should never use tabs
#822: FILE: tools/virtiofsd/fuse.h:802:
+^Ipid_t pid;$
ERROR: code indent should never use tabs
#824: FILE: tools/virtiofsd/fuse.h:804:
+^I/** Private filesystem data */$
ERROR: code indent should never use tabs
#825: FILE: tools/virtiofsd/fuse.h:805:
+^Ivoid *private_data;$
ERROR: code indent should never use tabs
#827: FILE: tools/virtiofsd/fuse.h:807:
+^I/** Umask of the calling process */$
ERROR: code indent should never use tabs
#828: FILE: tools/virtiofsd/fuse.h:808:
+^Imode_t umask;$
WARNING: Block comments use * on subsequent lines
#886: FILE: tools/virtiofsd/fuse.h:866:
+/*
+ int fuse_main(int argc, char *argv[], const struct fuse_operations *op,
ERROR: code indent should never use tabs
#889: FILE: tools/virtiofsd/fuse.h:869:
+#define fuse_main(argc, argv, op, private_data)^I^I^I^I\$
ERROR: code indent should never use tabs
#890: FILE: tools/virtiofsd/fuse.h:870:
+^Ifuse_main_real(argc, argv, op, sizeof(*(op)), private_data)$
WARNING: Block comments use a leading /* on a separate line
#892: FILE: tools/virtiofsd/fuse.h:872:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#893: FILE: tools/virtiofsd/fuse.h:873:
+ * More detailed API^I^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#894: FILE: tools/virtiofsd/fuse.h:874:
+ * ----------------------------------------------------------- */
WARNING: line over 80 characters
#937: FILE: tools/virtiofsd/fuse.h:917:
+struct fuse *fuse_new_30(struct fuse_args *args, const struct fuse_operations *op,
ERROR: code indent should never use tabs
#938: FILE: tools/virtiofsd/fuse.h:918:
+^I^I^I size_t op_size, void *private_data);$
ERROR: code indent should never use tabs
#942: FILE: tools/virtiofsd/fuse.h:922:
+^I^I size_t op_size, void *private_data);$
ERROR: code indent should never use tabs
#967: FILE: tools/virtiofsd/fuse.h:947:
+ * NOTE: This function does not unmount the filesystem.^I If this is$
ERROR: code indent should never use tabs
#1095: FILE: tools/virtiofsd/fuse.h:1075:
+^I^I size_t op_size, void *private_data);$
ERROR: code indent should never use tabs
#1146: FILE: tools/virtiofsd/fuse.h:1126:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1148: FILE: tools/virtiofsd/fuse.h:1128:
+^I^I const char *newpath, unsigned int flags);$
ERROR: code indent should never use tabs
#1152: FILE: tools/virtiofsd/fuse.h:1132:
+^I^I const char *path);$
ERROR: code indent should never use tabs
#1154: FILE: tools/virtiofsd/fuse.h:1134:
+int fuse_fs_release(struct fuse_fs *fs,^I const char *path,$
ERROR: code indent should never use tabs
#1155: FILE: tools/virtiofsd/fuse.h:1135:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1157: FILE: tools/virtiofsd/fuse.h:1137:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1159: FILE: tools/virtiofsd/fuse.h:1139:
+^I^I off_t off, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1161: FILE: tools/virtiofsd/fuse.h:1141:
+^I^I struct fuse_bufvec **bufp, size_t size, off_t off,$
ERROR: code indent should never use tabs
#1162: FILE: tools/virtiofsd/fuse.h:1142:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1164: FILE: tools/virtiofsd/fuse.h:1144:
+^I^I size_t size, off_t off, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1166: FILE: tools/virtiofsd/fuse.h:1146:
+^I^I struct fuse_bufvec *buf, off_t off,$
ERROR: code indent should never use tabs
#1167: FILE: tools/virtiofsd/fuse.h:1147:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1169: FILE: tools/virtiofsd/fuse.h:1149:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1171: FILE: tools/virtiofsd/fuse.h:1151:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1174: FILE: tools/virtiofsd/fuse.h:1154:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1176: FILE: tools/virtiofsd/fuse.h:1156:
+^I^I fuse_fill_dir_t filler, off_t off,$
ERROR: code indent should never use tabs
#1177: FILE: tools/virtiofsd/fuse.h:1157:
+^I^I struct fuse_file_info *fi, enum fuse_readdir_flags flags);$
ERROR: code indent should never use tabs
#1179: FILE: tools/virtiofsd/fuse.h:1159:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1181: FILE: tools/virtiofsd/fuse.h:1161:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1183: FILE: tools/virtiofsd/fuse.h:1163:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1185: FILE: tools/virtiofsd/fuse.h:1165:
+^I^I struct fuse_file_info *fi, int cmd, struct flock *lock);$
ERROR: code indent should never use tabs
#1187: FILE: tools/virtiofsd/fuse.h:1167:
+^I^I struct fuse_file_info *fi, int op);$
ERROR: code indent should never use tabs
#1189: FILE: tools/virtiofsd/fuse.h:1169:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1191: FILE: tools/virtiofsd/fuse.h:1171:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1193: FILE: tools/virtiofsd/fuse.h:1173:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1195: FILE: tools/virtiofsd/fuse.h:1175:
+^I^I const struct timespec tv[2], struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1198: FILE: tools/virtiofsd/fuse.h:1178:
+^I^I size_t len);$
ERROR: code indent should never use tabs
#1200: FILE: tools/virtiofsd/fuse.h:1180:
+^I^I dev_t rdev);$
ERROR: code indent should never use tabs
#1203: FILE: tools/virtiofsd/fuse.h:1183:
+^I^I const char *value, size_t size, int flags);$
ERROR: code indent should never use tabs
#1205: FILE: tools/virtiofsd/fuse.h:1185:
+^I^I char *value, size_t size);$
ERROR: code indent should never use tabs
#1207: FILE: tools/virtiofsd/fuse.h:1187:
+^I^I size_t size);$
ERROR: code indent should never use tabs
#1209: FILE: tools/virtiofsd/fuse.h:1189:
+^I^I^Iconst char *name);$
ERROR: code indent should never use tabs
#1211: FILE: tools/virtiofsd/fuse.h:1191:
+^I^I uint64_t *idx);$
ERROR: code indent should never use tabs
#1213: FILE: tools/virtiofsd/fuse.h:1193:
+^I^I void *arg, struct fuse_file_info *fi, unsigned int flags,$
ERROR: code indent should never use tabs
#1214: FILE: tools/virtiofsd/fuse.h:1194:
+^I^I void *data);$
ERROR: code indent should never use tabs
#1216: FILE: tools/virtiofsd/fuse.h:1196:
+^I^I struct fuse_file_info *fi, struct fuse_pollhandle *ph,$
ERROR: code indent should never use tabs
#1217: FILE: tools/virtiofsd/fuse.h:1197:
+^I^I unsigned *reventsp);$
ERROR: code indent should never use tabs
#1219: FILE: tools/virtiofsd/fuse.h:1199:
+^I^I off_t offset, off_t length, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1221: FILE: tools/virtiofsd/fuse.h:1201:
+^I^I^I^Istruct fuse_file_info *fi_in, off_t off_in,$
ERROR: code indent should never use tabs
#1222: FILE: tools/virtiofsd/fuse.h:1202:
+^I^I^I^Iconst char *path_out,$
ERROR: code indent should never use tabs
#1223: FILE: tools/virtiofsd/fuse.h:1203:
+^I^I^I^Istruct fuse_file_info *fi_out, off_t off_out,$
ERROR: code indent should never use tabs
#1224: FILE: tools/virtiofsd/fuse.h:1204:
+^I^I^I^Isize_t len, int flags);$
ERROR: code indent should never use tabs
#1226: FILE: tools/virtiofsd/fuse.h:1206:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#1228: FILE: tools/virtiofsd/fuse.h:1208:
+^I^Istruct fuse_config *cfg);$
ERROR: code indent should never use tabs
#1247: FILE: tools/virtiofsd/fuse.h:1227:
+^I^I^I void *private_data);$
ERROR: code indent should never use tabs
#1264: FILE: tools/virtiofsd/fuse.h:1244:
+^I^I^I^I^I^I struct fuse_fs *fs[]);$
ERROR: code indent should never use tabs
#1276: FILE: tools/virtiofsd/fuse.h:1256:
+^Ifuse_module_factory_t fuse_module_ ## name_ ## _factory = factory_$
WARNING: architecture specific defines should be avoided
#1291: FILE: tools/virtiofsd/fuse.h:1271:
+#ifdef __cplusplus
WARNING: Block comments use a leading /* on a separate line
#1302: FILE: tools/virtiofsd/fuse_common.h:1:
+/* FUSE: Filesystem in Userspace
WARNING: Block comments use * on subsequent lines
#1303: FILE: tools/virtiofsd/fuse_common.h:2:
+/* FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
ERROR: line over 90 characters
#1312: FILE: tools/virtiofsd/fuse_common.h:11:
+#error "Never include <fuse_common.h> directly; use <fuse.h> or <fuse_lowlevel.h> instead."
WARNING: architecture specific defines should be avoided
#1332: FILE: tools/virtiofsd/fuse_common.h:31:
+#ifdef __cplusplus
ERROR: code indent should never use tabs
#1346: FILE: tools/virtiofsd/fuse_common.h:45:
+^I/** Open flags.^I Available in open() and release() */$
ERROR: code indent should never use tabs
#1347: FILE: tools/virtiofsd/fuse_common.h:46:
+^Iint flags;$
ERROR: code indent should never use tabs
#1349: FILE: tools/virtiofsd/fuse_common.h:48:
+^I/** In case of a write operation indicates if this was caused$
WARNING: Block comments use a leading /* on a separate line
#1349: FILE: tools/virtiofsd/fuse_common.h:48:
+ /** In case of a write operation indicates if this was caused
ERROR: code indent should never use tabs
#1350: FILE: tools/virtiofsd/fuse_common.h:49:
+^I by a delayed write from the page cache. If so, then the$
WARNING: Block comments use * on subsequent lines
#1350: FILE: tools/virtiofsd/fuse_common.h:49:
+ /** In case of a write operation indicates if this was caused
+ by a delayed write from the page cache. If so, then the
ERROR: code indent should never use tabs
#1351: FILE: tools/virtiofsd/fuse_common.h:50:
+^I context's pid, uid, and gid fields will not be valid, and$
ERROR: code indent should never use tabs
#1352: FILE: tools/virtiofsd/fuse_common.h:51:
+^I the *fh* value may not match the *fh* value that would$
ERROR: code indent should never use tabs
#1353: FILE: tools/virtiofsd/fuse_common.h:52:
+^I have been sent with the corresponding individual write$
ERROR: code indent should never use tabs
#1354: FILE: tools/virtiofsd/fuse_common.h:53:
+^I requests if write caching had been disabled. */$
WARNING: Block comments use a trailing */ on a separate line
#1354: FILE: tools/virtiofsd/fuse_common.h:53:
+ requests if write caching had been disabled. */
ERROR: code indent should never use tabs
#1355: FILE: tools/virtiofsd/fuse_common.h:54:
+^Iunsigned int writepage : 1;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1355: FILE: tools/virtiofsd/fuse_common.h:54:
+ unsigned int writepage : 1;
^
ERROR: code indent should never use tabs
#1357: FILE: tools/virtiofsd/fuse_common.h:56:
+^I/** Can be filled in by open, to use direct I/O on this file. */$
ERROR: code indent should never use tabs
#1358: FILE: tools/virtiofsd/fuse_common.h:57:
+^Iunsigned int direct_io : 1;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1358: FILE: tools/virtiofsd/fuse_common.h:57:
+ unsigned int direct_io : 1;
^
ERROR: code indent should never use tabs
#1360: FILE: tools/virtiofsd/fuse_common.h:59:
+^I/** Can be filled in by open. It signals the kernel that any$
WARNING: Block comments use a leading /* on a separate line
#1360: FILE: tools/virtiofsd/fuse_common.h:59:
+ /** Can be filled in by open. It signals the kernel that any
ERROR: code indent should never use tabs
#1361: FILE: tools/virtiofsd/fuse_common.h:60:
+^I currently cached file data (ie., data that the filesystem$
WARNING: Block comments use * on subsequent lines
#1361: FILE: tools/virtiofsd/fuse_common.h:60:
+ /** Can be filled in by open. It signals the kernel that any
+ currently cached file data (ie., data that the filesystem
ERROR: code indent should never use tabs
#1362: FILE: tools/virtiofsd/fuse_common.h:61:
+^I provided the last time the file was open) need not be$
ERROR: code indent should never use tabs
#1363: FILE: tools/virtiofsd/fuse_common.h:62:
+^I invalidated. Has no effect when set in other contexts (in$
ERROR: code indent should never use tabs
#1364: FILE: tools/virtiofsd/fuse_common.h:63:
+^I particular it does nothing when set by opendir()). */$
WARNING: Block comments use a trailing */ on a separate line
#1364: FILE: tools/virtiofsd/fuse_common.h:63:
+ particular it does nothing when set by opendir()). */
ERROR: code indent should never use tabs
#1365: FILE: tools/virtiofsd/fuse_common.h:64:
+^Iunsigned int keep_cache : 1;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1365: FILE: tools/virtiofsd/fuse_common.h:64:
+ unsigned int keep_cache : 1;
^
ERROR: code indent should never use tabs
#1367: FILE: tools/virtiofsd/fuse_common.h:66:
+^I/** Indicates a flush operation. Set in flush operation, also$
WARNING: Block comments use a leading /* on a separate line
#1367: FILE: tools/virtiofsd/fuse_common.h:66:
+ /** Indicates a flush operation. Set in flush operation, also
ERROR: code indent should never use tabs
#1368: FILE: tools/virtiofsd/fuse_common.h:67:
+^I maybe set in highlevel lock operation and lowlevel release$
WARNING: Block comments use * on subsequent lines
#1368: FILE: tools/virtiofsd/fuse_common.h:67:
+ /** Indicates a flush operation. Set in flush operation, also
+ maybe set in highlevel lock operation and lowlevel release
ERROR: code indent should never use tabs
#1369: FILE: tools/virtiofsd/fuse_common.h:68:
+^I operation. */$
WARNING: Block comments use a trailing */ on a separate line
#1369: FILE: tools/virtiofsd/fuse_common.h:68:
+ operation. */
ERROR: code indent should never use tabs
#1370: FILE: tools/virtiofsd/fuse_common.h:69:
+^Iunsigned int flush : 1;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1370: FILE: tools/virtiofsd/fuse_common.h:69:
+ unsigned int flush : 1;
^
ERROR: code indent should never use tabs
#1372: FILE: tools/virtiofsd/fuse_common.h:71:
+^I/** Can be filled in by open, to indicate that the file is not$
WARNING: Block comments use a leading /* on a separate line
#1372: FILE: tools/virtiofsd/fuse_common.h:71:
+ /** Can be filled in by open, to indicate that the file is not
ERROR: code indent should never use tabs
#1373: FILE: tools/virtiofsd/fuse_common.h:72:
+^I seekable. */$
WARNING: Block comments use * on subsequent lines
#1373: FILE: tools/virtiofsd/fuse_common.h:72:
+ /** Can be filled in by open, to indicate that the file is not
+ seekable. */
WARNING: Block comments use a trailing */ on a separate line
#1373: FILE: tools/virtiofsd/fuse_common.h:72:
+ seekable. */
ERROR: code indent should never use tabs
#1374: FILE: tools/virtiofsd/fuse_common.h:73:
+^Iunsigned int nonseekable : 1;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1374: FILE: tools/virtiofsd/fuse_common.h:73:
+ unsigned int nonseekable : 1;
^
ERROR: code indent should never use tabs
#1376: FILE: tools/virtiofsd/fuse_common.h:75:
+^I/* Indicates that flock locks for this file should be$
WARNING: Block comments use a leading /* on a separate line
#1376: FILE: tools/virtiofsd/fuse_common.h:75:
+ /* Indicates that flock locks for this file should be
ERROR: code indent should never use tabs
#1377: FILE: tools/virtiofsd/fuse_common.h:76:
+^I released. If set, lock_owner shall contain a valid value.$
WARNING: Block comments use * on subsequent lines
#1377: FILE: tools/virtiofsd/fuse_common.h:76:
+ /* Indicates that flock locks for this file should be
+ released. If set, lock_owner shall contain a valid value.
ERROR: code indent should never use tabs
#1378: FILE: tools/virtiofsd/fuse_common.h:77:
+^I May only be set in ->release(). */$
WARNING: Block comments use a trailing */ on a separate line
#1378: FILE: tools/virtiofsd/fuse_common.h:77:
+ May only be set in ->release(). */
ERROR: code indent should never use tabs
#1379: FILE: tools/virtiofsd/fuse_common.h:78:
+^Iunsigned int flock_release : 1;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1379: FILE: tools/virtiofsd/fuse_common.h:78:
+ unsigned int flock_release : 1;
^
ERROR: code indent should never use tabs
#1381: FILE: tools/virtiofsd/fuse_common.h:80:
+^I/** Can be filled in by opendir. It signals the kernel to$
WARNING: Block comments use a leading /* on a separate line
#1381: FILE: tools/virtiofsd/fuse_common.h:80:
+ /** Can be filled in by opendir. It signals the kernel to
ERROR: code indent should never use tabs
#1382: FILE: tools/virtiofsd/fuse_common.h:81:
+^I enable caching of entries returned by readdir(). Has no$
WARNING: Block comments use * on subsequent lines
#1382: FILE: tools/virtiofsd/fuse_common.h:81:
+ /** Can be filled in by opendir. It signals the kernel to
+ enable caching of entries returned by readdir(). Has no
ERROR: code indent should never use tabs
#1383: FILE: tools/virtiofsd/fuse_common.h:82:
+^I effect when set in other contexts (in particular it does$
ERROR: code indent should never use tabs
#1384: FILE: tools/virtiofsd/fuse_common.h:83:
+^I nothing when set by open()). */$
WARNING: Block comments use a trailing */ on a separate line
#1384: FILE: tools/virtiofsd/fuse_common.h:83:
+ nothing when set by open()). */
ERROR: code indent should never use tabs
#1385: FILE: tools/virtiofsd/fuse_common.h:84:
+^Iunsigned int cache_readdir : 1;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1385: FILE: tools/virtiofsd/fuse_common.h:84:
+ unsigned int cache_readdir : 1;
^
ERROR: code indent should never use tabs
#1387: FILE: tools/virtiofsd/fuse_common.h:86:
+^I/** Padding. Reserved for future use*/$
ERROR: code indent should never use tabs
#1388: FILE: tools/virtiofsd/fuse_common.h:87:
+^Iunsigned int padding : 25;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1388: FILE: tools/virtiofsd/fuse_common.h:87:
+ unsigned int padding : 25;
^
ERROR: code indent should never use tabs
#1389: FILE: tools/virtiofsd/fuse_common.h:88:
+^Iunsigned int padding2 : 32;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#1389: FILE: tools/virtiofsd/fuse_common.h:88:
+ unsigned int padding2 : 32;
^
ERROR: code indent should never use tabs
#1391: FILE: tools/virtiofsd/fuse_common.h:90:
+^I/** File handle id. May be filled in by filesystem in create,$
WARNING: Block comments use a leading /* on a separate line
#1391: FILE: tools/virtiofsd/fuse_common.h:90:
+ /** File handle id. May be filled in by filesystem in create,
ERROR: code indent should never use tabs
#1392: FILE: tools/virtiofsd/fuse_common.h:91:
+^I * open, and opendir(). Available in most other file operations on the$
ERROR: code indent should never use tabs
#1393: FILE: tools/virtiofsd/fuse_common.h:92:
+^I * same file handle. */$
WARNING: Block comments use a trailing */ on a separate line
#1393: FILE: tools/virtiofsd/fuse_common.h:92:
+ * same file handle. */
ERROR: code indent should never use tabs
#1394: FILE: tools/virtiofsd/fuse_common.h:93:
+^Iuint64_t fh;$
ERROR: code indent should never use tabs
#1396: FILE: tools/virtiofsd/fuse_common.h:95:
+^I/** Lock owner id. Available in locking operations and flush */$
ERROR: code indent should never use tabs
#1397: FILE: tools/virtiofsd/fuse_common.h:96:
+^Iuint64_t lock_owner;$
ERROR: code indent should never use tabs
#1399: FILE: tools/virtiofsd/fuse_common.h:98:
+^I/** Requested poll events. Available in ->poll. Only set on kernels$
WARNING: Block comments use a leading /* on a separate line
#1399: FILE: tools/virtiofsd/fuse_common.h:98:
+ /** Requested poll events. Available in ->poll. Only set on kernels
ERROR: code indent should never use tabs
#1400: FILE: tools/virtiofsd/fuse_common.h:99:
+^I which support it. If unsupported, this field is set to zero. */$
WARNING: Block comments use * on subsequent lines
#1400: FILE: tools/virtiofsd/fuse_common.h:99:
+ /** Requested poll events. Available in ->poll. Only set on kernels
+ which support it. If unsupported, this field is set to zero. */
WARNING: Block comments use a trailing */ on a separate line
#1400: FILE: tools/virtiofsd/fuse_common.h:99:
+ which support it. If unsupported, this field is set to zero. */
ERROR: code indent should never use tabs
#1401: FILE: tools/virtiofsd/fuse_common.h:100:
+^Iuint32_t poll_events;$
ERROR: code indent should never use tabs
#1409: FILE: tools/virtiofsd/fuse_common.h:108:
+^I/**$
ERROR: code indent should never use tabs
#1410: FILE: tools/virtiofsd/fuse_common.h:109:
+^I * whether to use separate device fds for each thread$
ERROR: code indent should never use tabs
#1411: FILE: tools/virtiofsd/fuse_common.h:110:
+^I * (may increase performance)$
ERROR: code indent should never use tabs
#1412: FILE: tools/virtiofsd/fuse_common.h:111:
+^I */$
ERROR: code indent should never use tabs
#1413: FILE: tools/virtiofsd/fuse_common.h:112:
+^Iint clone_fd;$
ERROR: code indent should never use tabs
#1415: FILE: tools/virtiofsd/fuse_common.h:114:
+^I/**$
ERROR: code indent should never use tabs
#1416: FILE: tools/virtiofsd/fuse_common.h:115:
+^I * The maximum number of available worker threads before they$
ERROR: code indent should never use tabs
#1417: FILE: tools/virtiofsd/fuse_common.h:116:
+^I * start to get deleted when they become idle. If not$
ERROR: code indent should never use tabs
#1418: FILE: tools/virtiofsd/fuse_common.h:117:
+^I * specified, the default is 10.$
ERROR: code indent should never use tabs
#1419: FILE: tools/virtiofsd/fuse_common.h:118:
+^I *$
ERROR: code indent should never use tabs
#1420: FILE: tools/virtiofsd/fuse_common.h:119:
+^I * Adjusting this has performance implications; a very small number$
ERROR: code indent should never use tabs
#1421: FILE: tools/virtiofsd/fuse_common.h:120:
+^I * of threads in the pool will cause a lot of thread creation and$
ERROR: code indent should never use tabs
#1422: FILE: tools/virtiofsd/fuse_common.h:121:
+^I * deletion overhead and performance may suffer. When set to 0, a new$
ERROR: code indent should never use tabs
#1423: FILE: tools/virtiofsd/fuse_common.h:122:
+^I * thread will be created to service every operation.$
ERROR: code indent should never use tabs
#1424: FILE: tools/virtiofsd/fuse_common.h:123:
+^I */$
ERROR: code indent should never use tabs
#1425: FILE: tools/virtiofsd/fuse_common.h:124:
+^Iunsigned int max_idle_threads;$
WARNING: Block comments use a leading /* on a separate line
#1428: FILE: tools/virtiofsd/fuse_common.h:127:
+/**************************************************************************
ERROR: code indent should never use tabs
#1442: FILE: tools/virtiofsd/fuse_common.h:141:
+#define FUSE_CAP_ASYNC_READ^I^I(1 << 0)$
ERROR: code indent should never use tabs
#1450: FILE: tools/virtiofsd/fuse_common.h:149:
+#define FUSE_CAP_POSIX_LOCKS^I^I(1 << 1)$
ERROR: code indent should never use tabs
#1459: FILE: tools/virtiofsd/fuse_common.h:158:
+#define FUSE_CAP_ATOMIC_O_TRUNC^I^I(1 << 3)$
ERROR: code indent should never use tabs
#1466: FILE: tools/virtiofsd/fuse_common.h:165:
+#define FUSE_CAP_EXPORT_SUPPORT^I^I(1 << 4)$
ERROR: code indent should never use tabs
#1474: FILE: tools/virtiofsd/fuse_common.h:173:
+#define FUSE_CAP_DONT_MASK^I^I(1 << 6)$
ERROR: code indent should never use tabs
#1482: FILE: tools/virtiofsd/fuse_common.h:181:
+#define FUSE_CAP_SPLICE_WRITE^I^I(1 << 7)$
ERROR: code indent should never use tabs
#1490: FILE: tools/virtiofsd/fuse_common.h:189:
+#define FUSE_CAP_SPLICE_MOVE^I^I(1 << 8)$
ERROR: code indent should never use tabs
#1499: FILE: tools/virtiofsd/fuse_common.h:198:
+#define FUSE_CAP_SPLICE_READ^I^I(1 << 9)$
ERROR: code indent should never use tabs
#1512: FILE: tools/virtiofsd/fuse_common.h:211:
+#define FUSE_CAP_FLOCK_LOCKS^I^I(1 << 10)$
ERROR: code indent should never use tabs
#1519: FILE: tools/virtiofsd/fuse_common.h:218:
+#define FUSE_CAP_IOCTL_DIR^I^I(1 << 11)$
ERROR: code indent should never use tabs
#1541: FILE: tools/virtiofsd/fuse_common.h:240:
+#define FUSE_CAP_AUTO_INVAL_DATA^I(1 << 12)$
ERROR: code indent should never use tabs
#1549: FILE: tools/virtiofsd/fuse_common.h:248:
+#define FUSE_CAP_READDIRPLUS^I^I(1 << 13)$
ERROR: code indent should never use tabs
#1577: FILE: tools/virtiofsd/fuse_common.h:276:
+#define FUSE_CAP_READDIRPLUS_AUTO^I(1 << 14)$
ERROR: code indent should never use tabs
#1588: FILE: tools/virtiofsd/fuse_common.h:287:
+#define FUSE_CAP_ASYNC_DIO^I^I(1 << 15)$
ERROR: code indent should never use tabs
#1597: FILE: tools/virtiofsd/fuse_common.h:296:
+#define FUSE_CAP_WRITEBACK_CACHE^I(1 << 16)$
ERROR: code indent should never use tabs
#1610: FILE: tools/virtiofsd/fuse_common.h:309:
+#define FUSE_CAP_NO_OPEN_SUPPORT^I(1 << 17)$
ERROR: code indent should never use tabs
#1672: FILE: tools/virtiofsd/fuse_common.h:371:
+#define FUSE_IOCTL_COMPAT^I(1 << 0)$
ERROR: code indent should never use tabs
#1673: FILE: tools/virtiofsd/fuse_common.h:372:
+#define FUSE_IOCTL_UNRESTRICTED^I(1 << 1)$
ERROR: code indent should never use tabs
#1674: FILE: tools/virtiofsd/fuse_common.h:373:
+#define FUSE_IOCTL_RETRY^I(1 << 2)$
ERROR: code indent should never use tabs
#1675: FILE: tools/virtiofsd/fuse_common.h:374:
+#define FUSE_IOCTL_DIR^I^I(1 << 4)$
ERROR: code indent should never use tabs
#1677: FILE: tools/virtiofsd/fuse_common.h:376:
+#define FUSE_IOCTL_MAX_IOV^I256$
ERROR: code indent should never use tabs
#1687: FILE: tools/virtiofsd/fuse_common.h:386:
+^I/**$
ERROR: code indent should never use tabs
#1688: FILE: tools/virtiofsd/fuse_common.h:387:
+^I * Major version of the protocol (read-only)$
ERROR: code indent should never use tabs
#1689: FILE: tools/virtiofsd/fuse_common.h:388:
+^I */$
ERROR: code indent should never use tabs
#1690: FILE: tools/virtiofsd/fuse_common.h:389:
+^Iunsigned proto_major;$
ERROR: code indent should never use tabs
#1692: FILE: tools/virtiofsd/fuse_common.h:391:
+^I/**$
ERROR: code indent should never use tabs
#1693: FILE: tools/virtiofsd/fuse_common.h:392:
+^I * Minor version of the protocol (read-only)$
ERROR: code indent should never use tabs
#1694: FILE: tools/virtiofsd/fuse_common.h:393:
+^I */$
ERROR: code indent should never use tabs
#1695: FILE: tools/virtiofsd/fuse_common.h:394:
+^Iunsigned proto_minor;$
ERROR: code indent should never use tabs
#1697: FILE: tools/virtiofsd/fuse_common.h:396:
+^I/**$
ERROR: code indent should never use tabs
#1698: FILE: tools/virtiofsd/fuse_common.h:397:
+^I * Maximum size of the write buffer$
ERROR: code indent should never use tabs
#1699: FILE: tools/virtiofsd/fuse_common.h:398:
+^I */$
ERROR: code indent should never use tabs
#1700: FILE: tools/virtiofsd/fuse_common.h:399:
+^Iunsigned max_write;$
ERROR: code indent should never use tabs
#1702: FILE: tools/virtiofsd/fuse_common.h:401:
+^I/**$
ERROR: code indent should never use tabs
#1703: FILE: tools/virtiofsd/fuse_common.h:402:
+^I * Maximum size of read requests. A value of zero indicates no$
ERROR: code indent should never use tabs
#1704: FILE: tools/virtiofsd/fuse_common.h:403:
+^I * limit. However, even if the filesystem does not specify a$
ERROR: code indent should never use tabs
#1705: FILE: tools/virtiofsd/fuse_common.h:404:
+^I * limit, the maximum size of read requests will still be$
ERROR: code indent should never use tabs
#1706: FILE: tools/virtiofsd/fuse_common.h:405:
+^I * limited by the kernel.$
ERROR: code indent should never use tabs
#1707: FILE: tools/virtiofsd/fuse_common.h:406:
+^I *$
ERROR: code indent should never use tabs
#1708: FILE: tools/virtiofsd/fuse_common.h:407:
+^I * NOTE: For the time being, the maximum size of read requests$
ERROR: code indent should never use tabs
#1709: FILE: tools/virtiofsd/fuse_common.h:408:
+^I * must be set both here *and* passed to fuse_session_new()$
ERROR: code indent should never use tabs
#1710: FILE: tools/virtiofsd/fuse_common.h:409:
+^I * using the ``-o max_read=<n>`` mount option. At some point$
ERROR: code indent should never use tabs
#1711: FILE: tools/virtiofsd/fuse_common.h:410:
+^I * in the future, specifying the mount option will no longer$
ERROR: code indent should never use tabs
#1712: FILE: tools/virtiofsd/fuse_common.h:411:
+^I * be necessary.$
ERROR: code indent should never use tabs
#1713: FILE: tools/virtiofsd/fuse_common.h:412:
+^I */$
ERROR: code indent should never use tabs
#1714: FILE: tools/virtiofsd/fuse_common.h:413:
+^Iunsigned max_read;$
ERROR: code indent should never use tabs
#1716: FILE: tools/virtiofsd/fuse_common.h:415:
+^I/**$
ERROR: code indent should never use tabs
#1717: FILE: tools/virtiofsd/fuse_common.h:416:
+^I * Maximum readahead$
ERROR: code indent should never use tabs
#1718: FILE: tools/virtiofsd/fuse_common.h:417:
+^I */$
ERROR: code indent should never use tabs
#1719: FILE: tools/virtiofsd/fuse_common.h:418:
+^Iunsigned max_readahead;$
ERROR: code indent should never use tabs
#1721: FILE: tools/virtiofsd/fuse_common.h:420:
+^I/**$
ERROR: code indent should never use tabs
#1722: FILE: tools/virtiofsd/fuse_common.h:421:
+^I * Capability flags that the kernel supports (read-only)$
ERROR: code indent should never use tabs
#1723: FILE: tools/virtiofsd/fuse_common.h:422:
+^I */$
ERROR: code indent should never use tabs
#1724: FILE: tools/virtiofsd/fuse_common.h:423:
+^Iunsigned capable;$
ERROR: code indent should never use tabs
#1726: FILE: tools/virtiofsd/fuse_common.h:425:
+^I/**$
ERROR: code indent should never use tabs
#1727: FILE: tools/virtiofsd/fuse_common.h:426:
+^I * Capability flags that the filesystem wants to enable.$
ERROR: code indent should never use tabs
#1728: FILE: tools/virtiofsd/fuse_common.h:427:
+^I *$
ERROR: code indent should never use tabs
#1729: FILE: tools/virtiofsd/fuse_common.h:428:
+^I * libfuse attempts to initialize this field with$
ERROR: code indent should never use tabs
#1730: FILE: tools/virtiofsd/fuse_common.h:429:
+^I * reasonable default values before calling the init() handler.$
ERROR: code indent should never use tabs
#1731: FILE: tools/virtiofsd/fuse_common.h:430:
+^I */$
ERROR: code indent should never use tabs
#1732: FILE: tools/virtiofsd/fuse_common.h:431:
+^Iunsigned want;$
ERROR: code indent should never use tabs
#1734: FILE: tools/virtiofsd/fuse_common.h:433:
+^I/**$
ERROR: code indent should never use tabs
#1735: FILE: tools/virtiofsd/fuse_common.h:434:
+^I * Maximum number of pending "background" requests. A$
ERROR: code indent should never use tabs
#1736: FILE: tools/virtiofsd/fuse_common.h:435:
+^I * background request is any type of request for which the$
ERROR: code indent should never use tabs
#1737: FILE: tools/virtiofsd/fuse_common.h:436:
+^I * total number is not limited by other means. As of kernel$
ERROR: code indent should never use tabs
#1738: FILE: tools/virtiofsd/fuse_common.h:437:
+^I * 4.8, only two types of requests fall into this category:$
ERROR: code indent should never use tabs
#1739: FILE: tools/virtiofsd/fuse_common.h:438:
+^I *$
ERROR: code indent should never use tabs
#1740: FILE: tools/virtiofsd/fuse_common.h:439:
+^I * 1. Read-ahead requests$
ERROR: code indent should never use tabs
#1741: FILE: tools/virtiofsd/fuse_common.h:440:
+^I * 2. Asynchronous direct I/O requests$
ERROR: code indent should never use tabs
#1742: FILE: tools/virtiofsd/fuse_common.h:441:
+^I *$
ERROR: code indent should never use tabs
#1743: FILE: tools/virtiofsd/fuse_common.h:442:
+^I * Read-ahead requests are generated (if max_readahead is$
ERROR: code indent should never use tabs
#1744: FILE: tools/virtiofsd/fuse_common.h:443:
+^I * non-zero) by the kernel to preemptively fill its caches$
ERROR: code indent should never use tabs
#1745: FILE: tools/virtiofsd/fuse_common.h:444:
+^I * when it anticipates that userspace will soon read more$
ERROR: code indent should never use tabs
#1746: FILE: tools/virtiofsd/fuse_common.h:445:
+^I * data.$
ERROR: code indent should never use tabs
#1747: FILE: tools/virtiofsd/fuse_common.h:446:
+^I *$
ERROR: code indent should never use tabs
#1748: FILE: tools/virtiofsd/fuse_common.h:447:
+^I * Asynchronous direct I/O requests are generated if$
ERROR: code indent should never use tabs
#1749: FILE: tools/virtiofsd/fuse_common.h:448:
+^I * FUSE_CAP_ASYNC_DIO is enabled and userspace submits a large$
ERROR: code indent should never use tabs
#1750: FILE: tools/virtiofsd/fuse_common.h:449:
+^I * direct I/O request. In this case the kernel will internally$
ERROR: code indent should never use tabs
#1751: FILE: tools/virtiofsd/fuse_common.h:450:
+^I * split it up into multiple smaller requests and submit them$
ERROR: code indent should never use tabs
#1752: FILE: tools/virtiofsd/fuse_common.h:451:
+^I * to the filesystem concurrently.$
ERROR: code indent should never use tabs
#1753: FILE: tools/virtiofsd/fuse_common.h:452:
+^I *$
ERROR: code indent should never use tabs
#1754: FILE: tools/virtiofsd/fuse_common.h:453:
+^I * Note that the following requests are *not* background$
ERROR: code indent should never use tabs
#1755: FILE: tools/virtiofsd/fuse_common.h:454:
+^I * requests: writeback requests (limited by the kernel's$
ERROR: code indent should never use tabs
#1756: FILE: tools/virtiofsd/fuse_common.h:455:
+^I * flusher algorithm), regular (i.e., synchronous and$
ERROR: code indent should never use tabs
#1757: FILE: tools/virtiofsd/fuse_common.h:456:
+^I * buffered) userspace read/write requests (limited to one per$
ERROR: code indent should never use tabs
#1758: FILE: tools/virtiofsd/fuse_common.h:457:
+^I * thread), asynchronous read requests (Linux's io_submit(2)$
ERROR: code indent should never use tabs
#1759: FILE: tools/virtiofsd/fuse_common.h:458:
+^I * call actually blocks, so these are also limited to one per$
ERROR: code indent should never use tabs
#1760: FILE: tools/virtiofsd/fuse_common.h:459:
+^I * thread).$
ERROR: code indent should never use tabs
#1761: FILE: tools/virtiofsd/fuse_common.h:460:
+^I */$
ERROR: code indent should never use tabs
#1762: FILE: tools/virtiofsd/fuse_common.h:461:
+^Iunsigned max_background;$
ERROR: code indent should never use tabs
#1764: FILE: tools/virtiofsd/fuse_common.h:463:
+^I/**$
ERROR: code indent should never use tabs
#1765: FILE: tools/virtiofsd/fuse_common.h:464:
+^I * Kernel congestion threshold parameter. If the number of pending$
ERROR: code indent should never use tabs
#1766: FILE: tools/virtiofsd/fuse_common.h:465:
+^I * background requests exceeds this number, the FUSE kernel module will$
ERROR: code indent should never use tabs
#1767: FILE: tools/virtiofsd/fuse_common.h:466:
+^I * mark the filesystem as "congested". This instructs the kernel to$
ERROR: code indent should never use tabs
#1768: FILE: tools/virtiofsd/fuse_common.h:467:
+^I * expect that queued requests will take some time to complete, and to$
ERROR: code indent should never use tabs
#1769: FILE: tools/virtiofsd/fuse_common.h:468:
+^I * adjust its algorithms accordingly (e.g. by putting a waiting thread$
ERROR: code indent should never use tabs
#1770: FILE: tools/virtiofsd/fuse_common.h:469:
+^I * to sleep instead of using a busy-loop).$
ERROR: code indent should never use tabs
#1771: FILE: tools/virtiofsd/fuse_common.h:470:
+^I */$
ERROR: code indent should never use tabs
#1772: FILE: tools/virtiofsd/fuse_common.h:471:
+^Iunsigned congestion_threshold;$
ERROR: code indent should never use tabs
#1774: FILE: tools/virtiofsd/fuse_common.h:473:
+^I/**$
ERROR: code indent should never use tabs
#1775: FILE: tools/virtiofsd/fuse_common.h:474:
+^I * When FUSE_CAP_WRITEBACK_CACHE is enabled, the kernel is responsible$
ERROR: code indent should never use tabs
#1776: FILE: tools/virtiofsd/fuse_common.h:475:
+^I * for updating mtime and ctime when write requests are received. The$
ERROR: code indent should never use tabs
#1777: FILE: tools/virtiofsd/fuse_common.h:476:
+^I * updated values are passed to the filesystem with setattr() requests.$
ERROR: code indent should never use tabs
#1778: FILE: tools/virtiofsd/fuse_common.h:477:
+^I * However, if the filesystem does not support the full resolution of$
ERROR: code indent should never use tabs
#1779: FILE: tools/virtiofsd/fuse_common.h:478:
+^I * the kernel timestamps (nanoseconds), the mtime and ctime values used$
ERROR: code indent should never use tabs
#1780: FILE: tools/virtiofsd/fuse_common.h:479:
+^I * by kernel and filesystem will differ (and result in an apparent$
ERROR: code indent should never use tabs
#1781: FILE: tools/virtiofsd/fuse_common.h:480:
+^I * change of times after a cache flush).$
ERROR: code indent should never use tabs
#1782: FILE: tools/virtiofsd/fuse_common.h:481:
+^I *$
ERROR: code indent should never use tabs
#1783: FILE: tools/virtiofsd/fuse_common.h:482:
+^I * To prevent this problem, this variable can be used to inform the$
ERROR: code indent should never use tabs
#1784: FILE: tools/virtiofsd/fuse_common.h:483:
+^I * kernel about the timestamp granularity supported by the file-system.$
ERROR: code indent should never use tabs
#1785: FILE: tools/virtiofsd/fuse_common.h:484:
+^I * The value should be power of 10. The default is 1, i.e. full$
ERROR: code indent should never use tabs
#1786: FILE: tools/virtiofsd/fuse_common.h:485:
+^I * nano-second resolution. Filesystems supporting only second resolution$
ERROR: code indent should never use tabs
#1787: FILE: tools/virtiofsd/fuse_common.h:486:
+^I * should set this to 1000000000.$
ERROR: code indent should never use tabs
#1788: FILE: tools/virtiofsd/fuse_common.h:487:
+^I */$
ERROR: code indent should never use tabs
#1789: FILE: tools/virtiofsd/fuse_common.h:488:
+^Iunsigned time_gran;$
ERROR: code indent should never use tabs
#1791: FILE: tools/virtiofsd/fuse_common.h:490:
+^I/**$
ERROR: code indent should never use tabs
#1792: FILE: tools/virtiofsd/fuse_common.h:491:
+^I * For future use.$
ERROR: code indent should never use tabs
#1793: FILE: tools/virtiofsd/fuse_common.h:492:
+^I */$
ERROR: code indent should never use tabs
#1794: FILE: tools/virtiofsd/fuse_common.h:493:
+^Iunsigned reserved[22];$
WARNING: line over 80 characters
#1821: FILE: tools/virtiofsd/fuse_common.h:520:
+ * -o no_remote_lock Equivalent to -o no_remote_flock,no_remote_posix_lock
ERROR: "foo* bar" should be "foo *bar"
#1843: FILE: tools/virtiofsd/fuse_common.h:542:
+struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args);
ERROR: code indent should never use tabs
#1853: FILE: tools/virtiofsd/fuse_common.h:552:
+^I^I^I struct fuse_conn_info *conn);$
WARNING: Block comments use a leading /* on a separate line
#1884: FILE: tools/virtiofsd/fuse_common.h:583:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#1885: FILE: tools/virtiofsd/fuse_common.h:584:
+ * Data buffer^I^I^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#1886: FILE: tools/virtiofsd/fuse_common.h:585:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#1892: FILE: tools/virtiofsd/fuse_common.h:591:
+^I/**$
ERROR: code indent should never use tabs
#1893: FILE: tools/virtiofsd/fuse_common.h:592:
+^I * Buffer contains a file descriptor$
ERROR: code indent should never use tabs
#1894: FILE: tools/virtiofsd/fuse_common.h:593:
+^I *$
ERROR: code indent should never use tabs
#1895: FILE: tools/virtiofsd/fuse_common.h:594:
+^I * If this flag is set, the .fd field is valid, otherwise the$
ERROR: code indent should never use tabs
#1896: FILE: tools/virtiofsd/fuse_common.h:595:
+^I * .mem fields is valid.$
ERROR: code indent should never use tabs
#1897: FILE: tools/virtiofsd/fuse_common.h:596:
+^I */$
ERROR: code indent should never use tabs
#1898: FILE: tools/virtiofsd/fuse_common.h:597:
+^IFUSE_BUF_IS_FD^I^I= (1 << 1),$
ERROR: code indent should never use tabs
#1900: FILE: tools/virtiofsd/fuse_common.h:599:
+^I/**$
ERROR: code indent should never use tabs
#1901: FILE: tools/virtiofsd/fuse_common.h:600:
+^I * Seek on the file descriptor$
ERROR: code indent should never use tabs
#1902: FILE: tools/virtiofsd/fuse_common.h:601:
+^I *$
ERROR: code indent should never use tabs
#1903: FILE: tools/virtiofsd/fuse_common.h:602:
+^I * If this flag is set then the .pos field is valid and is$
ERROR: code indent should never use tabs
#1904: FILE: tools/virtiofsd/fuse_common.h:603:
+^I * used to seek to the given offset before performing$
ERROR: code indent should never use tabs
#1905: FILE: tools/virtiofsd/fuse_common.h:604:
+^I * operation on file descriptor.$
ERROR: code indent should never use tabs
#1906: FILE: tools/virtiofsd/fuse_common.h:605:
+^I */$
ERROR: code indent should never use tabs
#1907: FILE: tools/virtiofsd/fuse_common.h:606:
+^IFUSE_BUF_FD_SEEK^I= (1 << 2),$
ERROR: code indent should never use tabs
#1909: FILE: tools/virtiofsd/fuse_common.h:608:
+^I/**$
ERROR: code indent should never use tabs
#1910: FILE: tools/virtiofsd/fuse_common.h:609:
+^I * Retry operation on file descriptor$
ERROR: code indent should never use tabs
#1911: FILE: tools/virtiofsd/fuse_common.h:610:
+^I *$
ERROR: code indent should never use tabs
#1912: FILE: tools/virtiofsd/fuse_common.h:611:
+^I * If this flag is set then retry operation on file descriptor$
ERROR: code indent should never use tabs
#1913: FILE: tools/virtiofsd/fuse_common.h:612:
+^I * until .size bytes have been copied or an error or EOF is$
ERROR: code indent should never use tabs
#1914: FILE: tools/virtiofsd/fuse_common.h:613:
+^I * detected.$
ERROR: code indent should never use tabs
#1915: FILE: tools/virtiofsd/fuse_common.h:614:
+^I */$
ERROR: code indent should never use tabs
#1916: FILE: tools/virtiofsd/fuse_common.h:615:
+^IFUSE_BUF_FD_RETRY^I= (1 << 3),$
ERROR: code indent should never use tabs
#1923: FILE: tools/virtiofsd/fuse_common.h:622:
+^I/**$
ERROR: code indent should never use tabs
#1924: FILE: tools/virtiofsd/fuse_common.h:623:
+^I * Don't use splice(2)$
ERROR: code indent should never use tabs
#1925: FILE: tools/virtiofsd/fuse_common.h:624:
+^I *$
ERROR: code indent should never use tabs
#1926: FILE: tools/virtiofsd/fuse_common.h:625:
+^I * Always fall back to using read and write instead of$
ERROR: code indent should never use tabs
#1927: FILE: tools/virtiofsd/fuse_common.h:626:
+^I * splice(2) to copy data from one file descriptor to another.$
ERROR: code indent should never use tabs
#1928: FILE: tools/virtiofsd/fuse_common.h:627:
+^I *$
ERROR: code indent should never use tabs
#1929: FILE: tools/virtiofsd/fuse_common.h:628:
+^I * If this flag is not set, then only fall back if splice is$
ERROR: code indent should never use tabs
#1930: FILE: tools/virtiofsd/fuse_common.h:629:
+^I * unavailable.$
ERROR: code indent should never use tabs
#1931: FILE: tools/virtiofsd/fuse_common.h:630:
+^I */$
ERROR: code indent should never use tabs
#1932: FILE: tools/virtiofsd/fuse_common.h:631:
+^IFUSE_BUF_NO_SPLICE^I= (1 << 1),$
ERROR: code indent should never use tabs
#1934: FILE: tools/virtiofsd/fuse_common.h:633:
+^I/**$
ERROR: code indent should never use tabs
#1935: FILE: tools/virtiofsd/fuse_common.h:634:
+^I * Force splice$
ERROR: code indent should never use tabs
#1936: FILE: tools/virtiofsd/fuse_common.h:635:
+^I *$
ERROR: code indent should never use tabs
#1937: FILE: tools/virtiofsd/fuse_common.h:636:
+^I * Always use splice(2) to copy data from one file descriptor$
ERROR: code indent should never use tabs
#1938: FILE: tools/virtiofsd/fuse_common.h:637:
+^I * to another. If splice is not available, return -EINVAL.$
ERROR: code indent should never use tabs
#1939: FILE: tools/virtiofsd/fuse_common.h:638:
+^I */$
ERROR: code indent should never use tabs
#1940: FILE: tools/virtiofsd/fuse_common.h:639:
+^IFUSE_BUF_FORCE_SPLICE^I= (1 << 2),$
ERROR: code indent should never use tabs
#1942: FILE: tools/virtiofsd/fuse_common.h:641:
+^I/**$
ERROR: code indent should never use tabs
#1943: FILE: tools/virtiofsd/fuse_common.h:642:
+^I * Try to move data with splice.$
ERROR: code indent should never use tabs
#1944: FILE: tools/virtiofsd/fuse_common.h:643:
+^I *$
ERROR: code indent should never use tabs
#1945: FILE: tools/virtiofsd/fuse_common.h:644:
+^I * If splice is used, try to move pages from the source to the$
ERROR: code indent should never use tabs
#1946: FILE: tools/virtiofsd/fuse_common.h:645:
+^I * destination instead of copying. See documentation of$
ERROR: code indent should never use tabs
#1947: FILE: tools/virtiofsd/fuse_common.h:646:
+^I * SPLICE_F_MOVE in splice(2) man page.$
ERROR: code indent should never use tabs
#1948: FILE: tools/virtiofsd/fuse_common.h:647:
+^I */$
ERROR: code indent should never use tabs
#1949: FILE: tools/virtiofsd/fuse_common.h:648:
+^IFUSE_BUF_SPLICE_MOVE^I= (1 << 3),$
ERROR: code indent should never use tabs
#1951: FILE: tools/virtiofsd/fuse_common.h:650:
+^I/**$
ERROR: code indent should never use tabs
#1952: FILE: tools/virtiofsd/fuse_common.h:651:
+^I * Don't block on the pipe when copying data with splice$
ERROR: code indent should never use tabs
#1953: FILE: tools/virtiofsd/fuse_common.h:652:
+^I *$
ERROR: code indent should never use tabs
#1954: FILE: tools/virtiofsd/fuse_common.h:653:
+^I * Makes the operations on the pipe non-blocking (if the pipe$
ERROR: code indent should never use tabs
#1955: FILE: tools/virtiofsd/fuse_common.h:654:
+^I * is full or empty). See SPLICE_F_NONBLOCK in the splice(2)$
ERROR: code indent should never use tabs
#1956: FILE: tools/virtiofsd/fuse_common.h:655:
+^I * man page.$
ERROR: code indent should never use tabs
#1957: FILE: tools/virtiofsd/fuse_common.h:656:
+^I */$
ERROR: code indent should never use tabs
#1958: FILE: tools/virtiofsd/fuse_common.h:657:
+^IFUSE_BUF_SPLICE_NONBLOCK= (1 << 4),$
ERROR: spaces required around that '=' (ctx:VxW)
#1958: FILE: tools/virtiofsd/fuse_common.h:657:
+ FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
^
ERROR: code indent should never use tabs
#1968: FILE: tools/virtiofsd/fuse_common.h:667:
+^I/**$
ERROR: code indent should never use tabs
#1969: FILE: tools/virtiofsd/fuse_common.h:668:
+^I * Size of data in bytes$
ERROR: code indent should never use tabs
#1970: FILE: tools/virtiofsd/fuse_common.h:669:
+^I */$
ERROR: code indent should never use tabs
#1971: FILE: tools/virtiofsd/fuse_common.h:670:
+^Isize_t size;$
ERROR: code indent should never use tabs
#1973: FILE: tools/virtiofsd/fuse_common.h:672:
+^I/**$
ERROR: code indent should never use tabs
#1974: FILE: tools/virtiofsd/fuse_common.h:673:
+^I * Buffer flags$
ERROR: code indent should never use tabs
#1975: FILE: tools/virtiofsd/fuse_common.h:674:
+^I */$
ERROR: code indent should never use tabs
#1976: FILE: tools/virtiofsd/fuse_common.h:675:
+^Ienum fuse_buf_flags flags;$
ERROR: code indent should never use tabs
#1978: FILE: tools/virtiofsd/fuse_common.h:677:
+^I/**$
ERROR: code indent should never use tabs
#1979: FILE: tools/virtiofsd/fuse_common.h:678:
+^I * Memory pointer$
ERROR: code indent should never use tabs
#1980: FILE: tools/virtiofsd/fuse_common.h:679:
+^I *$
ERROR: code indent should never use tabs
#1981: FILE: tools/virtiofsd/fuse_common.h:680:
+^I * Used unless FUSE_BUF_IS_FD flag is set.$
ERROR: code indent should never use tabs
#1982: FILE: tools/virtiofsd/fuse_common.h:681:
+^I */$
ERROR: code indent should never use tabs
#1983: FILE: tools/virtiofsd/fuse_common.h:682:
+^Ivoid *mem;$
ERROR: code indent should never use tabs
#1985: FILE: tools/virtiofsd/fuse_common.h:684:
+^I/**$
ERROR: code indent should never use tabs
#1986: FILE: tools/virtiofsd/fuse_common.h:685:
+^I * File descriptor$
ERROR: code indent should never use tabs
#1987: FILE: tools/virtiofsd/fuse_common.h:686:
+^I *$
ERROR: code indent should never use tabs
#1988: FILE: tools/virtiofsd/fuse_common.h:687:
+^I * Used if FUSE_BUF_IS_FD flag is set.$
ERROR: code indent should never use tabs
#1989: FILE: tools/virtiofsd/fuse_common.h:688:
+^I */$
ERROR: code indent should never use tabs
#1990: FILE: tools/virtiofsd/fuse_common.h:689:
+^Iint fd;$
ERROR: code indent should never use tabs
#1992: FILE: tools/virtiofsd/fuse_common.h:691:
+^I/**$
ERROR: code indent should never use tabs
#1993: FILE: tools/virtiofsd/fuse_common.h:692:
+^I * File position$
ERROR: code indent should never use tabs
#1994: FILE: tools/virtiofsd/fuse_common.h:693:
+^I *$
ERROR: code indent should never use tabs
#1995: FILE: tools/virtiofsd/fuse_common.h:694:
+^I * Used if FUSE_BUF_FD_SEEK flag is set.$
ERROR: code indent should never use tabs
#1996: FILE: tools/virtiofsd/fuse_common.h:695:
+^I */$
ERROR: code indent should never use tabs
#1997: FILE: tools/virtiofsd/fuse_common.h:696:
+^Ioff_t pos;$
ERROR: code indent should never use tabs
#2009: FILE: tools/virtiofsd/fuse_common.h:708:
+^I/**$
ERROR: code indent should never use tabs
#2010: FILE: tools/virtiofsd/fuse_common.h:709:
+^I * Number of buffers in the array$
ERROR: code indent should never use tabs
#2011: FILE: tools/virtiofsd/fuse_common.h:710:
+^I */$
ERROR: code indent should never use tabs
#2012: FILE: tools/virtiofsd/fuse_common.h:711:
+^Isize_t count;$
ERROR: code indent should never use tabs
#2014: FILE: tools/virtiofsd/fuse_common.h:713:
+^I/**$
ERROR: code indent should never use tabs
#2015: FILE: tools/virtiofsd/fuse_common.h:714:
+^I * Index of current buffer within the array$
ERROR: code indent should never use tabs
#2016: FILE: tools/virtiofsd/fuse_common.h:715:
+^I */$
ERROR: code indent should never use tabs
#2017: FILE: tools/virtiofsd/fuse_common.h:716:
+^Isize_t idx;$
ERROR: code indent should never use tabs
#2019: FILE: tools/virtiofsd/fuse_common.h:718:
+^I/**$
ERROR: code indent should never use tabs
#2020: FILE: tools/virtiofsd/fuse_common.h:719:
+^I * Current offset within the current buffer$
ERROR: code indent should never use tabs
#2021: FILE: tools/virtiofsd/fuse_common.h:720:
+^I */$
ERROR: code indent should never use tabs
#2022: FILE: tools/virtiofsd/fuse_common.h:721:
+^Isize_t off;$
ERROR: code indent should never use tabs
#2024: FILE: tools/virtiofsd/fuse_common.h:723:
+^I/**$
ERROR: code indent should never use tabs
#2025: FILE: tools/virtiofsd/fuse_common.h:724:
+^I * Array of buffers$
ERROR: code indent should never use tabs
#2026: FILE: tools/virtiofsd/fuse_common.h:725:
+^I */$
ERROR: code indent should never use tabs
#2027: FILE: tools/virtiofsd/fuse_common.h:726:
+^Istruct fuse_buf buf[1];$
ERROR: code indent should never use tabs
#2031: FILE: tools/virtiofsd/fuse_common.h:730:
+#define FUSE_BUFVEC_INIT(size__)^I^I^I^I\$
ERROR: code indent should never use tabs
#2032: FILE: tools/virtiofsd/fuse_common.h:731:
+^I((struct fuse_bufvec) {^I^I^I^I^I\$
ERROR: code indent should never use tabs
#2033: FILE: tools/virtiofsd/fuse_common.h:732:
+^I^I/* .count= */ 1,^I^I^I^I\$
WARNING: Block comments use a leading /* on a separate line
#2033: FILE: tools/virtiofsd/fuse_common.h:732:
+ /* .count= */ 1, \
ERROR: code indent should never use tabs
#2034: FILE: tools/virtiofsd/fuse_common.h:733:
+^I^I/* .idx = */ 0,^I^I^I^I\$
WARNING: Block comments use a leading /* on a separate line
#2034: FILE: tools/virtiofsd/fuse_common.h:733:
+ /* .idx = */ 0, \
ERROR: code indent should never use tabs
#2035: FILE: tools/virtiofsd/fuse_common.h:734:
+^I^I/* .off = */ 0,^I^I^I^I\$
WARNING: Block comments use a leading /* on a separate line
#2035: FILE: tools/virtiofsd/fuse_common.h:734:
+ /* .off = */ 0, \
ERROR: code indent should never use tabs
#2036: FILE: tools/virtiofsd/fuse_common.h:735:
+^I^I/* .buf = */ { /* [0] = */ {^I^I^I\$
WARNING: Block comments use a leading /* on a separate line
#2036: FILE: tools/virtiofsd/fuse_common.h:735:
+ /* .buf = */ { /* [0] = */ { \
ERROR: code indent should never use tabs
#2037: FILE: tools/virtiofsd/fuse_common.h:736:
+^I^I^I/* .size = */ (size__),^I^I\$
WARNING: Block comments use a leading /* on a separate line
#2037: FILE: tools/virtiofsd/fuse_common.h:736:
+ /* .size = */ (size__), \
ERROR: code indent should never use tabs
#2038: FILE: tools/virtiofsd/fuse_common.h:737:
+^I^I^I/* .flags = */ (enum fuse_buf_flags) 0,^I\$
WARNING: Block comments use a leading /* on a separate line
#2038: FILE: tools/virtiofsd/fuse_common.h:737:
+ /* .flags = */ (enum fuse_buf_flags) 0, \
ERROR: code indent should never use tabs
#2039: FILE: tools/virtiofsd/fuse_common.h:738:
+^I^I^I/* .mem = */ NULL,^I^I^I\$
WARNING: Block comments use a leading /* on a separate line
#2039: FILE: tools/virtiofsd/fuse_common.h:738:
+ /* .mem = */ NULL, \
ERROR: code indent should never use tabs
#2040: FILE: tools/virtiofsd/fuse_common.h:739:
+^I^I^I/* .fd = */ -1,^I^I^I\$
WARNING: Block comments use a leading /* on a separate line
#2040: FILE: tools/virtiofsd/fuse_common.h:739:
+ /* .fd = */ -1, \
ERROR: code indent should never use tabs
#2041: FILE: tools/virtiofsd/fuse_common.h:740:
+^I^I^I/* .pos = */ 0,^I^I^I\$
WARNING: Block comments use a leading /* on a separate line
#2041: FILE: tools/virtiofsd/fuse_common.h:740:
+ /* .pos = */ 0, \
ERROR: code indent should never use tabs
#2042: FILE: tools/virtiofsd/fuse_common.h:741:
+^I^I} }^I^I^I^I^I^I\$
ERROR: code indent should never use tabs
#2043: FILE: tools/virtiofsd/fuse_common.h:742:
+^I} )$
ERROR: space prohibited before that close parenthesis ')'
#2043: FILE: tools/virtiofsd/fuse_common.h:742:
+ } )
ERROR: code indent should never use tabs
#2062: FILE: tools/virtiofsd/fuse_common.h:761:
+^I^I enum fuse_buf_copy_flags flags);$
WARNING: Block comments use a leading /* on a separate line
#2064: FILE: tools/virtiofsd/fuse_common.h:763:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#2065: FILE: tools/virtiofsd/fuse_common.h:764:
+ * Signal handling^I^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#2066: FILE: tools/virtiofsd/fuse_common.h:765:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#2071: FILE: tools/virtiofsd/fuse_common.h:770:
+ * Stores session in a global variable.^I May only be called once per$
WARNING: Block comments use a leading /* on a separate line
#2098: FILE: tools/virtiofsd/fuse_common.h:797:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#2099: FILE: tools/virtiofsd/fuse_common.h:798:
+ * Compatibility stuff^I^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#2100: FILE: tools/virtiofsd/fuse_common.h:799:
+ * ----------------------------------------------------------- */
WARNING: architecture specific defines should be avoided
#2106: FILE: tools/virtiofsd/fuse_common.h:805:
+#ifdef __cplusplus
ERROR: line over 90 characters
#2117: FILE: tools/virtiofsd/fuse_common.h:816:
+#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
WARNING: architecture specific defines should be avoided
#2117: FILE: tools/virtiofsd/fuse_common.h:816:
+#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
ERROR: code indent should never use tabs
#2121: FILE: tools/virtiofsd/fuse_common.h:820:
+^I{ unsigned _fuse_off_t_must_be_64bit:((sizeof(off_t) == 8) ? 1 : -1); };$
WARNING: Block comments use * on subsequent lines
#2132: FILE: tools/virtiofsd/fuse_i.h:2:
+/*
+ FUSE: Filesystem in Userspace
ERROR: code indent should never use tabs
#2145: FILE: tools/virtiofsd/fuse_i.h:15:
+^Istruct fuse_session *se;$
ERROR: code indent should never use tabs
#2146: FILE: tools/virtiofsd/fuse_i.h:16:
+^Iuint64_t unique;$
ERROR: code indent should never use tabs
#2147: FILE: tools/virtiofsd/fuse_i.h:17:
+^Iint ctr;$
ERROR: code indent should never use tabs
#2148: FILE: tools/virtiofsd/fuse_i.h:18:
+^Ipthread_mutex_t lock;$
ERROR: code indent should never use tabs
#2149: FILE: tools/virtiofsd/fuse_i.h:19:
+^Istruct fuse_ctx ctx;$
ERROR: code indent should never use tabs
#2150: FILE: tools/virtiofsd/fuse_i.h:20:
+^Istruct fuse_chan *ch;$
ERROR: code indent should never use tabs
#2151: FILE: tools/virtiofsd/fuse_i.h:21:
+^Iint interrupted;$
ERROR: code indent should never use tabs
#2152: FILE: tools/virtiofsd/fuse_i.h:22:
+^Iunsigned int ioctl_64bit : 1;$
ERROR: spaces prohibited around that ':' (ctx:WxW)
#2152: FILE: tools/virtiofsd/fuse_i.h:22:
+ unsigned int ioctl_64bit : 1;
^
ERROR: code indent should never use tabs
#2153: FILE: tools/virtiofsd/fuse_i.h:23:
+^Iunion {$
ERROR: code indent should never use tabs
#2154: FILE: tools/virtiofsd/fuse_i.h:24:
+^I^Istruct {$
ERROR: code indent should never use tabs
#2155: FILE: tools/virtiofsd/fuse_i.h:25:
+^I^I^Iuint64_t unique;$
ERROR: code indent should never use tabs
#2156: FILE: tools/virtiofsd/fuse_i.h:26:
+^I^I} i;$
ERROR: code indent should never use tabs
#2157: FILE: tools/virtiofsd/fuse_i.h:27:
+^I^Istruct {$
ERROR: code indent should never use tabs
#2158: FILE: tools/virtiofsd/fuse_i.h:28:
+^I^I^Ifuse_interrupt_func_t func;$
ERROR: code indent should never use tabs
#2159: FILE: tools/virtiofsd/fuse_i.h:29:
+^I^I^Ivoid *data;$
ERROR: code indent should never use tabs
#2160: FILE: tools/virtiofsd/fuse_i.h:30:
+^I^I} ni;$
ERROR: code indent should never use tabs
#2161: FILE: tools/virtiofsd/fuse_i.h:31:
+^I} u;$
ERROR: code indent should never use tabs
#2162: FILE: tools/virtiofsd/fuse_i.h:32:
+^Istruct fuse_req *next;$
ERROR: code indent should never use tabs
#2163: FILE: tools/virtiofsd/fuse_i.h:33:
+^Istruct fuse_req *prev;$
ERROR: code indent should never use tabs
#2167: FILE: tools/virtiofsd/fuse_i.h:37:
+^Iuint64_t unique;$
ERROR: code indent should never use tabs
#2168: FILE: tools/virtiofsd/fuse_i.h:38:
+^Ivoid (*reply)(struct fuse_notify_req *, fuse_req_t, fuse_ino_t,$
ERROR: code indent should never use tabs
#2169: FILE: tools/virtiofsd/fuse_i.h:39:
+^I^I const void *, const struct fuse_buf *);$
ERROR: code indent should never use tabs
#2170: FILE: tools/virtiofsd/fuse_i.h:40:
+^Istruct fuse_notify_req *next;$
ERROR: code indent should never use tabs
#2171: FILE: tools/virtiofsd/fuse_i.h:41:
+^Istruct fuse_notify_req *prev;$
ERROR: code indent should never use tabs
#2175: FILE: tools/virtiofsd/fuse_i.h:45:
+^Ichar *mountpoint;$
ERROR: code indent should never use tabs
#2176: FILE: tools/virtiofsd/fuse_i.h:46:
+^Ivolatile int exited;$
ERROR: Use of volatile is usually wrong, please add a comment
#2176: FILE: tools/virtiofsd/fuse_i.h:46:
+ volatile int exited;
ERROR: code indent should never use tabs
#2177: FILE: tools/virtiofsd/fuse_i.h:47:
+^Iint fd;$
ERROR: code indent should never use tabs
#2178: FILE: tools/virtiofsd/fuse_i.h:48:
+^Istruct mount_opts *mo;$
ERROR: code indent should never use tabs
#2179: FILE: tools/virtiofsd/fuse_i.h:49:
+^Iint debug;$
ERROR: code indent should never use tabs
#2180: FILE: tools/virtiofsd/fuse_i.h:50:
+^Iint deny_others;$
ERROR: code indent should never use tabs
#2181: FILE: tools/virtiofsd/fuse_i.h:51:
+^Istruct fuse_lowlevel_ops op;$
ERROR: code indent should never use tabs
#2182: FILE: tools/virtiofsd/fuse_i.h:52:
+^Iint got_init;$
ERROR: code indent should never use tabs
#2183: FILE: tools/virtiofsd/fuse_i.h:53:
+^Istruct cuse_data *cuse_data;$
ERROR: code indent should never use tabs
#2184: FILE: tools/virtiofsd/fuse_i.h:54:
+^Ivoid *userdata;$
ERROR: code indent should never use tabs
#2185: FILE: tools/virtiofsd/fuse_i.h:55:
+^Iuid_t owner;$
ERROR: code indent should never use tabs
#2186: FILE: tools/virtiofsd/fuse_i.h:56:
+^Istruct fuse_conn_info conn;$
ERROR: code indent should never use tabs
#2187: FILE: tools/virtiofsd/fuse_i.h:57:
+^Istruct fuse_req list;$
ERROR: code indent should never use tabs
#2188: FILE: tools/virtiofsd/fuse_i.h:58:
+^Istruct fuse_req interrupts;$
ERROR: code indent should never use tabs
#2189: FILE: tools/virtiofsd/fuse_i.h:59:
+^Ipthread_mutex_t lock;$
ERROR: code indent should never use tabs
#2190: FILE: tools/virtiofsd/fuse_i.h:60:
+^Iint got_destroy;$
ERROR: code indent should never use tabs
#2191: FILE: tools/virtiofsd/fuse_i.h:61:
+^Ipthread_key_t pipe_key;$
ERROR: code indent should never use tabs
#2192: FILE: tools/virtiofsd/fuse_i.h:62:
+^Iint broken_splice_nonblock;$
ERROR: code indent should never use tabs
#2193: FILE: tools/virtiofsd/fuse_i.h:63:
+^Iuint64_t notify_ctr;$
ERROR: code indent should never use tabs
#2194: FILE: tools/virtiofsd/fuse_i.h:64:
+^Istruct fuse_notify_req notify_list;$
ERROR: code indent should never use tabs
#2195: FILE: tools/virtiofsd/fuse_i.h:65:
+^Isize_t bufsize;$
ERROR: code indent should never use tabs
#2196: FILE: tools/virtiofsd/fuse_i.h:66:
+^Iint error;$
ERROR: code indent should never use tabs
#2200: FILE: tools/virtiofsd/fuse_i.h:70:
+^Ipthread_mutex_t lock;$
ERROR: code indent should never use tabs
#2201: FILE: tools/virtiofsd/fuse_i.h:71:
+^Iint ctr;$
ERROR: code indent should never use tabs
#2202: FILE: tools/virtiofsd/fuse_i.h:72:
+^Iint fd;$
ERROR: code indent should never use tabs
#2213: FILE: tools/virtiofsd/fuse_i.h:83:
+^Ichar *name;$
ERROR: code indent should never use tabs
#2214: FILE: tools/virtiofsd/fuse_i.h:84:
+^Ifuse_module_factory_t factory;$
ERROR: code indent should never use tabs
#2215: FILE: tools/virtiofsd/fuse_i.h:85:
+^Istruct fuse_module *next;$
ERROR: code indent should never use tabs
#2216: FILE: tools/virtiofsd/fuse_i.h:86:
+^Istruct fusemod_so *so;$
ERROR: code indent should never use tabs
#2217: FILE: tools/virtiofsd/fuse_i.h:87:
+^Iint ctr;$
WARNING: Block comments use a leading /* on a separate line
#2220: FILE: tools/virtiofsd/fuse_i.h:90:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#2221: FILE: tools/virtiofsd/fuse_i.h:91:
+ * Channel interface (when using -o clone_fd)^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#2222: FILE: tools/virtiofsd/fuse_i.h:92:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#2247: FILE: tools/virtiofsd/fuse_i.h:117:
+^I^I^I int count);$
ERROR: code indent should never use tabs
#2255: FILE: tools/virtiofsd/fuse_i.h:125:
+^I^I^I^I struct fuse_chan *ch);$
WARNING: line over 80 characters
#2257: FILE: tools/virtiofsd/fuse_i.h:127:
+ const struct fuse_buf *buf, struct fuse_chan *ch);
ERROR: code indent should never use tabs
#2257: FILE: tools/virtiofsd/fuse_i.h:127:
+^I^I^I^I const struct fuse_buf *buf, struct fuse_chan *ch);$
WARNING: line over 80 characters
#2259: FILE: tools/virtiofsd/fuse_i.h:129:
+struct fuse *fuse_new_31(struct fuse_args *args, const struct fuse_operations *op,
ERROR: code indent should never use tabs
#2260: FILE: tools/virtiofsd/fuse_i.h:130:
+^I^I size_t op_size, void *private_data);$
WARNING: line over 80 characters
#2262: FILE: tools/virtiofsd/fuse_i.h:132:
+int fuse_session_loop_mt_32(struct fuse_session *se, struct fuse_loop_config *config);
WARNING: Block comments use * on subsequent lines
#2277: FILE: tools/virtiofsd/fuse_log.h:2:
+/*
+ FUSE: Filesystem in Userspace
WARNING: Block comments use a leading /* on a separate line
#2287: FILE: tools/virtiofsd/fuse_log.h:12:
+/** @file
WARNING: architecture specific defines should be avoided
#2294: FILE: tools/virtiofsd/fuse_log.h:19:
+#ifdef __cplusplus
ERROR: code indent should never use tabs
#2304: FILE: tools/virtiofsd/fuse_log.h:29:
+^IFUSE_LOG_EMERG,$
ERROR: code indent should never use tabs
#2305: FILE: tools/virtiofsd/fuse_log.h:30:
+^IFUSE_LOG_ALERT,$
ERROR: code indent should never use tabs
#2306: FILE: tools/virtiofsd/fuse_log.h:31:
+^IFUSE_LOG_CRIT,$
ERROR: code indent should never use tabs
#2307: FILE: tools/virtiofsd/fuse_log.h:32:
+^IFUSE_LOG_ERR,$
ERROR: code indent should never use tabs
#2308: FILE: tools/virtiofsd/fuse_log.h:33:
+^IFUSE_LOG_WARNING,$
ERROR: code indent should never use tabs
#2309: FILE: tools/virtiofsd/fuse_log.h:34:
+^IFUSE_LOG_NOTICE,$
ERROR: code indent should never use tabs
#2310: FILE: tools/virtiofsd/fuse_log.h:35:
+^IFUSE_LOG_INFO,$
ERROR: code indent should never use tabs
#2311: FILE: tools/virtiofsd/fuse_log.h:36:
+^IFUSE_LOG_DEBUG$
ERROR: code indent should never use tabs
#2328: FILE: tools/virtiofsd/fuse_log.h:53:
+^I^I^I^Iconst char *fmt, va_list ap);$
WARNING: architecture specific defines should be avoided
#2353: FILE: tools/virtiofsd/fuse_log.h:78:
+#ifdef __cplusplus
WARNING: Block comments use * on subsequent lines
#2365: FILE: tools/virtiofsd/fuse_lowlevel.h:2:
+/*
+ FUSE: Filesystem in Userspace
WARNING: Block comments use a leading /* on a separate line
#2375: FILE: tools/virtiofsd/fuse_lowlevel.h:12:
+/** @file
WARNING: architecture specific defines should be avoided
#2397: FILE: tools/virtiofsd/fuse_lowlevel.h:34:
+#ifdef __cplusplus
WARNING: Block comments use a leading /* on a separate line
#2401: FILE: tools/virtiofsd/fuse_lowlevel.h:38:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#2402: FILE: tools/virtiofsd/fuse_lowlevel.h:39:
+ * Miscellaneous definitions^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#2403: FILE: tools/virtiofsd/fuse_lowlevel.h:40:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#2423: FILE: tools/virtiofsd/fuse_lowlevel.h:60:
+^I/** Unique inode number$
WARNING: Block comments use a leading /* on a separate line
#2423: FILE: tools/virtiofsd/fuse_lowlevel.h:60:
+ /** Unique inode number
ERROR: code indent should never use tabs
#2424: FILE: tools/virtiofsd/fuse_lowlevel.h:61:
+^I *$
ERROR: code indent should never use tabs
#2425: FILE: tools/virtiofsd/fuse_lowlevel.h:62:
+^I * In lookup, zero means negative entry (from version 2.5)$
ERROR: code indent should never use tabs
#2426: FILE: tools/virtiofsd/fuse_lowlevel.h:63:
+^I * Returning ENOENT also means negative entry, but by setting zero$
ERROR: code indent should never use tabs
#2427: FILE: tools/virtiofsd/fuse_lowlevel.h:64:
+^I * ino the kernel may cache negative entries for entry_timeout$
ERROR: code indent should never use tabs
#2428: FILE: tools/virtiofsd/fuse_lowlevel.h:65:
+^I * seconds.$
ERROR: code indent should never use tabs
#2429: FILE: tools/virtiofsd/fuse_lowlevel.h:66:
+^I */$
ERROR: code indent should never use tabs
#2430: FILE: tools/virtiofsd/fuse_lowlevel.h:67:
+^Ifuse_ino_t ino;$
ERROR: code indent should never use tabs
#2432: FILE: tools/virtiofsd/fuse_lowlevel.h:69:
+^I/** Generation number for this entry.$
WARNING: Block comments use a leading /* on a separate line
#2432: FILE: tools/virtiofsd/fuse_lowlevel.h:69:
+ /** Generation number for this entry.
ERROR: code indent should never use tabs
#2433: FILE: tools/virtiofsd/fuse_lowlevel.h:70:
+^I *$
ERROR: code indent should never use tabs
#2434: FILE: tools/virtiofsd/fuse_lowlevel.h:71:
+^I * If the file system will be exported over NFS, the$
ERROR: code indent should never use tabs
#2435: FILE: tools/virtiofsd/fuse_lowlevel.h:72:
+^I * ino/generation pairs need to be unique over the file$
ERROR: code indent should never use tabs
#2436: FILE: tools/virtiofsd/fuse_lowlevel.h:73:
+^I * system's lifetime (rather than just the mount time). So if$
ERROR: code indent should never use tabs
#2437: FILE: tools/virtiofsd/fuse_lowlevel.h:74:
+^I * the file system reuses an inode after it has been deleted,$
ERROR: code indent should never use tabs
#2438: FILE: tools/virtiofsd/fuse_lowlevel.h:75:
+^I * it must assign a new, previously unused generation number$
ERROR: code indent should never use tabs
#2439: FILE: tools/virtiofsd/fuse_lowlevel.h:76:
+^I * to the inode at the same time.$
ERROR: code indent should never use tabs
#2440: FILE: tools/virtiofsd/fuse_lowlevel.h:77:
+^I *$
ERROR: code indent should never use tabs
#2441: FILE: tools/virtiofsd/fuse_lowlevel.h:78:
+^I */$
ERROR: code indent should never use tabs
#2442: FILE: tools/virtiofsd/fuse_lowlevel.h:79:
+^Iuint64_t generation;$
ERROR: code indent should never use tabs
#2444: FILE: tools/virtiofsd/fuse_lowlevel.h:81:
+^I/** Inode attributes.$
WARNING: Block comments use a leading /* on a separate line
#2444: FILE: tools/virtiofsd/fuse_lowlevel.h:81:
+ /** Inode attributes.
ERROR: code indent should never use tabs
#2445: FILE: tools/virtiofsd/fuse_lowlevel.h:82:
+^I *$
ERROR: code indent should never use tabs
#2446: FILE: tools/virtiofsd/fuse_lowlevel.h:83:
+^I * Even if attr_timeout == 0, attr must be correct. For example,$
ERROR: code indent should never use tabs
#2447: FILE: tools/virtiofsd/fuse_lowlevel.h:84:
+^I * for open(), FUSE uses attr.st_size from lookup() to determine$
ERROR: code indent should never use tabs
#2448: FILE: tools/virtiofsd/fuse_lowlevel.h:85:
+^I * how many bytes to request. If this value is not correct,$
ERROR: code indent should never use tabs
#2449: FILE: tools/virtiofsd/fuse_lowlevel.h:86:
+^I * incorrect data will be returned.$
ERROR: code indent should never use tabs
#2450: FILE: tools/virtiofsd/fuse_lowlevel.h:87:
+^I */$
ERROR: code indent should never use tabs
#2451: FILE: tools/virtiofsd/fuse_lowlevel.h:88:
+^Istruct stat attr;$
ERROR: code indent should never use tabs
#2453: FILE: tools/virtiofsd/fuse_lowlevel.h:90:
+^I/** Validity timeout (in seconds) for inode attributes. If$
WARNING: Block comments use a leading /* on a separate line
#2453: FILE: tools/virtiofsd/fuse_lowlevel.h:90:
+ /** Validity timeout (in seconds) for inode attributes. If
ERROR: code indent should never use tabs
#2454: FILE: tools/virtiofsd/fuse_lowlevel.h:91:
+^I attributes only change as a result of requests that come$
WARNING: Block comments use * on subsequent lines
#2454: FILE: tools/virtiofsd/fuse_lowlevel.h:91:
+ /** Validity timeout (in seconds) for inode attributes. If
+ attributes only change as a result of requests that come
ERROR: code indent should never use tabs
#2455: FILE: tools/virtiofsd/fuse_lowlevel.h:92:
+^I through the kernel, this should be set to a very large$
ERROR: code indent should never use tabs
#2456: FILE: tools/virtiofsd/fuse_lowlevel.h:93:
+^I value. */$
WARNING: Block comments use a trailing */ on a separate line
#2456: FILE: tools/virtiofsd/fuse_lowlevel.h:93:
+ value. */
ERROR: code indent should never use tabs
#2457: FILE: tools/virtiofsd/fuse_lowlevel.h:94:
+^Idouble attr_timeout;$
ERROR: code indent should never use tabs
#2459: FILE: tools/virtiofsd/fuse_lowlevel.h:96:
+^I/** Validity timeout (in seconds) for the name. If directory$
WARNING: Block comments use a leading /* on a separate line
#2459: FILE: tools/virtiofsd/fuse_lowlevel.h:96:
+ /** Validity timeout (in seconds) for the name. If directory
ERROR: code indent should never use tabs
#2460: FILE: tools/virtiofsd/fuse_lowlevel.h:97:
+^I entries are changed/deleted only as a result of requests$
WARNING: Block comments use * on subsequent lines
#2460: FILE: tools/virtiofsd/fuse_lowlevel.h:97:
+ /** Validity timeout (in seconds) for the name. If directory
+ entries are changed/deleted only as a result of requests
ERROR: code indent should never use tabs
#2461: FILE: tools/virtiofsd/fuse_lowlevel.h:98:
+^I that come through the kernel, this should be set to a very$
ERROR: code indent should never use tabs
#2462: FILE: tools/virtiofsd/fuse_lowlevel.h:99:
+^I large value. */$
WARNING: Block comments use a trailing */ on a separate line
#2462: FILE: tools/virtiofsd/fuse_lowlevel.h:99:
+ large value. */
ERROR: code indent should never use tabs
#2463: FILE: tools/virtiofsd/fuse_lowlevel.h:100:
+^Idouble entry_timeout;$
ERROR: code indent should never use tabs
#2475: FILE: tools/virtiofsd/fuse_lowlevel.h:112:
+^I/** User ID of the calling process */$
ERROR: code indent should never use tabs
#2476: FILE: tools/virtiofsd/fuse_lowlevel.h:113:
+^Iuid_t uid;$
ERROR: code indent should never use tabs
#2478: FILE: tools/virtiofsd/fuse_lowlevel.h:115:
+^I/** Group ID of the calling process */$
ERROR: code indent should never use tabs
#2479: FILE: tools/virtiofsd/fuse_lowlevel.h:116:
+^Igid_t gid;$
ERROR: code indent should never use tabs
#2481: FILE: tools/virtiofsd/fuse_lowlevel.h:118:
+^I/** Thread ID of the calling process */$
ERROR: code indent should never use tabs
#2482: FILE: tools/virtiofsd/fuse_lowlevel.h:119:
+^Ipid_t pid;$
ERROR: code indent should never use tabs
#2484: FILE: tools/virtiofsd/fuse_lowlevel.h:121:
+^I/** Umask of the calling process */$
ERROR: code indent should never use tabs
#2485: FILE: tools/virtiofsd/fuse_lowlevel.h:122:
+^Imode_t umask;$
ERROR: code indent should never use tabs
#2489: FILE: tools/virtiofsd/fuse_lowlevel.h:126:
+^Ifuse_ino_t ino;$
ERROR: code indent should never use tabs
#2490: FILE: tools/virtiofsd/fuse_lowlevel.h:127:
+^Iuint64_t nlookup;$
ERROR: code indent should never use tabs
#2494: FILE: tools/virtiofsd/fuse_lowlevel.h:131:
+#define FUSE_SET_ATTR_MODE^I(1 << 0)$
ERROR: code indent should never use tabs
#2495: FILE: tools/virtiofsd/fuse_lowlevel.h:132:
+#define FUSE_SET_ATTR_UID^I(1 << 1)$
ERROR: code indent should never use tabs
#2496: FILE: tools/virtiofsd/fuse_lowlevel.h:133:
+#define FUSE_SET_ATTR_GID^I(1 << 2)$
ERROR: code indent should never use tabs
#2497: FILE: tools/virtiofsd/fuse_lowlevel.h:134:
+#define FUSE_SET_ATTR_SIZE^I(1 << 3)$
ERROR: code indent should never use tabs
#2498: FILE: tools/virtiofsd/fuse_lowlevel.h:135:
+#define FUSE_SET_ATTR_ATIME^I(1 << 4)$
ERROR: code indent should never use tabs
#2499: FILE: tools/virtiofsd/fuse_lowlevel.h:136:
+#define FUSE_SET_ATTR_MTIME^I(1 << 5)$
ERROR: code indent should never use tabs
#2500: FILE: tools/virtiofsd/fuse_lowlevel.h:137:
+#define FUSE_SET_ATTR_ATIME_NOW^I(1 << 7)$
ERROR: code indent should never use tabs
#2501: FILE: tools/virtiofsd/fuse_lowlevel.h:138:
+#define FUSE_SET_ATTR_MTIME_NOW^I(1 << 8)$
ERROR: code indent should never use tabs
#2502: FILE: tools/virtiofsd/fuse_lowlevel.h:139:
+#define FUSE_SET_ATTR_CTIME^I(1 << 10)$
WARNING: Block comments use a leading /* on a separate line
#2504: FILE: tools/virtiofsd/fuse_lowlevel.h:141:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#2505: FILE: tools/virtiofsd/fuse_lowlevel.h:142:
+ * Request methods and replies^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#2506: FILE: tools/virtiofsd/fuse_lowlevel.h:143:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#2536: FILE: tools/virtiofsd/fuse_lowlevel.h:173:
+^I/**$
ERROR: code indent should never use tabs
#2537: FILE: tools/virtiofsd/fuse_lowlevel.h:174:
+^I * Initialize filesystem$
ERROR: code indent should never use tabs
#2538: FILE: tools/virtiofsd/fuse_lowlevel.h:175:
+^I *$
ERROR: code indent should never use tabs
#2539: FILE: tools/virtiofsd/fuse_lowlevel.h:176:
+^I * This function is called when libfuse establishes$
ERROR: code indent should never use tabs
#2540: FILE: tools/virtiofsd/fuse_lowlevel.h:177:
+^I * communication with the FUSE kernel module. The file system$
ERROR: code indent should never use tabs
#2541: FILE: tools/virtiofsd/fuse_lowlevel.h:178:
+^I * should use this module to inspect and/or modify the$
ERROR: code indent should never use tabs
#2542: FILE: tools/virtiofsd/fuse_lowlevel.h:179:
+^I * connection parameters provided in the `conn` structure.$
ERROR: code indent should never use tabs
#2543: FILE: tools/virtiofsd/fuse_lowlevel.h:180:
+^I *$
ERROR: code indent should never use tabs
#2544: FILE: tools/virtiofsd/fuse_lowlevel.h:181:
+^I * Note that some parameters may be overwritten by options$
ERROR: code indent should never use tabs
#2545: FILE: tools/virtiofsd/fuse_lowlevel.h:182:
+^I * passed to fuse_session_new() which take precedence over the$
ERROR: code indent should never use tabs
#2546: FILE: tools/virtiofsd/fuse_lowlevel.h:183:
+^I * values set in this handler.$
ERROR: code indent should never use tabs
#2547: FILE: tools/virtiofsd/fuse_lowlevel.h:184:
+^I *$
ERROR: code indent should never use tabs
#2548: FILE: tools/virtiofsd/fuse_lowlevel.h:185:
+^I * There's no reply to this function$
ERROR: code indent should never use tabs
#2549: FILE: tools/virtiofsd/fuse_lowlevel.h:186:
+^I *$
ERROR: code indent should never use tabs
#2550: FILE: tools/virtiofsd/fuse_lowlevel.h:187:
+^I * @param userdata the user data passed to fuse_session_new()$
ERROR: code indent should never use tabs
#2551: FILE: tools/virtiofsd/fuse_lowlevel.h:188:
+^I */$
ERROR: code indent should never use tabs
#2552: FILE: tools/virtiofsd/fuse_lowlevel.h:189:
+^Ivoid (*init) (void *userdata, struct fuse_conn_info *conn);$
ERROR: code indent should never use tabs
#2554: FILE: tools/virtiofsd/fuse_lowlevel.h:191:
+^I/**$
ERROR: code indent should never use tabs
#2555: FILE: tools/virtiofsd/fuse_lowlevel.h:192:
+^I * Clean up filesystem.$
ERROR: code indent should never use tabs
#2556: FILE: tools/virtiofsd/fuse_lowlevel.h:193:
+^I *$
ERROR: code indent should never use tabs
#2557: FILE: tools/virtiofsd/fuse_lowlevel.h:194:
+^I * Called on filesystem exit. When this method is called, the$
ERROR: code indent should never use tabs
#2558: FILE: tools/virtiofsd/fuse_lowlevel.h:195:
+^I * connection to the kernel may be gone already, so that eg. calls$
ERROR: code indent should never use tabs
#2559: FILE: tools/virtiofsd/fuse_lowlevel.h:196:
+^I * to fuse_lowlevel_notify_* will fail.$
ERROR: code indent should never use tabs
#2560: FILE: tools/virtiofsd/fuse_lowlevel.h:197:
+^I *$
ERROR: code indent should never use tabs
#2561: FILE: tools/virtiofsd/fuse_lowlevel.h:198:
+^I * There's no reply to this function$
ERROR: code indent should never use tabs
#2562: FILE: tools/virtiofsd/fuse_lowlevel.h:199:
+^I *$
ERROR: code indent should never use tabs
#2563: FILE: tools/virtiofsd/fuse_lowlevel.h:200:
+^I * @param userdata the user data passed to fuse_session_new()$
ERROR: code indent should never use tabs
#2564: FILE: tools/virtiofsd/fuse_lowlevel.h:201:
+^I */$
ERROR: code indent should never use tabs
#2565: FILE: tools/virtiofsd/fuse_lowlevel.h:202:
+^Ivoid (*destroy) (void *userdata);$
ERROR: code indent should never use tabs
#2567: FILE: tools/virtiofsd/fuse_lowlevel.h:204:
+^I/**$
ERROR: code indent should never use tabs
#2568: FILE: tools/virtiofsd/fuse_lowlevel.h:205:
+^I * Look up a directory entry by name and get its attributes.$
ERROR: code indent should never use tabs
#2569: FILE: tools/virtiofsd/fuse_lowlevel.h:206:
+^I *$
ERROR: code indent should never use tabs
#2570: FILE: tools/virtiofsd/fuse_lowlevel.h:207:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2571: FILE: tools/virtiofsd/fuse_lowlevel.h:208:
+^I * fuse_reply_entry$
ERROR: code indent should never use tabs
#2572: FILE: tools/virtiofsd/fuse_lowlevel.h:209:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2573: FILE: tools/virtiofsd/fuse_lowlevel.h:210:
+^I *$
ERROR: code indent should never use tabs
#2574: FILE: tools/virtiofsd/fuse_lowlevel.h:211:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2575: FILE: tools/virtiofsd/fuse_lowlevel.h:212:
+^I * @param parent inode number of the parent directory$
ERROR: code indent should never use tabs
#2576: FILE: tools/virtiofsd/fuse_lowlevel.h:213:
+^I * @param name the name to look up$
ERROR: code indent should never use tabs
#2577: FILE: tools/virtiofsd/fuse_lowlevel.h:214:
+^I */$
ERROR: code indent should never use tabs
#2578: FILE: tools/virtiofsd/fuse_lowlevel.h:215:
+^Ivoid (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name);$
ERROR: code indent should never use tabs
#2580: FILE: tools/virtiofsd/fuse_lowlevel.h:217:
+^I/**$
ERROR: code indent should never use tabs
#2581: FILE: tools/virtiofsd/fuse_lowlevel.h:218:
+^I * Forget about an inode$
ERROR: code indent should never use tabs
#2582: FILE: tools/virtiofsd/fuse_lowlevel.h:219:
+^I *$
ERROR: code indent should never use tabs
#2583: FILE: tools/virtiofsd/fuse_lowlevel.h:220:
+^I * This function is called when the kernel removes an inode$
ERROR: code indent should never use tabs
#2584: FILE: tools/virtiofsd/fuse_lowlevel.h:221:
+^I * from its internal caches.$
ERROR: code indent should never use tabs
#2585: FILE: tools/virtiofsd/fuse_lowlevel.h:222:
+^I *$
ERROR: code indent should never use tabs
#2586: FILE: tools/virtiofsd/fuse_lowlevel.h:223:
+^I * The inode's lookup count increases by one for every call to$
ERROR: code indent should never use tabs
#2587: FILE: tools/virtiofsd/fuse_lowlevel.h:224:
+^I * fuse_reply_entry and fuse_reply_create. The nlookup parameter$
ERROR: code indent should never use tabs
#2588: FILE: tools/virtiofsd/fuse_lowlevel.h:225:
+^I * indicates by how much the lookup count should be decreased.$
ERROR: code indent should never use tabs
#2589: FILE: tools/virtiofsd/fuse_lowlevel.h:226:
+^I *$
ERROR: code indent should never use tabs
#2590: FILE: tools/virtiofsd/fuse_lowlevel.h:227:
+^I * Inodes with a non-zero lookup count may receive request from$
ERROR: code indent should never use tabs
#2591: FILE: tools/virtiofsd/fuse_lowlevel.h:228:
+^I * the kernel even after calls to unlink, rmdir or (when$
ERROR: code indent should never use tabs
#2592: FILE: tools/virtiofsd/fuse_lowlevel.h:229:
+^I * overwriting an existing file) rename. Filesystems must handle$
ERROR: code indent should never use tabs
#2593: FILE: tools/virtiofsd/fuse_lowlevel.h:230:
+^I * such requests properly and it is recommended to defer removal$
ERROR: code indent should never use tabs
#2594: FILE: tools/virtiofsd/fuse_lowlevel.h:231:
+^I * of the inode until the lookup count reaches zero. Calls to$
ERROR: code indent should never use tabs
#2595: FILE: tools/virtiofsd/fuse_lowlevel.h:232:
+^I * unlink, rmdir or rename will be followed closely by forget$
ERROR: code indent should never use tabs
#2596: FILE: tools/virtiofsd/fuse_lowlevel.h:233:
+^I * unless the file or directory is open, in which case the$
ERROR: code indent should never use tabs
#2597: FILE: tools/virtiofsd/fuse_lowlevel.h:234:
+^I * kernel issues forget only after the release or releasedir$
ERROR: code indent should never use tabs
#2598: FILE: tools/virtiofsd/fuse_lowlevel.h:235:
+^I * calls.$
ERROR: code indent should never use tabs
#2599: FILE: tools/virtiofsd/fuse_lowlevel.h:236:
+^I *$
ERROR: code indent should never use tabs
#2600: FILE: tools/virtiofsd/fuse_lowlevel.h:237:
+^I * Note that if a file system will be exported over NFS the$
ERROR: code indent should never use tabs
#2601: FILE: tools/virtiofsd/fuse_lowlevel.h:238:
+^I * inodes lifetime must extend even beyond forget. See the$
ERROR: code indent should never use tabs
#2602: FILE: tools/virtiofsd/fuse_lowlevel.h:239:
+^I * generation field in struct fuse_entry_param above.$
ERROR: code indent should never use tabs
#2603: FILE: tools/virtiofsd/fuse_lowlevel.h:240:
+^I *$
ERROR: code indent should never use tabs
#2604: FILE: tools/virtiofsd/fuse_lowlevel.h:241:
+^I * On unmount the lookup count for all inodes implicitly drops$
ERROR: code indent should never use tabs
#2605: FILE: tools/virtiofsd/fuse_lowlevel.h:242:
+^I * to zero. It is not guaranteed that the file system will$
ERROR: code indent should never use tabs
#2606: FILE: tools/virtiofsd/fuse_lowlevel.h:243:
+^I * receive corresponding forget messages for the affected$
ERROR: code indent should never use tabs
#2607: FILE: tools/virtiofsd/fuse_lowlevel.h:244:
+^I * inodes.$
ERROR: code indent should never use tabs
#2608: FILE: tools/virtiofsd/fuse_lowlevel.h:245:
+^I *$
ERROR: code indent should never use tabs
#2609: FILE: tools/virtiofsd/fuse_lowlevel.h:246:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2610: FILE: tools/virtiofsd/fuse_lowlevel.h:247:
+^I * fuse_reply_none$
ERROR: code indent should never use tabs
#2611: FILE: tools/virtiofsd/fuse_lowlevel.h:248:
+^I *$
ERROR: code indent should never use tabs
#2612: FILE: tools/virtiofsd/fuse_lowlevel.h:249:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2613: FILE: tools/virtiofsd/fuse_lowlevel.h:250:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2614: FILE: tools/virtiofsd/fuse_lowlevel.h:251:
+^I * @param nlookup the number of lookups to forget$
ERROR: code indent should never use tabs
#2615: FILE: tools/virtiofsd/fuse_lowlevel.h:252:
+^I */$
ERROR: code indent should never use tabs
#2616: FILE: tools/virtiofsd/fuse_lowlevel.h:253:
+^Ivoid (*forget) (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup);$
ERROR: code indent should never use tabs
#2618: FILE: tools/virtiofsd/fuse_lowlevel.h:255:
+^I/**$
ERROR: code indent should never use tabs
#2619: FILE: tools/virtiofsd/fuse_lowlevel.h:256:
+^I * Get file attributes.$
ERROR: code indent should never use tabs
#2620: FILE: tools/virtiofsd/fuse_lowlevel.h:257:
+^I *$
ERROR: code indent should never use tabs
#2621: FILE: tools/virtiofsd/fuse_lowlevel.h:258:
+^I * If writeback caching is enabled, the kernel may have a$
ERROR: code indent should never use tabs
#2622: FILE: tools/virtiofsd/fuse_lowlevel.h:259:
+^I * better idea of a file's length than the FUSE file system$
ERROR: code indent should never use tabs
#2623: FILE: tools/virtiofsd/fuse_lowlevel.h:260:
+^I * (eg if there has been a write that extended the file size,$
ERROR: code indent should never use tabs
#2624: FILE: tools/virtiofsd/fuse_lowlevel.h:261:
+^I * but that has not yet been passed to the filesystem.n$
ERROR: code indent should never use tabs
#2625: FILE: tools/virtiofsd/fuse_lowlevel.h:262:
+^I *$
ERROR: code indent should never use tabs
#2626: FILE: tools/virtiofsd/fuse_lowlevel.h:263:
+^I * In this case, the st_size value provided by the file system$
ERROR: code indent should never use tabs
#2627: FILE: tools/virtiofsd/fuse_lowlevel.h:264:
+^I * will be ignored.$
ERROR: code indent should never use tabs
#2628: FILE: tools/virtiofsd/fuse_lowlevel.h:265:
+^I *$
ERROR: code indent should never use tabs
#2629: FILE: tools/virtiofsd/fuse_lowlevel.h:266:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2630: FILE: tools/virtiofsd/fuse_lowlevel.h:267:
+^I * fuse_reply_attr$
ERROR: code indent should never use tabs
#2631: FILE: tools/virtiofsd/fuse_lowlevel.h:268:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2632: FILE: tools/virtiofsd/fuse_lowlevel.h:269:
+^I *$
ERROR: code indent should never use tabs
#2633: FILE: tools/virtiofsd/fuse_lowlevel.h:270:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2634: FILE: tools/virtiofsd/fuse_lowlevel.h:271:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2635: FILE: tools/virtiofsd/fuse_lowlevel.h:272:
+^I * @param fi for future use, currently always NULL$
ERROR: code indent should never use tabs
#2636: FILE: tools/virtiofsd/fuse_lowlevel.h:273:
+^I */$
ERROR: code indent should never use tabs
#2637: FILE: tools/virtiofsd/fuse_lowlevel.h:274:
+^Ivoid (*getattr) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#2638: FILE: tools/virtiofsd/fuse_lowlevel.h:275:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#2640: FILE: tools/virtiofsd/fuse_lowlevel.h:277:
+^I/**$
ERROR: code indent should never use tabs
#2641: FILE: tools/virtiofsd/fuse_lowlevel.h:278:
+^I * Set file attributes$
ERROR: code indent should never use tabs
#2642: FILE: tools/virtiofsd/fuse_lowlevel.h:279:
+^I *$
ERROR: code indent should never use tabs
#2643: FILE: tools/virtiofsd/fuse_lowlevel.h:280:
+^I * In the 'attr' argument only members indicated by the 'to_set'$
ERROR: code indent should never use tabs
#2644: FILE: tools/virtiofsd/fuse_lowlevel.h:281:
+^I * bitmask contain valid values. Other members contain undefined$
ERROR: code indent should never use tabs
#2645: FILE: tools/virtiofsd/fuse_lowlevel.h:282:
+^I * values.$
ERROR: code indent should never use tabs
#2646: FILE: tools/virtiofsd/fuse_lowlevel.h:283:
+^I *$
ERROR: code indent should never use tabs
#2647: FILE: tools/virtiofsd/fuse_lowlevel.h:284:
+^I * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is$
ERROR: code indent should never use tabs
#2648: FILE: tools/virtiofsd/fuse_lowlevel.h:285:
+^I * expected to reset the setuid and setgid bits if the file$
ERROR: code indent should never use tabs
#2649: FILE: tools/virtiofsd/fuse_lowlevel.h:286:
+^I * size or owner is being changed.$
ERROR: code indent should never use tabs
#2650: FILE: tools/virtiofsd/fuse_lowlevel.h:287:
+^I *$
ERROR: code indent should never use tabs
#2651: FILE: tools/virtiofsd/fuse_lowlevel.h:288:
+^I * If the setattr was invoked from the ftruncate() system call$
ERROR: code indent should never use tabs
#2652: FILE: tools/virtiofsd/fuse_lowlevel.h:289:
+^I * under Linux kernel versions 2.6.15 or later, the fi->fh will$
ERROR: code indent should never use tabs
#2653: FILE: tools/virtiofsd/fuse_lowlevel.h:290:
+^I * contain the value set by the open method or will be undefined$
ERROR: code indent should never use tabs
#2654: FILE: tools/virtiofsd/fuse_lowlevel.h:291:
+^I * if the open method didn't set any value. Otherwise (not$
ERROR: code indent should never use tabs
#2655: FILE: tools/virtiofsd/fuse_lowlevel.h:292:
+^I * ftruncate call, or kernel version earlier than 2.6.15) the fi$
ERROR: code indent should never use tabs
#2656: FILE: tools/virtiofsd/fuse_lowlevel.h:293:
+^I * parameter will be NULL.$
ERROR: code indent should never use tabs
#2657: FILE: tools/virtiofsd/fuse_lowlevel.h:294:
+^I *$
ERROR: code indent should never use tabs
#2658: FILE: tools/virtiofsd/fuse_lowlevel.h:295:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2659: FILE: tools/virtiofsd/fuse_lowlevel.h:296:
+^I * fuse_reply_attr$
ERROR: code indent should never use tabs
#2660: FILE: tools/virtiofsd/fuse_lowlevel.h:297:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2661: FILE: tools/virtiofsd/fuse_lowlevel.h:298:
+^I *$
ERROR: code indent should never use tabs
#2662: FILE: tools/virtiofsd/fuse_lowlevel.h:299:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2663: FILE: tools/virtiofsd/fuse_lowlevel.h:300:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2664: FILE: tools/virtiofsd/fuse_lowlevel.h:301:
+^I * @param attr the attributes$
ERROR: code indent should never use tabs
#2665: FILE: tools/virtiofsd/fuse_lowlevel.h:302:
+^I * @param to_set bit mask of attributes which should be set$
ERROR: code indent should never use tabs
#2666: FILE: tools/virtiofsd/fuse_lowlevel.h:303:
+^I * @param fi file information, or NULL$
ERROR: code indent should never use tabs
#2667: FILE: tools/virtiofsd/fuse_lowlevel.h:304:
+^I */$
ERROR: code indent should never use tabs
#2668: FILE: tools/virtiofsd/fuse_lowlevel.h:305:
+^Ivoid (*setattr) (fuse_req_t req, fuse_ino_t ino, struct stat *attr,$
ERROR: code indent should never use tabs
#2669: FILE: tools/virtiofsd/fuse_lowlevel.h:306:
+^I^I^I int to_set, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#2671: FILE: tools/virtiofsd/fuse_lowlevel.h:308:
+^I/**$
ERROR: code indent should never use tabs
#2672: FILE: tools/virtiofsd/fuse_lowlevel.h:309:
+^I * Read symbolic link$
ERROR: code indent should never use tabs
#2673: FILE: tools/virtiofsd/fuse_lowlevel.h:310:
+^I *$
ERROR: code indent should never use tabs
#2674: FILE: tools/virtiofsd/fuse_lowlevel.h:311:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2675: FILE: tools/virtiofsd/fuse_lowlevel.h:312:
+^I * fuse_reply_readlink$
ERROR: code indent should never use tabs
#2676: FILE: tools/virtiofsd/fuse_lowlevel.h:313:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2677: FILE: tools/virtiofsd/fuse_lowlevel.h:314:
+^I *$
ERROR: code indent should never use tabs
#2678: FILE: tools/virtiofsd/fuse_lowlevel.h:315:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2679: FILE: tools/virtiofsd/fuse_lowlevel.h:316:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2680: FILE: tools/virtiofsd/fuse_lowlevel.h:317:
+^I */$
ERROR: code indent should never use tabs
#2681: FILE: tools/virtiofsd/fuse_lowlevel.h:318:
+^Ivoid (*readlink) (fuse_req_t req, fuse_ino_t ino);$
ERROR: code indent should never use tabs
#2683: FILE: tools/virtiofsd/fuse_lowlevel.h:320:
+^I/**$
ERROR: code indent should never use tabs
#2684: FILE: tools/virtiofsd/fuse_lowlevel.h:321:
+^I * Create file node$
ERROR: code indent should never use tabs
#2685: FILE: tools/virtiofsd/fuse_lowlevel.h:322:
+^I *$
ERROR: code indent should never use tabs
#2686: FILE: tools/virtiofsd/fuse_lowlevel.h:323:
+^I * Create a regular file, character device, block device, fifo or$
ERROR: code indent should never use tabs
#2687: FILE: tools/virtiofsd/fuse_lowlevel.h:324:
+^I * socket node.$
ERROR: code indent should never use tabs
#2688: FILE: tools/virtiofsd/fuse_lowlevel.h:325:
+^I *$
ERROR: code indent should never use tabs
#2689: FILE: tools/virtiofsd/fuse_lowlevel.h:326:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2690: FILE: tools/virtiofsd/fuse_lowlevel.h:327:
+^I * fuse_reply_entry$
ERROR: code indent should never use tabs
#2691: FILE: tools/virtiofsd/fuse_lowlevel.h:328:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2692: FILE: tools/virtiofsd/fuse_lowlevel.h:329:
+^I *$
ERROR: code indent should never use tabs
#2693: FILE: tools/virtiofsd/fuse_lowlevel.h:330:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2694: FILE: tools/virtiofsd/fuse_lowlevel.h:331:
+^I * @param parent inode number of the parent directory$
ERROR: code indent should never use tabs
#2695: FILE: tools/virtiofsd/fuse_lowlevel.h:332:
+^I * @param name to create$
ERROR: code indent should never use tabs
#2696: FILE: tools/virtiofsd/fuse_lowlevel.h:333:
+^I * @param mode file type and mode with which to create the new file$
WARNING: line over 80 characters
#2697: FILE: tools/virtiofsd/fuse_lowlevel.h:334:
+ * @param rdev the device number (only valid if created file is a device)
ERROR: code indent should never use tabs
#2697: FILE: tools/virtiofsd/fuse_lowlevel.h:334:
+^I * @param rdev the device number (only valid if created file is a device)$
ERROR: code indent should never use tabs
#2698: FILE: tools/virtiofsd/fuse_lowlevel.h:335:
+^I */$
ERROR: code indent should never use tabs
#2699: FILE: tools/virtiofsd/fuse_lowlevel.h:336:
+^Ivoid (*mknod) (fuse_req_t req, fuse_ino_t parent, const char *name,$
ERROR: code indent should never use tabs
#2700: FILE: tools/virtiofsd/fuse_lowlevel.h:337:
+^I^I mode_t mode, dev_t rdev);$
ERROR: code indent should never use tabs
#2702: FILE: tools/virtiofsd/fuse_lowlevel.h:339:
+^I/**$
ERROR: code indent should never use tabs
#2703: FILE: tools/virtiofsd/fuse_lowlevel.h:340:
+^I * Create a directory$
ERROR: code indent should never use tabs
#2704: FILE: tools/virtiofsd/fuse_lowlevel.h:341:
+^I *$
ERROR: code indent should never use tabs
#2705: FILE: tools/virtiofsd/fuse_lowlevel.h:342:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2706: FILE: tools/virtiofsd/fuse_lowlevel.h:343:
+^I * fuse_reply_entry$
ERROR: code indent should never use tabs
#2707: FILE: tools/virtiofsd/fuse_lowlevel.h:344:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2708: FILE: tools/virtiofsd/fuse_lowlevel.h:345:
+^I *$
ERROR: code indent should never use tabs
#2709: FILE: tools/virtiofsd/fuse_lowlevel.h:346:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2710: FILE: tools/virtiofsd/fuse_lowlevel.h:347:
+^I * @param parent inode number of the parent directory$
ERROR: code indent should never use tabs
#2711: FILE: tools/virtiofsd/fuse_lowlevel.h:348:
+^I * @param name to create$
ERROR: code indent should never use tabs
#2712: FILE: tools/virtiofsd/fuse_lowlevel.h:349:
+^I * @param mode with which to create the new file$
ERROR: code indent should never use tabs
#2713: FILE: tools/virtiofsd/fuse_lowlevel.h:350:
+^I */$
ERROR: code indent should never use tabs
#2714: FILE: tools/virtiofsd/fuse_lowlevel.h:351:
+^Ivoid (*mkdir) (fuse_req_t req, fuse_ino_t parent, const char *name,$
ERROR: code indent should never use tabs
#2715: FILE: tools/virtiofsd/fuse_lowlevel.h:352:
+^I^I mode_t mode);$
ERROR: code indent should never use tabs
#2717: FILE: tools/virtiofsd/fuse_lowlevel.h:354:
+^I/**$
ERROR: code indent should never use tabs
#2718: FILE: tools/virtiofsd/fuse_lowlevel.h:355:
+^I * Remove a file$
ERROR: code indent should never use tabs
#2719: FILE: tools/virtiofsd/fuse_lowlevel.h:356:
+^I *$
ERROR: code indent should never use tabs
#2720: FILE: tools/virtiofsd/fuse_lowlevel.h:357:
+^I * If the file's inode's lookup count is non-zero, the file$
ERROR: code indent should never use tabs
#2721: FILE: tools/virtiofsd/fuse_lowlevel.h:358:
+^I * system is expected to postpone any removal of the inode$
ERROR: code indent should never use tabs
#2722: FILE: tools/virtiofsd/fuse_lowlevel.h:359:
+^I * until the lookup count reaches zero (see description of the$
ERROR: code indent should never use tabs
#2723: FILE: tools/virtiofsd/fuse_lowlevel.h:360:
+^I * forget function).$
ERROR: code indent should never use tabs
#2724: FILE: tools/virtiofsd/fuse_lowlevel.h:361:
+^I *$
ERROR: code indent should never use tabs
#2725: FILE: tools/virtiofsd/fuse_lowlevel.h:362:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2726: FILE: tools/virtiofsd/fuse_lowlevel.h:363:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2727: FILE: tools/virtiofsd/fuse_lowlevel.h:364:
+^I *$
ERROR: code indent should never use tabs
#2728: FILE: tools/virtiofsd/fuse_lowlevel.h:365:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2729: FILE: tools/virtiofsd/fuse_lowlevel.h:366:
+^I * @param parent inode number of the parent directory$
ERROR: code indent should never use tabs
#2730: FILE: tools/virtiofsd/fuse_lowlevel.h:367:
+^I * @param name to remove$
ERROR: code indent should never use tabs
#2731: FILE: tools/virtiofsd/fuse_lowlevel.h:368:
+^I */$
ERROR: code indent should never use tabs
#2732: FILE: tools/virtiofsd/fuse_lowlevel.h:369:
+^Ivoid (*unlink) (fuse_req_t req, fuse_ino_t parent, const char *name);$
ERROR: code indent should never use tabs
#2734: FILE: tools/virtiofsd/fuse_lowlevel.h:371:
+^I/**$
ERROR: code indent should never use tabs
#2735: FILE: tools/virtiofsd/fuse_lowlevel.h:372:
+^I * Remove a directory$
ERROR: code indent should never use tabs
#2736: FILE: tools/virtiofsd/fuse_lowlevel.h:373:
+^I *$
ERROR: code indent should never use tabs
#2737: FILE: tools/virtiofsd/fuse_lowlevel.h:374:
+^I * If the directory's inode's lookup count is non-zero, the$
ERROR: code indent should never use tabs
#2738: FILE: tools/virtiofsd/fuse_lowlevel.h:375:
+^I * file system is expected to postpone any removal of the$
ERROR: code indent should never use tabs
#2739: FILE: tools/virtiofsd/fuse_lowlevel.h:376:
+^I * inode until the lookup count reaches zero (see description$
ERROR: code indent should never use tabs
#2740: FILE: tools/virtiofsd/fuse_lowlevel.h:377:
+^I * of the forget function).$
ERROR: code indent should never use tabs
#2741: FILE: tools/virtiofsd/fuse_lowlevel.h:378:
+^I *$
ERROR: code indent should never use tabs
#2742: FILE: tools/virtiofsd/fuse_lowlevel.h:379:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2743: FILE: tools/virtiofsd/fuse_lowlevel.h:380:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2744: FILE: tools/virtiofsd/fuse_lowlevel.h:381:
+^I *$
ERROR: code indent should never use tabs
#2745: FILE: tools/virtiofsd/fuse_lowlevel.h:382:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2746: FILE: tools/virtiofsd/fuse_lowlevel.h:383:
+^I * @param parent inode number of the parent directory$
ERROR: code indent should never use tabs
#2747: FILE: tools/virtiofsd/fuse_lowlevel.h:384:
+^I * @param name to remove$
ERROR: code indent should never use tabs
#2748: FILE: tools/virtiofsd/fuse_lowlevel.h:385:
+^I */$
ERROR: code indent should never use tabs
#2749: FILE: tools/virtiofsd/fuse_lowlevel.h:386:
+^Ivoid (*rmdir) (fuse_req_t req, fuse_ino_t parent, const char *name);$
ERROR: code indent should never use tabs
#2751: FILE: tools/virtiofsd/fuse_lowlevel.h:388:
+^I/**$
ERROR: code indent should never use tabs
#2752: FILE: tools/virtiofsd/fuse_lowlevel.h:389:
+^I * Create a symbolic link$
ERROR: code indent should never use tabs
#2753: FILE: tools/virtiofsd/fuse_lowlevel.h:390:
+^I *$
ERROR: code indent should never use tabs
#2754: FILE: tools/virtiofsd/fuse_lowlevel.h:391:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2755: FILE: tools/virtiofsd/fuse_lowlevel.h:392:
+^I * fuse_reply_entry$
ERROR: code indent should never use tabs
#2756: FILE: tools/virtiofsd/fuse_lowlevel.h:393:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2757: FILE: tools/virtiofsd/fuse_lowlevel.h:394:
+^I *$
ERROR: code indent should never use tabs
#2758: FILE: tools/virtiofsd/fuse_lowlevel.h:395:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2759: FILE: tools/virtiofsd/fuse_lowlevel.h:396:
+^I * @param link the contents of the symbolic link$
ERROR: code indent should never use tabs
#2760: FILE: tools/virtiofsd/fuse_lowlevel.h:397:
+^I * @param parent inode number of the parent directory$
ERROR: code indent should never use tabs
#2761: FILE: tools/virtiofsd/fuse_lowlevel.h:398:
+^I * @param name to create$
ERROR: code indent should never use tabs
#2762: FILE: tools/virtiofsd/fuse_lowlevel.h:399:
+^I */$
ERROR: code indent should never use tabs
#2763: FILE: tools/virtiofsd/fuse_lowlevel.h:400:
+^Ivoid (*symlink) (fuse_req_t req, const char *link, fuse_ino_t parent,$
ERROR: code indent should never use tabs
#2764: FILE: tools/virtiofsd/fuse_lowlevel.h:401:
+^I^I^I const char *name);$
ERROR: code indent should never use tabs
#2766: FILE: tools/virtiofsd/fuse_lowlevel.h:403:
+^I/** Rename a file$
WARNING: Block comments use a leading /* on a separate line
#2766: FILE: tools/virtiofsd/fuse_lowlevel.h:403:
+ /** Rename a file
ERROR: code indent should never use tabs
#2767: FILE: tools/virtiofsd/fuse_lowlevel.h:404:
+^I *$
ERROR: code indent should never use tabs
#2768: FILE: tools/virtiofsd/fuse_lowlevel.h:405:
+^I * If the target exists it should be atomically replaced. If$
ERROR: code indent should never use tabs
#2769: FILE: tools/virtiofsd/fuse_lowlevel.h:406:
+^I * the target's inode's lookup count is non-zero, the file$
ERROR: code indent should never use tabs
#2770: FILE: tools/virtiofsd/fuse_lowlevel.h:407:
+^I * system is expected to postpone any removal of the inode$
ERROR: code indent should never use tabs
#2771: FILE: tools/virtiofsd/fuse_lowlevel.h:408:
+^I * until the lookup count reaches zero (see description of the$
ERROR: code indent should never use tabs
#2772: FILE: tools/virtiofsd/fuse_lowlevel.h:409:
+^I * forget function).$
ERROR: code indent should never use tabs
#2773: FILE: tools/virtiofsd/fuse_lowlevel.h:410:
+^I *$
ERROR: code indent should never use tabs
#2774: FILE: tools/virtiofsd/fuse_lowlevel.h:411:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#2775: FILE: tools/virtiofsd/fuse_lowlevel.h:412:
+^I * treated as a permanent failure with error code EINVAL, i.e. all$
ERROR: code indent should never use tabs
#2776: FILE: tools/virtiofsd/fuse_lowlevel.h:413:
+^I * future bmap requests will fail with EINVAL without being$
ERROR: code indent should never use tabs
#2777: FILE: tools/virtiofsd/fuse_lowlevel.h:414:
+^I * send to the filesystem process.$
ERROR: code indent should never use tabs
#2778: FILE: tools/virtiofsd/fuse_lowlevel.h:415:
+^I *$
ERROR: code indent should never use tabs
#2779: FILE: tools/virtiofsd/fuse_lowlevel.h:416:
+^I * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If$
ERROR: code indent should never use tabs
#2780: FILE: tools/virtiofsd/fuse_lowlevel.h:417:
+^I * RENAME_NOREPLACE is specified, the filesystem must not$
ERROR: code indent should never use tabs
#2781: FILE: tools/virtiofsd/fuse_lowlevel.h:418:
+^I * overwrite *newname* if it exists and return an error$
ERROR: code indent should never use tabs
#2782: FILE: tools/virtiofsd/fuse_lowlevel.h:419:
+^I * instead. If `RENAME_EXCHANGE` is specified, the filesystem$
ERROR: code indent should never use tabs
#2783: FILE: tools/virtiofsd/fuse_lowlevel.h:420:
+^I * must atomically exchange the two files, i.e. both must$
ERROR: code indent should never use tabs
#2784: FILE: tools/virtiofsd/fuse_lowlevel.h:421:
+^I * exist and neither may be deleted.$
ERROR: code indent should never use tabs
#2785: FILE: tools/virtiofsd/fuse_lowlevel.h:422:
+^I *$
ERROR: code indent should never use tabs
#2786: FILE: tools/virtiofsd/fuse_lowlevel.h:423:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2787: FILE: tools/virtiofsd/fuse_lowlevel.h:424:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2788: FILE: tools/virtiofsd/fuse_lowlevel.h:425:
+^I *$
ERROR: code indent should never use tabs
#2789: FILE: tools/virtiofsd/fuse_lowlevel.h:426:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2790: FILE: tools/virtiofsd/fuse_lowlevel.h:427:
+^I * @param parent inode number of the old parent directory$
ERROR: code indent should never use tabs
#2791: FILE: tools/virtiofsd/fuse_lowlevel.h:428:
+^I * @param name old name$
ERROR: code indent should never use tabs
#2792: FILE: tools/virtiofsd/fuse_lowlevel.h:429:
+^I * @param newparent inode number of the new parent directory$
ERROR: code indent should never use tabs
#2793: FILE: tools/virtiofsd/fuse_lowlevel.h:430:
+^I * @param newname new name$
ERROR: code indent should never use tabs
#2794: FILE: tools/virtiofsd/fuse_lowlevel.h:431:
+^I */$
ERROR: code indent should never use tabs
#2795: FILE: tools/virtiofsd/fuse_lowlevel.h:432:
+^Ivoid (*rename) (fuse_req_t req, fuse_ino_t parent, const char *name,$
ERROR: code indent should never use tabs
#2796: FILE: tools/virtiofsd/fuse_lowlevel.h:433:
+^I^I^Ifuse_ino_t newparent, const char *newname,$
ERROR: code indent should never use tabs
#2797: FILE: tools/virtiofsd/fuse_lowlevel.h:434:
+^I^I^Iunsigned int flags);$
ERROR: code indent should never use tabs
#2799: FILE: tools/virtiofsd/fuse_lowlevel.h:436:
+^I/**$
ERROR: code indent should never use tabs
#2800: FILE: tools/virtiofsd/fuse_lowlevel.h:437:
+^I * Create a hard link$
ERROR: code indent should never use tabs
#2801: FILE: tools/virtiofsd/fuse_lowlevel.h:438:
+^I *$
ERROR: code indent should never use tabs
#2802: FILE: tools/virtiofsd/fuse_lowlevel.h:439:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2803: FILE: tools/virtiofsd/fuse_lowlevel.h:440:
+^I * fuse_reply_entry$
ERROR: code indent should never use tabs
#2804: FILE: tools/virtiofsd/fuse_lowlevel.h:441:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2805: FILE: tools/virtiofsd/fuse_lowlevel.h:442:
+^I *$
ERROR: code indent should never use tabs
#2806: FILE: tools/virtiofsd/fuse_lowlevel.h:443:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2807: FILE: tools/virtiofsd/fuse_lowlevel.h:444:
+^I * @param ino the old inode number$
ERROR: code indent should never use tabs
#2808: FILE: tools/virtiofsd/fuse_lowlevel.h:445:
+^I * @param newparent inode number of the new parent directory$
ERROR: code indent should never use tabs
#2809: FILE: tools/virtiofsd/fuse_lowlevel.h:446:
+^I * @param newname new name to create$
ERROR: code indent should never use tabs
#2810: FILE: tools/virtiofsd/fuse_lowlevel.h:447:
+^I */$
ERROR: code indent should never use tabs
#2811: FILE: tools/virtiofsd/fuse_lowlevel.h:448:
+^Ivoid (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,$
ERROR: code indent should never use tabs
#2812: FILE: tools/virtiofsd/fuse_lowlevel.h:449:
+^I^I const char *newname);$
ERROR: code indent should never use tabs
#2814: FILE: tools/virtiofsd/fuse_lowlevel.h:451:
+^I/**$
ERROR: code indent should never use tabs
#2815: FILE: tools/virtiofsd/fuse_lowlevel.h:452:
+^I * Open a file$
ERROR: code indent should never use tabs
#2816: FILE: tools/virtiofsd/fuse_lowlevel.h:453:
+^I *$
ERROR: code indent should never use tabs
#2817: FILE: tools/virtiofsd/fuse_lowlevel.h:454:
+^I * Open flags are available in fi->flags. The following rules$
ERROR: code indent should never use tabs
#2818: FILE: tools/virtiofsd/fuse_lowlevel.h:455:
+^I * apply.$
ERROR: code indent should never use tabs
#2819: FILE: tools/virtiofsd/fuse_lowlevel.h:456:
+^I *$
ERROR: code indent should never use tabs
#2820: FILE: tools/virtiofsd/fuse_lowlevel.h:457:
+^I * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be$
ERROR: code indent should never use tabs
#2821: FILE: tools/virtiofsd/fuse_lowlevel.h:458:
+^I * filtered out / handled by the kernel.$
ERROR: code indent should never use tabs
#2822: FILE: tools/virtiofsd/fuse_lowlevel.h:459:
+^I *$
ERROR: code indent should never use tabs
#2823: FILE: tools/virtiofsd/fuse_lowlevel.h:460:
+^I * - Access modes (O_RDONLY, O_WRONLY, O_RDWR) should be used$
ERROR: code indent should never use tabs
#2824: FILE: tools/virtiofsd/fuse_lowlevel.h:461:
+^I * by the filesystem to check if the operation is$
ERROR: code indent should never use tabs
#2825: FILE: tools/virtiofsd/fuse_lowlevel.h:462:
+^I * permitted. If the ``-o default_permissions`` mount$
ERROR: code indent should never use tabs
#2826: FILE: tools/virtiofsd/fuse_lowlevel.h:463:
+^I * option is given, this check is already done by the$
ERROR: code indent should never use tabs
#2827: FILE: tools/virtiofsd/fuse_lowlevel.h:464:
+^I * kernel before calling open() and may thus be omitted by$
ERROR: code indent should never use tabs
#2828: FILE: tools/virtiofsd/fuse_lowlevel.h:465:
+^I * the filesystem.$
ERROR: code indent should never use tabs
#2829: FILE: tools/virtiofsd/fuse_lowlevel.h:466:
+^I *$
ERROR: code indent should never use tabs
#2830: FILE: tools/virtiofsd/fuse_lowlevel.h:467:
+^I * - When writeback caching is enabled, the kernel may send$
ERROR: code indent should never use tabs
#2831: FILE: tools/virtiofsd/fuse_lowlevel.h:468:
+^I * read requests even for files opened with O_WRONLY. The$
ERROR: code indent should never use tabs
#2832: FILE: tools/virtiofsd/fuse_lowlevel.h:469:
+^I * filesystem should be prepared to handle this.$
ERROR: code indent should never use tabs
#2833: FILE: tools/virtiofsd/fuse_lowlevel.h:470:
+^I *$
ERROR: code indent should never use tabs
#2834: FILE: tools/virtiofsd/fuse_lowlevel.h:471:
+^I * - When writeback caching is disabled, the filesystem is$
ERROR: code indent should never use tabs
#2835: FILE: tools/virtiofsd/fuse_lowlevel.h:472:
+^I * expected to properly handle the O_APPEND flag and ensure$
ERROR: code indent should never use tabs
#2836: FILE: tools/virtiofsd/fuse_lowlevel.h:473:
+^I * that each write is appending to the end of the file.$
ERROR: trailing whitespace
#2837: FILE: tools/virtiofsd/fuse_lowlevel.h:474:
+^I * $
ERROR: code indent should never use tabs
#2837: FILE: tools/virtiofsd/fuse_lowlevel.h:474:
+^I * $
ERROR: code indent should never use tabs
#2839: FILE: tools/virtiofsd/fuse_lowlevel.h:476:
+^I * handle O_APPEND. However, unless all changes to the file$
ERROR: code indent should never use tabs
#2840: FILE: tools/virtiofsd/fuse_lowlevel.h:477:
+^I * come through the kernel this will not work reliably. The$
ERROR: code indent should never use tabs
#2841: FILE: tools/virtiofsd/fuse_lowlevel.h:478:
+^I * filesystem should thus either ignore the O_APPEND flag$
ERROR: code indent should never use tabs
#2842: FILE: tools/virtiofsd/fuse_lowlevel.h:479:
+^I * (and let the kernel handle it), or return an error$
ERROR: code indent should never use tabs
#2843: FILE: tools/virtiofsd/fuse_lowlevel.h:480:
+^I * (indicating that reliably O_APPEND is not available).$
ERROR: code indent should never use tabs
#2844: FILE: tools/virtiofsd/fuse_lowlevel.h:481:
+^I *$
ERROR: code indent should never use tabs
#2845: FILE: tools/virtiofsd/fuse_lowlevel.h:482:
+^I * Filesystem may store an arbitrary file handle (pointer,$
ERROR: code indent should never use tabs
#2846: FILE: tools/virtiofsd/fuse_lowlevel.h:483:
+^I * index, etc) in fi->fh, and use this in other all other file$
ERROR: code indent should never use tabs
#2847: FILE: tools/virtiofsd/fuse_lowlevel.h:484:
+^I * operations (read, write, flush, release, fsync).$
ERROR: code indent should never use tabs
#2848: FILE: tools/virtiofsd/fuse_lowlevel.h:485:
+^I *$
ERROR: code indent should never use tabs
#2849: FILE: tools/virtiofsd/fuse_lowlevel.h:486:
+^I * Filesystem may also implement stateless file I/O and not store$
ERROR: code indent should never use tabs
#2850: FILE: tools/virtiofsd/fuse_lowlevel.h:487:
+^I * anything in fi->fh.$
ERROR: code indent should never use tabs
#2851: FILE: tools/virtiofsd/fuse_lowlevel.h:488:
+^I *$
ERROR: code indent should never use tabs
#2852: FILE: tools/virtiofsd/fuse_lowlevel.h:489:
+^I * There are also some flags (direct_io, keep_cache) which the$
ERROR: code indent should never use tabs
#2853: FILE: tools/virtiofsd/fuse_lowlevel.h:490:
+^I * filesystem may set in fi, to change the way the file is opened.$
ERROR: code indent should never use tabs
#2854: FILE: tools/virtiofsd/fuse_lowlevel.h:491:
+^I * See fuse_file_info structure in <fuse_common.h> for more details.$
ERROR: code indent should never use tabs
#2855: FILE: tools/virtiofsd/fuse_lowlevel.h:492:
+^I *$
ERROR: code indent should never use tabs
#2856: FILE: tools/virtiofsd/fuse_lowlevel.h:493:
+^I * If this request is answered with an error code of ENOSYS$
ERROR: code indent should never use tabs
#2857: FILE: tools/virtiofsd/fuse_lowlevel.h:494:
+^I * and FUSE_CAP_NO_OPEN_SUPPORT is set in$
ERROR: code indent should never use tabs
#2858: FILE: tools/virtiofsd/fuse_lowlevel.h:495:
+^I * `fuse_conn_info.capable`, this is treated as success and$
ERROR: code indent should never use tabs
#2859: FILE: tools/virtiofsd/fuse_lowlevel.h:496:
+^I * future calls to open and release will also succeed without being$
ERROR: code indent should never use tabs
#2860: FILE: tools/virtiofsd/fuse_lowlevel.h:497:
+^I * sent to the filesystem process.$
ERROR: code indent should never use tabs
#2861: FILE: tools/virtiofsd/fuse_lowlevel.h:498:
+^I *$
ERROR: code indent should never use tabs
#2862: FILE: tools/virtiofsd/fuse_lowlevel.h:499:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2863: FILE: tools/virtiofsd/fuse_lowlevel.h:500:
+^I * fuse_reply_open$
ERROR: code indent should never use tabs
#2864: FILE: tools/virtiofsd/fuse_lowlevel.h:501:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2865: FILE: tools/virtiofsd/fuse_lowlevel.h:502:
+^I *$
ERROR: code indent should never use tabs
#2866: FILE: tools/virtiofsd/fuse_lowlevel.h:503:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2867: FILE: tools/virtiofsd/fuse_lowlevel.h:504:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2868: FILE: tools/virtiofsd/fuse_lowlevel.h:505:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#2869: FILE: tools/virtiofsd/fuse_lowlevel.h:506:
+^I */$
ERROR: code indent should never use tabs
#2870: FILE: tools/virtiofsd/fuse_lowlevel.h:507:
+^Ivoid (*open) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#2871: FILE: tools/virtiofsd/fuse_lowlevel.h:508:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#2873: FILE: tools/virtiofsd/fuse_lowlevel.h:510:
+^I/**$
ERROR: code indent should never use tabs
#2874: FILE: tools/virtiofsd/fuse_lowlevel.h:511:
+^I * Read data$
ERROR: code indent should never use tabs
#2875: FILE: tools/virtiofsd/fuse_lowlevel.h:512:
+^I *$
ERROR: code indent should never use tabs
#2876: FILE: tools/virtiofsd/fuse_lowlevel.h:513:
+^I * Read should send exactly the number of bytes requested except$
ERROR: code indent should never use tabs
#2877: FILE: tools/virtiofsd/fuse_lowlevel.h:514:
+^I * on EOF or error, otherwise the rest of the data will be$
ERROR: code indent should never use tabs
#2878: FILE: tools/virtiofsd/fuse_lowlevel.h:515:
+^I * substituted with zeroes. An exception to this is when the file$
ERROR: code indent should never use tabs
#2879: FILE: tools/virtiofsd/fuse_lowlevel.h:516:
+^I * has been opened in 'direct_io' mode, in which case the return$
ERROR: code indent should never use tabs
#2880: FILE: tools/virtiofsd/fuse_lowlevel.h:517:
+^I * value of the read system call will reflect the return value of$
ERROR: code indent should never use tabs
#2881: FILE: tools/virtiofsd/fuse_lowlevel.h:518:
+^I * this operation.$
ERROR: code indent should never use tabs
#2882: FILE: tools/virtiofsd/fuse_lowlevel.h:519:
+^I *$
ERROR: code indent should never use tabs
#2883: FILE: tools/virtiofsd/fuse_lowlevel.h:520:
+^I * fi->fh will contain the value set by the open method, or will$
ERROR: code indent should never use tabs
#2884: FILE: tools/virtiofsd/fuse_lowlevel.h:521:
+^I * be undefined if the open method didn't set any value.$
ERROR: code indent should never use tabs
#2885: FILE: tools/virtiofsd/fuse_lowlevel.h:522:
+^I *$
ERROR: code indent should never use tabs
#2886: FILE: tools/virtiofsd/fuse_lowlevel.h:523:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2887: FILE: tools/virtiofsd/fuse_lowlevel.h:524:
+^I * fuse_reply_buf$
ERROR: code indent should never use tabs
#2888: FILE: tools/virtiofsd/fuse_lowlevel.h:525:
+^I * fuse_reply_iov$
ERROR: code indent should never use tabs
#2889: FILE: tools/virtiofsd/fuse_lowlevel.h:526:
+^I * fuse_reply_data$
ERROR: code indent should never use tabs
#2890: FILE: tools/virtiofsd/fuse_lowlevel.h:527:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2891: FILE: tools/virtiofsd/fuse_lowlevel.h:528:
+^I *$
ERROR: code indent should never use tabs
#2892: FILE: tools/virtiofsd/fuse_lowlevel.h:529:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2893: FILE: tools/virtiofsd/fuse_lowlevel.h:530:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2894: FILE: tools/virtiofsd/fuse_lowlevel.h:531:
+^I * @param size number of bytes to read$
ERROR: code indent should never use tabs
#2895: FILE: tools/virtiofsd/fuse_lowlevel.h:532:
+^I * @param off offset to read from$
ERROR: code indent should never use tabs
#2896: FILE: tools/virtiofsd/fuse_lowlevel.h:533:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#2897: FILE: tools/virtiofsd/fuse_lowlevel.h:534:
+^I */$
ERROR: code indent should never use tabs
#2898: FILE: tools/virtiofsd/fuse_lowlevel.h:535:
+^Ivoid (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,$
ERROR: code indent should never use tabs
#2899: FILE: tools/virtiofsd/fuse_lowlevel.h:536:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#2901: FILE: tools/virtiofsd/fuse_lowlevel.h:538:
+^I/**$
ERROR: code indent should never use tabs
#2902: FILE: tools/virtiofsd/fuse_lowlevel.h:539:
+^I * Write data$
ERROR: code indent should never use tabs
#2903: FILE: tools/virtiofsd/fuse_lowlevel.h:540:
+^I *$
ERROR: code indent should never use tabs
#2904: FILE: tools/virtiofsd/fuse_lowlevel.h:541:
+^I * Write should return exactly the number of bytes requested$
ERROR: code indent should never use tabs
#2905: FILE: tools/virtiofsd/fuse_lowlevel.h:542:
+^I * except on error. An exception to this is when the file has$
ERROR: code indent should never use tabs
#2906: FILE: tools/virtiofsd/fuse_lowlevel.h:543:
+^I * been opened in 'direct_io' mode, in which case the return value$
ERROR: code indent should never use tabs
#2907: FILE: tools/virtiofsd/fuse_lowlevel.h:544:
+^I * of the write system call will reflect the return value of this$
ERROR: code indent should never use tabs
#2908: FILE: tools/virtiofsd/fuse_lowlevel.h:545:
+^I * operation.$
ERROR: code indent should never use tabs
#2909: FILE: tools/virtiofsd/fuse_lowlevel.h:546:
+^I *$
ERROR: code indent should never use tabs
#2910: FILE: tools/virtiofsd/fuse_lowlevel.h:547:
+^I * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is$
ERROR: code indent should never use tabs
#2911: FILE: tools/virtiofsd/fuse_lowlevel.h:548:
+^I * expected to reset the setuid and setgid bits.$
ERROR: code indent should never use tabs
#2912: FILE: tools/virtiofsd/fuse_lowlevel.h:549:
+^I *$
ERROR: code indent should never use tabs
#2913: FILE: tools/virtiofsd/fuse_lowlevel.h:550:
+^I * fi->fh will contain the value set by the open method, or will$
ERROR: code indent should never use tabs
#2914: FILE: tools/virtiofsd/fuse_lowlevel.h:551:
+^I * be undefined if the open method didn't set any value.$
ERROR: code indent should never use tabs
#2915: FILE: tools/virtiofsd/fuse_lowlevel.h:552:
+^I *$
ERROR: code indent should never use tabs
#2916: FILE: tools/virtiofsd/fuse_lowlevel.h:553:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2917: FILE: tools/virtiofsd/fuse_lowlevel.h:554:
+^I * fuse_reply_write$
ERROR: code indent should never use tabs
#2918: FILE: tools/virtiofsd/fuse_lowlevel.h:555:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2919: FILE: tools/virtiofsd/fuse_lowlevel.h:556:
+^I *$
ERROR: code indent should never use tabs
#2920: FILE: tools/virtiofsd/fuse_lowlevel.h:557:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2921: FILE: tools/virtiofsd/fuse_lowlevel.h:558:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2922: FILE: tools/virtiofsd/fuse_lowlevel.h:559:
+^I * @param buf data to write$
ERROR: code indent should never use tabs
#2923: FILE: tools/virtiofsd/fuse_lowlevel.h:560:
+^I * @param size number of bytes to write$
ERROR: code indent should never use tabs
#2924: FILE: tools/virtiofsd/fuse_lowlevel.h:561:
+^I * @param off offset to write to$
ERROR: code indent should never use tabs
#2925: FILE: tools/virtiofsd/fuse_lowlevel.h:562:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#2926: FILE: tools/virtiofsd/fuse_lowlevel.h:563:
+^I */$
ERROR: code indent should never use tabs
#2927: FILE: tools/virtiofsd/fuse_lowlevel.h:564:
+^Ivoid (*write) (fuse_req_t req, fuse_ino_t ino, const char *buf,$
ERROR: code indent should never use tabs
#2928: FILE: tools/virtiofsd/fuse_lowlevel.h:565:
+^I^I size_t size, off_t off, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#2930: FILE: tools/virtiofsd/fuse_lowlevel.h:567:
+^I/**$
ERROR: code indent should never use tabs
#2931: FILE: tools/virtiofsd/fuse_lowlevel.h:568:
+^I * Flush method$
ERROR: code indent should never use tabs
#2932: FILE: tools/virtiofsd/fuse_lowlevel.h:569:
+^I *$
ERROR: code indent should never use tabs
#2933: FILE: tools/virtiofsd/fuse_lowlevel.h:570:
+^I * This is called on each close() of the opened file.$
ERROR: code indent should never use tabs
#2934: FILE: tools/virtiofsd/fuse_lowlevel.h:571:
+^I *$
ERROR: code indent should never use tabs
#2935: FILE: tools/virtiofsd/fuse_lowlevel.h:572:
+^I * Since file descriptors can be duplicated (dup, dup2, fork), for$
ERROR: code indent should never use tabs
#2936: FILE: tools/virtiofsd/fuse_lowlevel.h:573:
+^I * one open call there may be many flush calls.$
ERROR: code indent should never use tabs
#2937: FILE: tools/virtiofsd/fuse_lowlevel.h:574:
+^I *$
ERROR: code indent should never use tabs
#2938: FILE: tools/virtiofsd/fuse_lowlevel.h:575:
+^I * Filesystems shouldn't assume that flush will always be called$
ERROR: code indent should never use tabs
#2939: FILE: tools/virtiofsd/fuse_lowlevel.h:576:
+^I * after some writes, or that if will be called at all.$
ERROR: code indent should never use tabs
#2940: FILE: tools/virtiofsd/fuse_lowlevel.h:577:
+^I *$
ERROR: code indent should never use tabs
#2941: FILE: tools/virtiofsd/fuse_lowlevel.h:578:
+^I * fi->fh will contain the value set by the open method, or will$
ERROR: code indent should never use tabs
#2942: FILE: tools/virtiofsd/fuse_lowlevel.h:579:
+^I * be undefined if the open method didn't set any value.$
ERROR: code indent should never use tabs
#2943: FILE: tools/virtiofsd/fuse_lowlevel.h:580:
+^I *$
ERROR: code indent should never use tabs
#2944: FILE: tools/virtiofsd/fuse_lowlevel.h:581:
+^I * NOTE: the name of the method is misleading, since (unlike$
ERROR: code indent should never use tabs
#2945: FILE: tools/virtiofsd/fuse_lowlevel.h:582:
+^I * fsync) the filesystem is not forced to flush pending writes.$
ERROR: code indent should never use tabs
#2946: FILE: tools/virtiofsd/fuse_lowlevel.h:583:
+^I * One reason to flush data is if the filesystem wants to return$
ERROR: code indent should never use tabs
#2947: FILE: tools/virtiofsd/fuse_lowlevel.h:584:
+^I * write errors during close. However, such use is non-portable$
ERROR: code indent should never use tabs
#2948: FILE: tools/virtiofsd/fuse_lowlevel.h:585:
+^I * because POSIX does not require [close] to wait for delayed I/O to$
ERROR: code indent should never use tabs
#2949: FILE: tools/virtiofsd/fuse_lowlevel.h:586:
+^I * complete.$
ERROR: code indent should never use tabs
#2950: FILE: tools/virtiofsd/fuse_lowlevel.h:587:
+^I *$
ERROR: code indent should never use tabs
#2951: FILE: tools/virtiofsd/fuse_lowlevel.h:588:
+^I * If the filesystem supports file locking operations (setlk,$
ERROR: code indent should never use tabs
#2952: FILE: tools/virtiofsd/fuse_lowlevel.h:589:
+^I * getlk) it should remove all locks belonging to 'fi->owner'.$
ERROR: code indent should never use tabs
#2953: FILE: tools/virtiofsd/fuse_lowlevel.h:590:
+^I *$
ERROR: code indent should never use tabs
#2954: FILE: tools/virtiofsd/fuse_lowlevel.h:591:
+^I * If this request is answered with an error code of ENOSYS,$
ERROR: code indent should never use tabs
#2955: FILE: tools/virtiofsd/fuse_lowlevel.h:592:
+^I * this is treated as success and future calls to flush() will$
ERROR: code indent should never use tabs
#2956: FILE: tools/virtiofsd/fuse_lowlevel.h:593:
+^I * succeed automatically without being send to the filesystem$
ERROR: code indent should never use tabs
#2957: FILE: tools/virtiofsd/fuse_lowlevel.h:594:
+^I * process.$
ERROR: code indent should never use tabs
#2958: FILE: tools/virtiofsd/fuse_lowlevel.h:595:
+^I *$
ERROR: code indent should never use tabs
#2959: FILE: tools/virtiofsd/fuse_lowlevel.h:596:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2960: FILE: tools/virtiofsd/fuse_lowlevel.h:597:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2961: FILE: tools/virtiofsd/fuse_lowlevel.h:598:
+^I *$
ERROR: code indent should never use tabs
#2962: FILE: tools/virtiofsd/fuse_lowlevel.h:599:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2963: FILE: tools/virtiofsd/fuse_lowlevel.h:600:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2964: FILE: tools/virtiofsd/fuse_lowlevel.h:601:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#2965: FILE: tools/virtiofsd/fuse_lowlevel.h:602:
+^I *$
WARNING: line over 80 characters
#2966: FILE: tools/virtiofsd/fuse_lowlevel.h:603:
+ * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
ERROR: code indent should never use tabs
#2966: FILE: tools/virtiofsd/fuse_lowlevel.h:603:
+^I * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html$
ERROR: code indent should never use tabs
#2967: FILE: tools/virtiofsd/fuse_lowlevel.h:604:
+^I */$
ERROR: code indent should never use tabs
#2968: FILE: tools/virtiofsd/fuse_lowlevel.h:605:
+^Ivoid (*flush) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#2969: FILE: tools/virtiofsd/fuse_lowlevel.h:606:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#2971: FILE: tools/virtiofsd/fuse_lowlevel.h:608:
+^I/**$
ERROR: code indent should never use tabs
#2972: FILE: tools/virtiofsd/fuse_lowlevel.h:609:
+^I * Release an open file$
ERROR: code indent should never use tabs
#2973: FILE: tools/virtiofsd/fuse_lowlevel.h:610:
+^I *$
ERROR: code indent should never use tabs
#2974: FILE: tools/virtiofsd/fuse_lowlevel.h:611:
+^I * Release is called when there are no more references to an open$
ERROR: code indent should never use tabs
#2975: FILE: tools/virtiofsd/fuse_lowlevel.h:612:
+^I * file: all file descriptors are closed and all memory mappings$
ERROR: code indent should never use tabs
#2976: FILE: tools/virtiofsd/fuse_lowlevel.h:613:
+^I * are unmapped.$
ERROR: code indent should never use tabs
#2977: FILE: tools/virtiofsd/fuse_lowlevel.h:614:
+^I *$
ERROR: code indent should never use tabs
#2978: FILE: tools/virtiofsd/fuse_lowlevel.h:615:
+^I * For every open call there will be exactly one release call (unless$
ERROR: code indent should never use tabs
#2979: FILE: tools/virtiofsd/fuse_lowlevel.h:616:
+^I * the filesystem is force-unmounted).$
ERROR: code indent should never use tabs
#2980: FILE: tools/virtiofsd/fuse_lowlevel.h:617:
+^I *$
ERROR: code indent should never use tabs
#2981: FILE: tools/virtiofsd/fuse_lowlevel.h:618:
+^I * The filesystem may reply with an error, but error values are$
ERROR: code indent should never use tabs
#2982: FILE: tools/virtiofsd/fuse_lowlevel.h:619:
+^I * not returned to close() or munmap() which triggered the$
ERROR: code indent should never use tabs
#2983: FILE: tools/virtiofsd/fuse_lowlevel.h:620:
+^I * release.$
ERROR: code indent should never use tabs
#2984: FILE: tools/virtiofsd/fuse_lowlevel.h:621:
+^I *$
ERROR: code indent should never use tabs
#2985: FILE: tools/virtiofsd/fuse_lowlevel.h:622:
+^I * fi->fh will contain the value set by the open method, or will$
ERROR: code indent should never use tabs
#2986: FILE: tools/virtiofsd/fuse_lowlevel.h:623:
+^I * be undefined if the open method didn't set any value.$
ERROR: code indent should never use tabs
#2987: FILE: tools/virtiofsd/fuse_lowlevel.h:624:
+^I * fi->flags will contain the same flags as for open.$
ERROR: code indent should never use tabs
#2988: FILE: tools/virtiofsd/fuse_lowlevel.h:625:
+^I *$
ERROR: code indent should never use tabs
#2989: FILE: tools/virtiofsd/fuse_lowlevel.h:626:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#2990: FILE: tools/virtiofsd/fuse_lowlevel.h:627:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#2991: FILE: tools/virtiofsd/fuse_lowlevel.h:628:
+^I *$
ERROR: code indent should never use tabs
#2992: FILE: tools/virtiofsd/fuse_lowlevel.h:629:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#2993: FILE: tools/virtiofsd/fuse_lowlevel.h:630:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#2994: FILE: tools/virtiofsd/fuse_lowlevel.h:631:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#2995: FILE: tools/virtiofsd/fuse_lowlevel.h:632:
+^I */$
ERROR: code indent should never use tabs
#2996: FILE: tools/virtiofsd/fuse_lowlevel.h:633:
+^Ivoid (*release) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#2997: FILE: tools/virtiofsd/fuse_lowlevel.h:634:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#2999: FILE: tools/virtiofsd/fuse_lowlevel.h:636:
+^I/**$
ERROR: code indent should never use tabs
#3000: FILE: tools/virtiofsd/fuse_lowlevel.h:637:
+^I * Synchronize file contents$
ERROR: code indent should never use tabs
#3001: FILE: tools/virtiofsd/fuse_lowlevel.h:638:
+^I *$
ERROR: code indent should never use tabs
#3002: FILE: tools/virtiofsd/fuse_lowlevel.h:639:
+^I * If the datasync parameter is non-zero, then only the user data$
ERROR: code indent should never use tabs
#3003: FILE: tools/virtiofsd/fuse_lowlevel.h:640:
+^I * should be flushed, not the meta data.$
ERROR: code indent should never use tabs
#3004: FILE: tools/virtiofsd/fuse_lowlevel.h:641:
+^I *$
ERROR: code indent should never use tabs
#3005: FILE: tools/virtiofsd/fuse_lowlevel.h:642:
+^I * If this request is answered with an error code of ENOSYS,$
ERROR: code indent should never use tabs
#3006: FILE: tools/virtiofsd/fuse_lowlevel.h:643:
+^I * this is treated as success and future calls to fsync() will$
ERROR: code indent should never use tabs
#3007: FILE: tools/virtiofsd/fuse_lowlevel.h:644:
+^I * succeed automatically without being send to the filesystem$
ERROR: code indent should never use tabs
#3008: FILE: tools/virtiofsd/fuse_lowlevel.h:645:
+^I * process.$
ERROR: code indent should never use tabs
#3009: FILE: tools/virtiofsd/fuse_lowlevel.h:646:
+^I *$
ERROR: code indent should never use tabs
#3010: FILE: tools/virtiofsd/fuse_lowlevel.h:647:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3011: FILE: tools/virtiofsd/fuse_lowlevel.h:648:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3012: FILE: tools/virtiofsd/fuse_lowlevel.h:649:
+^I *$
ERROR: code indent should never use tabs
#3013: FILE: tools/virtiofsd/fuse_lowlevel.h:650:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3014: FILE: tools/virtiofsd/fuse_lowlevel.h:651:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3015: FILE: tools/virtiofsd/fuse_lowlevel.h:652:
+^I * @param datasync flag indicating if only data should be flushed$
ERROR: code indent should never use tabs
#3016: FILE: tools/virtiofsd/fuse_lowlevel.h:653:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3017: FILE: tools/virtiofsd/fuse_lowlevel.h:654:
+^I */$
ERROR: code indent should never use tabs
#3018: FILE: tools/virtiofsd/fuse_lowlevel.h:655:
+^Ivoid (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync,$
ERROR: code indent should never use tabs
#3019: FILE: tools/virtiofsd/fuse_lowlevel.h:656:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3021: FILE: tools/virtiofsd/fuse_lowlevel.h:658:
+^I/**$
ERROR: code indent should never use tabs
#3022: FILE: tools/virtiofsd/fuse_lowlevel.h:659:
+^I * Open a directory$
ERROR: code indent should never use tabs
#3023: FILE: tools/virtiofsd/fuse_lowlevel.h:660:
+^I *$
ERROR: code indent should never use tabs
#3024: FILE: tools/virtiofsd/fuse_lowlevel.h:661:
+^I * Filesystem may store an arbitrary file handle (pointer, index,$
ERROR: code indent should never use tabs
#3025: FILE: tools/virtiofsd/fuse_lowlevel.h:662:
+^I * etc) in fi->fh, and use this in other all other directory$
ERROR: code indent should never use tabs
#3026: FILE: tools/virtiofsd/fuse_lowlevel.h:663:
+^I * stream operations (readdir, releasedir, fsyncdir).$
ERROR: code indent should never use tabs
#3027: FILE: tools/virtiofsd/fuse_lowlevel.h:664:
+^I *$
ERROR: code indent should never use tabs
#3028: FILE: tools/virtiofsd/fuse_lowlevel.h:665:
+^I * If this request is answered with an error code of ENOSYS and$
ERROR: code indent should never use tabs
#3029: FILE: tools/virtiofsd/fuse_lowlevel.h:666:
+^I * FUSE_CAP_NO_OPENDIR_SUPPORT is set in `fuse_conn_info.capable`,$
ERROR: code indent should never use tabs
#3030: FILE: tools/virtiofsd/fuse_lowlevel.h:667:
+^I * this is treated as success and future calls to opendir and$
ERROR: code indent should never use tabs
#3031: FILE: tools/virtiofsd/fuse_lowlevel.h:668:
+^I * releasedir will also succeed without being sent to the filesystem$
ERROR: code indent should never use tabs
#3032: FILE: tools/virtiofsd/fuse_lowlevel.h:669:
+^I * process. In addition, the kernel will cache readdir results$
ERROR: code indent should never use tabs
#3033: FILE: tools/virtiofsd/fuse_lowlevel.h:670:
+^I * as if opendir returned FOPEN_KEEP_CACHE | FOPEN_CACHE_DIR.$
ERROR: code indent should never use tabs
#3034: FILE: tools/virtiofsd/fuse_lowlevel.h:671:
+^I *$
ERROR: code indent should never use tabs
#3035: FILE: tools/virtiofsd/fuse_lowlevel.h:672:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3036: FILE: tools/virtiofsd/fuse_lowlevel.h:673:
+^I * fuse_reply_open$
ERROR: code indent should never use tabs
#3037: FILE: tools/virtiofsd/fuse_lowlevel.h:674:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3038: FILE: tools/virtiofsd/fuse_lowlevel.h:675:
+^I *$
ERROR: code indent should never use tabs
#3039: FILE: tools/virtiofsd/fuse_lowlevel.h:676:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3040: FILE: tools/virtiofsd/fuse_lowlevel.h:677:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3041: FILE: tools/virtiofsd/fuse_lowlevel.h:678:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3042: FILE: tools/virtiofsd/fuse_lowlevel.h:679:
+^I */$
ERROR: code indent should never use tabs
#3043: FILE: tools/virtiofsd/fuse_lowlevel.h:680:
+^Ivoid (*opendir) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#3044: FILE: tools/virtiofsd/fuse_lowlevel.h:681:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3046: FILE: tools/virtiofsd/fuse_lowlevel.h:683:
+^I/**$
ERROR: code indent should never use tabs
#3047: FILE: tools/virtiofsd/fuse_lowlevel.h:684:
+^I * Read directory$
ERROR: code indent should never use tabs
#3048: FILE: tools/virtiofsd/fuse_lowlevel.h:685:
+^I *$
ERROR: code indent should never use tabs
#3049: FILE: tools/virtiofsd/fuse_lowlevel.h:686:
+^I * Send a buffer filled using fuse_add_direntry(), with size not$
ERROR: code indent should never use tabs
#3050: FILE: tools/virtiofsd/fuse_lowlevel.h:687:
+^I * exceeding the requested size. Send an empty buffer on end of$
ERROR: code indent should never use tabs
#3051: FILE: tools/virtiofsd/fuse_lowlevel.h:688:
+^I * stream.$
ERROR: code indent should never use tabs
#3052: FILE: tools/virtiofsd/fuse_lowlevel.h:689:
+^I *$
ERROR: code indent should never use tabs
#3053: FILE: tools/virtiofsd/fuse_lowlevel.h:690:
+^I * fi->fh will contain the value set by the opendir method, or$
ERROR: code indent should never use tabs
#3054: FILE: tools/virtiofsd/fuse_lowlevel.h:691:
+^I * will be undefined if the opendir method didn't set any value.$
ERROR: code indent should never use tabs
#3055: FILE: tools/virtiofsd/fuse_lowlevel.h:692:
+^I *$
ERROR: code indent should never use tabs
#3056: FILE: tools/virtiofsd/fuse_lowlevel.h:693:
+^I * Returning a directory entry from readdir() does not affect$
ERROR: code indent should never use tabs
#3057: FILE: tools/virtiofsd/fuse_lowlevel.h:694:
+^I * its lookup count.$
ERROR: code indent should never use tabs
#3058: FILE: tools/virtiofsd/fuse_lowlevel.h:695:
+^I *$
ERROR: code indent should never use tabs
#3060: FILE: tools/virtiofsd/fuse_lowlevel.h:697:
+^I * values that was previously returned by readdir() for the same$
ERROR: code indent should never use tabs
#3061: FILE: tools/virtiofsd/fuse_lowlevel.h:698:
+^I * directory handle. In this case, readdir() should skip over entries$
ERROR: code indent should never use tabs
#3062: FILE: tools/virtiofsd/fuse_lowlevel.h:699:
+^I * coming before the position defined by the off_t value. If entries$
WARNING: line over 80 characters
#3063: FILE: tools/virtiofsd/fuse_lowlevel.h:700:
+ * are added or removed while the directory handle is open, they filesystem
ERROR: code indent should never use tabs
#3063: FILE: tools/virtiofsd/fuse_lowlevel.h:700:
+^I * are added or removed while the directory handle is open, they filesystem$
ERROR: code indent should never use tabs
#3064: FILE: tools/virtiofsd/fuse_lowlevel.h:701:
+^I * may still include the entries that have been removed, and may not$
ERROR: code indent should never use tabs
#3065: FILE: tools/virtiofsd/fuse_lowlevel.h:702:
+^I * report the entries that have been created. However, addition or$
ERROR: code indent should never use tabs
#3066: FILE: tools/virtiofsd/fuse_lowlevel.h:703:
+^I * removal of entries must never cause readdir() to skip over unrelated$
ERROR: code indent should never use tabs
#3067: FILE: tools/virtiofsd/fuse_lowlevel.h:704:
+^I * entries or to report them more than once. This means$
ERROR: code indent should never use tabs
#3068: FILE: tools/virtiofsd/fuse_lowlevel.h:705:
+^I * that off_t can not be a simple index that enumerates the entries$
ERROR: code indent should never use tabs
#3069: FILE: tools/virtiofsd/fuse_lowlevel.h:706:
+^I * that have been returned but must contain sufficient information to$
ERROR: code indent should never use tabs
#3070: FILE: tools/virtiofsd/fuse_lowlevel.h:707:
+^I * uniquely determine the next directory entry to return even when the$
ERROR: code indent should never use tabs
#3071: FILE: tools/virtiofsd/fuse_lowlevel.h:708:
+^I * set of entries is changing.$
ERROR: code indent should never use tabs
#3072: FILE: tools/virtiofsd/fuse_lowlevel.h:709:
+^I *$
ERROR: code indent should never use tabs
#3073: FILE: tools/virtiofsd/fuse_lowlevel.h:710:
+^I * The function does not have to report the '.' and '..'$
ERROR: code indent should never use tabs
#3074: FILE: tools/virtiofsd/fuse_lowlevel.h:711:
+^I * entries, but is allowed to do so. Note that, if readdir does$
ERROR: code indent should never use tabs
#3075: FILE: tools/virtiofsd/fuse_lowlevel.h:712:
+^I * not return '.' or '..', they will not be implicitly returned,$
ERROR: code indent should never use tabs
#3076: FILE: tools/virtiofsd/fuse_lowlevel.h:713:
+^I * and this behavior is observable by the caller.$
ERROR: code indent should never use tabs
#3077: FILE: tools/virtiofsd/fuse_lowlevel.h:714:
+^I *$
ERROR: code indent should never use tabs
#3078: FILE: tools/virtiofsd/fuse_lowlevel.h:715:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3079: FILE: tools/virtiofsd/fuse_lowlevel.h:716:
+^I * fuse_reply_buf$
ERROR: code indent should never use tabs
#3080: FILE: tools/virtiofsd/fuse_lowlevel.h:717:
+^I * fuse_reply_data$
ERROR: code indent should never use tabs
#3081: FILE: tools/virtiofsd/fuse_lowlevel.h:718:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3082: FILE: tools/virtiofsd/fuse_lowlevel.h:719:
+^I *$
ERROR: code indent should never use tabs
#3083: FILE: tools/virtiofsd/fuse_lowlevel.h:720:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3084: FILE: tools/virtiofsd/fuse_lowlevel.h:721:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3085: FILE: tools/virtiofsd/fuse_lowlevel.h:722:
+^I * @param size maximum number of bytes to send$
ERROR: code indent should never use tabs
#3086: FILE: tools/virtiofsd/fuse_lowlevel.h:723:
+^I * @param off offset to continue reading the directory stream$
ERROR: code indent should never use tabs
#3087: FILE: tools/virtiofsd/fuse_lowlevel.h:724:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3088: FILE: tools/virtiofsd/fuse_lowlevel.h:725:
+^I */$
ERROR: code indent should never use tabs
#3089: FILE: tools/virtiofsd/fuse_lowlevel.h:726:
+^Ivoid (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,$
ERROR: code indent should never use tabs
#3090: FILE: tools/virtiofsd/fuse_lowlevel.h:727:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3092: FILE: tools/virtiofsd/fuse_lowlevel.h:729:
+^I/**$
ERROR: code indent should never use tabs
#3093: FILE: tools/virtiofsd/fuse_lowlevel.h:730:
+^I * Release an open directory$
ERROR: code indent should never use tabs
#3094: FILE: tools/virtiofsd/fuse_lowlevel.h:731:
+^I *$
ERROR: code indent should never use tabs
#3095: FILE: tools/virtiofsd/fuse_lowlevel.h:732:
+^I * For every opendir call there will be exactly one releasedir$
ERROR: code indent should never use tabs
#3096: FILE: tools/virtiofsd/fuse_lowlevel.h:733:
+^I * call (unless the filesystem is force-unmounted).$
ERROR: code indent should never use tabs
#3097: FILE: tools/virtiofsd/fuse_lowlevel.h:734:
+^I *$
ERROR: code indent should never use tabs
#3098: FILE: tools/virtiofsd/fuse_lowlevel.h:735:
+^I * fi->fh will contain the value set by the opendir method, or$
ERROR: code indent should never use tabs
#3099: FILE: tools/virtiofsd/fuse_lowlevel.h:736:
+^I * will be undefined if the opendir method didn't set any value.$
ERROR: code indent should never use tabs
#3100: FILE: tools/virtiofsd/fuse_lowlevel.h:737:
+^I *$
ERROR: code indent should never use tabs
#3101: FILE: tools/virtiofsd/fuse_lowlevel.h:738:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3102: FILE: tools/virtiofsd/fuse_lowlevel.h:739:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3103: FILE: tools/virtiofsd/fuse_lowlevel.h:740:
+^I *$
ERROR: code indent should never use tabs
#3104: FILE: tools/virtiofsd/fuse_lowlevel.h:741:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3105: FILE: tools/virtiofsd/fuse_lowlevel.h:742:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3106: FILE: tools/virtiofsd/fuse_lowlevel.h:743:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3107: FILE: tools/virtiofsd/fuse_lowlevel.h:744:
+^I */$
ERROR: code indent should never use tabs
#3108: FILE: tools/virtiofsd/fuse_lowlevel.h:745:
+^Ivoid (*releasedir) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#3109: FILE: tools/virtiofsd/fuse_lowlevel.h:746:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3111: FILE: tools/virtiofsd/fuse_lowlevel.h:748:
+^I/**$
ERROR: code indent should never use tabs
#3112: FILE: tools/virtiofsd/fuse_lowlevel.h:749:
+^I * Synchronize directory contents$
ERROR: code indent should never use tabs
#3113: FILE: tools/virtiofsd/fuse_lowlevel.h:750:
+^I *$
ERROR: code indent should never use tabs
#3114: FILE: tools/virtiofsd/fuse_lowlevel.h:751:
+^I * If the datasync parameter is non-zero, then only the directory$
ERROR: code indent should never use tabs
#3115: FILE: tools/virtiofsd/fuse_lowlevel.h:752:
+^I * contents should be flushed, not the meta data.$
ERROR: code indent should never use tabs
#3116: FILE: tools/virtiofsd/fuse_lowlevel.h:753:
+^I *$
ERROR: code indent should never use tabs
#3117: FILE: tools/virtiofsd/fuse_lowlevel.h:754:
+^I * fi->fh will contain the value set by the opendir method, or$
ERROR: code indent should never use tabs
#3118: FILE: tools/virtiofsd/fuse_lowlevel.h:755:
+^I * will be undefined if the opendir method didn't set any value.$
ERROR: code indent should never use tabs
#3119: FILE: tools/virtiofsd/fuse_lowlevel.h:756:
+^I *$
ERROR: code indent should never use tabs
#3120: FILE: tools/virtiofsd/fuse_lowlevel.h:757:
+^I * If this request is answered with an error code of ENOSYS,$
ERROR: code indent should never use tabs
#3121: FILE: tools/virtiofsd/fuse_lowlevel.h:758:
+^I * this is treated as success and future calls to fsyncdir() will$
ERROR: code indent should never use tabs
#3122: FILE: tools/virtiofsd/fuse_lowlevel.h:759:
+^I * succeed automatically without being send to the filesystem$
ERROR: code indent should never use tabs
#3123: FILE: tools/virtiofsd/fuse_lowlevel.h:760:
+^I * process.$
ERROR: code indent should never use tabs
#3124: FILE: tools/virtiofsd/fuse_lowlevel.h:761:
+^I *$
ERROR: code indent should never use tabs
#3125: FILE: tools/virtiofsd/fuse_lowlevel.h:762:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3126: FILE: tools/virtiofsd/fuse_lowlevel.h:763:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3127: FILE: tools/virtiofsd/fuse_lowlevel.h:764:
+^I *$
ERROR: code indent should never use tabs
#3128: FILE: tools/virtiofsd/fuse_lowlevel.h:765:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3129: FILE: tools/virtiofsd/fuse_lowlevel.h:766:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3130: FILE: tools/virtiofsd/fuse_lowlevel.h:767:
+^I * @param datasync flag indicating if only data should be flushed$
ERROR: code indent should never use tabs
#3131: FILE: tools/virtiofsd/fuse_lowlevel.h:768:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3132: FILE: tools/virtiofsd/fuse_lowlevel.h:769:
+^I */$
ERROR: code indent should never use tabs
#3133: FILE: tools/virtiofsd/fuse_lowlevel.h:770:
+^Ivoid (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync,$
ERROR: code indent should never use tabs
#3134: FILE: tools/virtiofsd/fuse_lowlevel.h:771:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3136: FILE: tools/virtiofsd/fuse_lowlevel.h:773:
+^I/**$
ERROR: code indent should never use tabs
#3137: FILE: tools/virtiofsd/fuse_lowlevel.h:774:
+^I * Get file system statistics$
ERROR: code indent should never use tabs
#3138: FILE: tools/virtiofsd/fuse_lowlevel.h:775:
+^I *$
ERROR: code indent should never use tabs
#3139: FILE: tools/virtiofsd/fuse_lowlevel.h:776:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3140: FILE: tools/virtiofsd/fuse_lowlevel.h:777:
+^I * fuse_reply_statfs$
ERROR: code indent should never use tabs
#3141: FILE: tools/virtiofsd/fuse_lowlevel.h:778:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3142: FILE: tools/virtiofsd/fuse_lowlevel.h:779:
+^I *$
ERROR: code indent should never use tabs
#3143: FILE: tools/virtiofsd/fuse_lowlevel.h:780:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3144: FILE: tools/virtiofsd/fuse_lowlevel.h:781:
+^I * @param ino the inode number, zero means "undefined"$
ERROR: code indent should never use tabs
#3145: FILE: tools/virtiofsd/fuse_lowlevel.h:782:
+^I */$
ERROR: code indent should never use tabs
#3146: FILE: tools/virtiofsd/fuse_lowlevel.h:783:
+^Ivoid (*statfs) (fuse_req_t req, fuse_ino_t ino);$
ERROR: code indent should never use tabs
#3148: FILE: tools/virtiofsd/fuse_lowlevel.h:785:
+^I/**$
ERROR: code indent should never use tabs
#3149: FILE: tools/virtiofsd/fuse_lowlevel.h:786:
+^I * Set an extended attribute$
ERROR: code indent should never use tabs
#3150: FILE: tools/virtiofsd/fuse_lowlevel.h:787:
+^I *$
ERROR: code indent should never use tabs
#3151: FILE: tools/virtiofsd/fuse_lowlevel.h:788:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3152: FILE: tools/virtiofsd/fuse_lowlevel.h:789:
+^I * treated as a permanent failure with error code EOPNOTSUPP, i.e. all$
ERROR: code indent should never use tabs
#3153: FILE: tools/virtiofsd/fuse_lowlevel.h:790:
+^I * future setxattr() requests will fail with EOPNOTSUPP without being$
ERROR: code indent should never use tabs
#3154: FILE: tools/virtiofsd/fuse_lowlevel.h:791:
+^I * send to the filesystem process.$
ERROR: code indent should never use tabs
#3155: FILE: tools/virtiofsd/fuse_lowlevel.h:792:
+^I *$
ERROR: code indent should never use tabs
#3156: FILE: tools/virtiofsd/fuse_lowlevel.h:793:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3157: FILE: tools/virtiofsd/fuse_lowlevel.h:794:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3158: FILE: tools/virtiofsd/fuse_lowlevel.h:795:
+^I */$
ERROR: code indent should never use tabs
#3159: FILE: tools/virtiofsd/fuse_lowlevel.h:796:
+^Ivoid (*setxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,$
ERROR: code indent should never use tabs
#3160: FILE: tools/virtiofsd/fuse_lowlevel.h:797:
+^I^I^I const char *value, size_t size, int flags);$
ERROR: code indent should never use tabs
#3162: FILE: tools/virtiofsd/fuse_lowlevel.h:799:
+^I/**$
ERROR: code indent should never use tabs
#3163: FILE: tools/virtiofsd/fuse_lowlevel.h:800:
+^I * Get an extended attribute$
ERROR: code indent should never use tabs
#3164: FILE: tools/virtiofsd/fuse_lowlevel.h:801:
+^I *$
ERROR: code indent should never use tabs
#3165: FILE: tools/virtiofsd/fuse_lowlevel.h:802:
+^I * If size is zero, the size of the value should be sent with$
ERROR: code indent should never use tabs
#3166: FILE: tools/virtiofsd/fuse_lowlevel.h:803:
+^I * fuse_reply_xattr.$
ERROR: code indent should never use tabs
#3167: FILE: tools/virtiofsd/fuse_lowlevel.h:804:
+^I *$
ERROR: code indent should never use tabs
#3168: FILE: tools/virtiofsd/fuse_lowlevel.h:805:
+^I * If the size is non-zero, and the value fits in the buffer, the$
ERROR: code indent should never use tabs
#3169: FILE: tools/virtiofsd/fuse_lowlevel.h:806:
+^I * value should be sent with fuse_reply_buf.$
ERROR: code indent should never use tabs
#3170: FILE: tools/virtiofsd/fuse_lowlevel.h:807:
+^I *$
ERROR: code indent should never use tabs
#3171: FILE: tools/virtiofsd/fuse_lowlevel.h:808:
+^I * If the size is too small for the value, the ERANGE error should$
ERROR: code indent should never use tabs
#3172: FILE: tools/virtiofsd/fuse_lowlevel.h:809:
+^I * be sent.$
ERROR: code indent should never use tabs
#3173: FILE: tools/virtiofsd/fuse_lowlevel.h:810:
+^I *$
ERROR: code indent should never use tabs
#3174: FILE: tools/virtiofsd/fuse_lowlevel.h:811:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3175: FILE: tools/virtiofsd/fuse_lowlevel.h:812:
+^I * treated as a permanent failure with error code EOPNOTSUPP, i.e. all$
ERROR: code indent should never use tabs
#3176: FILE: tools/virtiofsd/fuse_lowlevel.h:813:
+^I * future getxattr() requests will fail with EOPNOTSUPP without being$
ERROR: code indent should never use tabs
#3177: FILE: tools/virtiofsd/fuse_lowlevel.h:814:
+^I * send to the filesystem process.$
ERROR: code indent should never use tabs
#3178: FILE: tools/virtiofsd/fuse_lowlevel.h:815:
+^I *$
ERROR: code indent should never use tabs
#3179: FILE: tools/virtiofsd/fuse_lowlevel.h:816:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3180: FILE: tools/virtiofsd/fuse_lowlevel.h:817:
+^I * fuse_reply_buf$
ERROR: code indent should never use tabs
#3181: FILE: tools/virtiofsd/fuse_lowlevel.h:818:
+^I * fuse_reply_data$
ERROR: code indent should never use tabs
#3182: FILE: tools/virtiofsd/fuse_lowlevel.h:819:
+^I * fuse_reply_xattr$
ERROR: code indent should never use tabs
#3183: FILE: tools/virtiofsd/fuse_lowlevel.h:820:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3184: FILE: tools/virtiofsd/fuse_lowlevel.h:821:
+^I *$
ERROR: code indent should never use tabs
#3185: FILE: tools/virtiofsd/fuse_lowlevel.h:822:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3186: FILE: tools/virtiofsd/fuse_lowlevel.h:823:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3187: FILE: tools/virtiofsd/fuse_lowlevel.h:824:
+^I * @param name of the extended attribute$
ERROR: code indent should never use tabs
#3188: FILE: tools/virtiofsd/fuse_lowlevel.h:825:
+^I * @param size maximum size of the value to send$
ERROR: code indent should never use tabs
#3189: FILE: tools/virtiofsd/fuse_lowlevel.h:826:
+^I */$
ERROR: code indent should never use tabs
#3190: FILE: tools/virtiofsd/fuse_lowlevel.h:827:
+^Ivoid (*getxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,$
ERROR: code indent should never use tabs
#3191: FILE: tools/virtiofsd/fuse_lowlevel.h:828:
+^I^I^I size_t size);$
ERROR: code indent should never use tabs
#3193: FILE: tools/virtiofsd/fuse_lowlevel.h:830:
+^I/**$
ERROR: code indent should never use tabs
#3194: FILE: tools/virtiofsd/fuse_lowlevel.h:831:
+^I * List extended attribute names$
ERROR: code indent should never use tabs
#3195: FILE: tools/virtiofsd/fuse_lowlevel.h:832:
+^I *$
ERROR: code indent should never use tabs
#3196: FILE: tools/virtiofsd/fuse_lowlevel.h:833:
+^I * If size is zero, the total size of the attribute list should be$
ERROR: code indent should never use tabs
#3197: FILE: tools/virtiofsd/fuse_lowlevel.h:834:
+^I * sent with fuse_reply_xattr.$
ERROR: code indent should never use tabs
#3198: FILE: tools/virtiofsd/fuse_lowlevel.h:835:
+^I *$
ERROR: code indent should never use tabs
#3199: FILE: tools/virtiofsd/fuse_lowlevel.h:836:
+^I * If the size is non-zero, and the null character separated$
ERROR: code indent should never use tabs
#3200: FILE: tools/virtiofsd/fuse_lowlevel.h:837:
+^I * attribute list fits in the buffer, the list should be sent with$
ERROR: code indent should never use tabs
#3201: FILE: tools/virtiofsd/fuse_lowlevel.h:838:
+^I * fuse_reply_buf.$
ERROR: code indent should never use tabs
#3202: FILE: tools/virtiofsd/fuse_lowlevel.h:839:
+^I *$
ERROR: code indent should never use tabs
#3203: FILE: tools/virtiofsd/fuse_lowlevel.h:840:
+^I * If the size is too small for the list, the ERANGE error should$
ERROR: code indent should never use tabs
#3204: FILE: tools/virtiofsd/fuse_lowlevel.h:841:
+^I * be sent.$
ERROR: code indent should never use tabs
#3205: FILE: tools/virtiofsd/fuse_lowlevel.h:842:
+^I *$
ERROR: code indent should never use tabs
#3206: FILE: tools/virtiofsd/fuse_lowlevel.h:843:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3207: FILE: tools/virtiofsd/fuse_lowlevel.h:844:
+^I * treated as a permanent failure with error code EOPNOTSUPP, i.e. all$
ERROR: code indent should never use tabs
#3208: FILE: tools/virtiofsd/fuse_lowlevel.h:845:
+^I * future listxattr() requests will fail with EOPNOTSUPP without being$
ERROR: code indent should never use tabs
#3209: FILE: tools/virtiofsd/fuse_lowlevel.h:846:
+^I * send to the filesystem process.$
ERROR: code indent should never use tabs
#3210: FILE: tools/virtiofsd/fuse_lowlevel.h:847:
+^I *$
ERROR: code indent should never use tabs
#3211: FILE: tools/virtiofsd/fuse_lowlevel.h:848:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3212: FILE: tools/virtiofsd/fuse_lowlevel.h:849:
+^I * fuse_reply_buf$
ERROR: code indent should never use tabs
#3213: FILE: tools/virtiofsd/fuse_lowlevel.h:850:
+^I * fuse_reply_data$
ERROR: code indent should never use tabs
#3214: FILE: tools/virtiofsd/fuse_lowlevel.h:851:
+^I * fuse_reply_xattr$
ERROR: code indent should never use tabs
#3215: FILE: tools/virtiofsd/fuse_lowlevel.h:852:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3216: FILE: tools/virtiofsd/fuse_lowlevel.h:853:
+^I *$
ERROR: code indent should never use tabs
#3217: FILE: tools/virtiofsd/fuse_lowlevel.h:854:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3218: FILE: tools/virtiofsd/fuse_lowlevel.h:855:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3219: FILE: tools/virtiofsd/fuse_lowlevel.h:856:
+^I * @param size maximum size of the list to send$
ERROR: code indent should never use tabs
#3220: FILE: tools/virtiofsd/fuse_lowlevel.h:857:
+^I */$
ERROR: code indent should never use tabs
#3221: FILE: tools/virtiofsd/fuse_lowlevel.h:858:
+^Ivoid (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size);$
ERROR: code indent should never use tabs
#3223: FILE: tools/virtiofsd/fuse_lowlevel.h:860:
+^I/**$
ERROR: code indent should never use tabs
#3224: FILE: tools/virtiofsd/fuse_lowlevel.h:861:
+^I * Remove an extended attribute$
ERROR: code indent should never use tabs
#3225: FILE: tools/virtiofsd/fuse_lowlevel.h:862:
+^I *$
ERROR: code indent should never use tabs
#3226: FILE: tools/virtiofsd/fuse_lowlevel.h:863:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3227: FILE: tools/virtiofsd/fuse_lowlevel.h:864:
+^I * treated as a permanent failure with error code EOPNOTSUPP, i.e. all$
ERROR: code indent should never use tabs
#3228: FILE: tools/virtiofsd/fuse_lowlevel.h:865:
+^I * future removexattr() requests will fail with EOPNOTSUPP without being$
ERROR: code indent should never use tabs
#3229: FILE: tools/virtiofsd/fuse_lowlevel.h:866:
+^I * send to the filesystem process.$
ERROR: code indent should never use tabs
#3230: FILE: tools/virtiofsd/fuse_lowlevel.h:867:
+^I *$
ERROR: code indent should never use tabs
#3231: FILE: tools/virtiofsd/fuse_lowlevel.h:868:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3232: FILE: tools/virtiofsd/fuse_lowlevel.h:869:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3233: FILE: tools/virtiofsd/fuse_lowlevel.h:870:
+^I *$
ERROR: code indent should never use tabs
#3234: FILE: tools/virtiofsd/fuse_lowlevel.h:871:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3235: FILE: tools/virtiofsd/fuse_lowlevel.h:872:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3236: FILE: tools/virtiofsd/fuse_lowlevel.h:873:
+^I * @param name of the extended attribute$
ERROR: code indent should never use tabs
#3237: FILE: tools/virtiofsd/fuse_lowlevel.h:874:
+^I */$
ERROR: code indent should never use tabs
#3238: FILE: tools/virtiofsd/fuse_lowlevel.h:875:
+^Ivoid (*removexattr) (fuse_req_t req, fuse_ino_t ino, const char *name);$
ERROR: code indent should never use tabs
#3240: FILE: tools/virtiofsd/fuse_lowlevel.h:877:
+^I/**$
ERROR: code indent should never use tabs
#3241: FILE: tools/virtiofsd/fuse_lowlevel.h:878:
+^I * Check file access permissions$
ERROR: code indent should never use tabs
#3242: FILE: tools/virtiofsd/fuse_lowlevel.h:879:
+^I *$
ERROR: code indent should never use tabs
#3243: FILE: tools/virtiofsd/fuse_lowlevel.h:880:
+^I * This will be called for the access() and chdir() system$
ERROR: code indent should never use tabs
#3244: FILE: tools/virtiofsd/fuse_lowlevel.h:881:
+^I * calls. If the 'default_permissions' mount option is given,$
ERROR: code indent should never use tabs
#3245: FILE: tools/virtiofsd/fuse_lowlevel.h:882:
+^I * this method is not called.$
ERROR: code indent should never use tabs
#3246: FILE: tools/virtiofsd/fuse_lowlevel.h:883:
+^I *$
ERROR: code indent should never use tabs
#3247: FILE: tools/virtiofsd/fuse_lowlevel.h:884:
+^I * This method is not called under Linux kernel versions 2.4.x$
ERROR: code indent should never use tabs
#3248: FILE: tools/virtiofsd/fuse_lowlevel.h:885:
+^I *$
ERROR: code indent should never use tabs
#3249: FILE: tools/virtiofsd/fuse_lowlevel.h:886:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3250: FILE: tools/virtiofsd/fuse_lowlevel.h:887:
+^I * treated as a permanent success, i.e. this and all future access()$
ERROR: code indent should never use tabs
#3251: FILE: tools/virtiofsd/fuse_lowlevel.h:888:
+^I * requests will succeed without being send to the filesystem process.$
ERROR: code indent should never use tabs
#3252: FILE: tools/virtiofsd/fuse_lowlevel.h:889:
+^I *$
ERROR: code indent should never use tabs
#3253: FILE: tools/virtiofsd/fuse_lowlevel.h:890:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3254: FILE: tools/virtiofsd/fuse_lowlevel.h:891:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3255: FILE: tools/virtiofsd/fuse_lowlevel.h:892:
+^I *$
ERROR: code indent should never use tabs
#3256: FILE: tools/virtiofsd/fuse_lowlevel.h:893:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3257: FILE: tools/virtiofsd/fuse_lowlevel.h:894:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3258: FILE: tools/virtiofsd/fuse_lowlevel.h:895:
+^I * @param mask requested access mode$
ERROR: code indent should never use tabs
#3259: FILE: tools/virtiofsd/fuse_lowlevel.h:896:
+^I */$
ERROR: code indent should never use tabs
#3260: FILE: tools/virtiofsd/fuse_lowlevel.h:897:
+^Ivoid (*access) (fuse_req_t req, fuse_ino_t ino, int mask);$
ERROR: code indent should never use tabs
#3262: FILE: tools/virtiofsd/fuse_lowlevel.h:899:
+^I/**$
ERROR: code indent should never use tabs
#3263: FILE: tools/virtiofsd/fuse_lowlevel.h:900:
+^I * Create and open a file$
ERROR: code indent should never use tabs
#3264: FILE: tools/virtiofsd/fuse_lowlevel.h:901:
+^I *$
ERROR: code indent should never use tabs
#3265: FILE: tools/virtiofsd/fuse_lowlevel.h:902:
+^I * If the file does not exist, first create it with the specified$
ERROR: code indent should never use tabs
#3266: FILE: tools/virtiofsd/fuse_lowlevel.h:903:
+^I * mode, and then open it.$
ERROR: code indent should never use tabs
#3267: FILE: tools/virtiofsd/fuse_lowlevel.h:904:
+^I *$
ERROR: code indent should never use tabs
#3268: FILE: tools/virtiofsd/fuse_lowlevel.h:905:
+^I * See the description of the open handler for more$
ERROR: code indent should never use tabs
#3269: FILE: tools/virtiofsd/fuse_lowlevel.h:906:
+^I * information.$
ERROR: code indent should never use tabs
#3270: FILE: tools/virtiofsd/fuse_lowlevel.h:907:
+^I *$
ERROR: code indent should never use tabs
#3271: FILE: tools/virtiofsd/fuse_lowlevel.h:908:
+^I * If this method is not implemented or under Linux kernel$
ERROR: code indent should never use tabs
#3272: FILE: tools/virtiofsd/fuse_lowlevel.h:909:
+^I * versions earlier than 2.6.15, the mknod() and open() methods$
ERROR: code indent should never use tabs
#3273: FILE: tools/virtiofsd/fuse_lowlevel.h:910:
+^I * will be called instead.$
ERROR: code indent should never use tabs
#3274: FILE: tools/virtiofsd/fuse_lowlevel.h:911:
+^I *$
ERROR: code indent should never use tabs
#3275: FILE: tools/virtiofsd/fuse_lowlevel.h:912:
+^I * If this request is answered with an error code of ENOSYS, the handler$
ERROR: code indent should never use tabs
#3276: FILE: tools/virtiofsd/fuse_lowlevel.h:913:
+^I * is treated as not implemented (i.e., for this and future requests the$
ERROR: code indent should never use tabs
#3277: FILE: tools/virtiofsd/fuse_lowlevel.h:914:
+^I * mknod() and open() handlers will be called instead).$
ERROR: code indent should never use tabs
#3278: FILE: tools/virtiofsd/fuse_lowlevel.h:915:
+^I *$
ERROR: code indent should never use tabs
#3279: FILE: tools/virtiofsd/fuse_lowlevel.h:916:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3280: FILE: tools/virtiofsd/fuse_lowlevel.h:917:
+^I * fuse_reply_create$
ERROR: code indent should never use tabs
#3281: FILE: tools/virtiofsd/fuse_lowlevel.h:918:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3282: FILE: tools/virtiofsd/fuse_lowlevel.h:919:
+^I *$
ERROR: code indent should never use tabs
#3283: FILE: tools/virtiofsd/fuse_lowlevel.h:920:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3284: FILE: tools/virtiofsd/fuse_lowlevel.h:921:
+^I * @param parent inode number of the parent directory$
ERROR: code indent should never use tabs
#3285: FILE: tools/virtiofsd/fuse_lowlevel.h:922:
+^I * @param name to create$
ERROR: code indent should never use tabs
#3286: FILE: tools/virtiofsd/fuse_lowlevel.h:923:
+^I * @param mode file type and mode with which to create the new file$
ERROR: code indent should never use tabs
#3287: FILE: tools/virtiofsd/fuse_lowlevel.h:924:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3288: FILE: tools/virtiofsd/fuse_lowlevel.h:925:
+^I */$
ERROR: code indent should never use tabs
#3289: FILE: tools/virtiofsd/fuse_lowlevel.h:926:
+^Ivoid (*create) (fuse_req_t req, fuse_ino_t parent, const char *name,$
ERROR: code indent should never use tabs
#3290: FILE: tools/virtiofsd/fuse_lowlevel.h:927:
+^I^I^Imode_t mode, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3292: FILE: tools/virtiofsd/fuse_lowlevel.h:929:
+^I/**$
ERROR: code indent should never use tabs
#3293: FILE: tools/virtiofsd/fuse_lowlevel.h:930:
+^I * Test for a POSIX file lock$
ERROR: code indent should never use tabs
#3294: FILE: tools/virtiofsd/fuse_lowlevel.h:931:
+^I *$
ERROR: code indent should never use tabs
#3295: FILE: tools/virtiofsd/fuse_lowlevel.h:932:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3296: FILE: tools/virtiofsd/fuse_lowlevel.h:933:
+^I * fuse_reply_lock$
ERROR: code indent should never use tabs
#3297: FILE: tools/virtiofsd/fuse_lowlevel.h:934:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3298: FILE: tools/virtiofsd/fuse_lowlevel.h:935:
+^I *$
ERROR: code indent should never use tabs
#3299: FILE: tools/virtiofsd/fuse_lowlevel.h:936:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3300: FILE: tools/virtiofsd/fuse_lowlevel.h:937:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3301: FILE: tools/virtiofsd/fuse_lowlevel.h:938:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3302: FILE: tools/virtiofsd/fuse_lowlevel.h:939:
+^I * @param lock the region/type to test$
ERROR: code indent should never use tabs
#3303: FILE: tools/virtiofsd/fuse_lowlevel.h:940:
+^I */$
ERROR: code indent should never use tabs
#3304: FILE: tools/virtiofsd/fuse_lowlevel.h:941:
+^Ivoid (*getlk) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#3305: FILE: tools/virtiofsd/fuse_lowlevel.h:942:
+^I^I struct fuse_file_info *fi, struct flock *lock);$
ERROR: code indent should never use tabs
#3307: FILE: tools/virtiofsd/fuse_lowlevel.h:944:
+^I/**$
ERROR: code indent should never use tabs
#3308: FILE: tools/virtiofsd/fuse_lowlevel.h:945:
+^I * Acquire, modify or release a POSIX file lock$
ERROR: code indent should never use tabs
#3309: FILE: tools/virtiofsd/fuse_lowlevel.h:946:
+^I *$
ERROR: code indent should never use tabs
#3310: FILE: tools/virtiofsd/fuse_lowlevel.h:947:
+^I * For POSIX threads (NPTL) there's a 1-1 relation between pid and$
ERROR: code indent should never use tabs
#3311: FILE: tools/virtiofsd/fuse_lowlevel.h:948:
+^I * owner, but otherwise this is not always the case. For checking$
ERROR: code indent should never use tabs
#3312: FILE: tools/virtiofsd/fuse_lowlevel.h:949:
+^I * lock ownership, 'fi->owner' must be used. The l_pid field in$
ERROR: code indent should never use tabs
#3313: FILE: tools/virtiofsd/fuse_lowlevel.h:950:
+^I * 'struct flock' should only be used to fill in this field in$
ERROR: code indent should never use tabs
#3314: FILE: tools/virtiofsd/fuse_lowlevel.h:951:
+^I * getlk().$
ERROR: code indent should never use tabs
#3315: FILE: tools/virtiofsd/fuse_lowlevel.h:952:
+^I *$
ERROR: code indent should never use tabs
#3316: FILE: tools/virtiofsd/fuse_lowlevel.h:953:
+^I * Note: if the locking methods are not implemented, the kernel$
ERROR: code indent should never use tabs
#3317: FILE: tools/virtiofsd/fuse_lowlevel.h:954:
+^I * will still allow file locking to work locally. Hence these are$
ERROR: code indent should never use tabs
#3318: FILE: tools/virtiofsd/fuse_lowlevel.h:955:
+^I * only interesting for network filesystems and similar.$
ERROR: code indent should never use tabs
#3319: FILE: tools/virtiofsd/fuse_lowlevel.h:956:
+^I *$
ERROR: code indent should never use tabs
#3320: FILE: tools/virtiofsd/fuse_lowlevel.h:957:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3321: FILE: tools/virtiofsd/fuse_lowlevel.h:958:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3322: FILE: tools/virtiofsd/fuse_lowlevel.h:959:
+^I *$
ERROR: code indent should never use tabs
#3323: FILE: tools/virtiofsd/fuse_lowlevel.h:960:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3324: FILE: tools/virtiofsd/fuse_lowlevel.h:961:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3325: FILE: tools/virtiofsd/fuse_lowlevel.h:962:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3326: FILE: tools/virtiofsd/fuse_lowlevel.h:963:
+^I * @param lock the region/type to set$
ERROR: code indent should never use tabs
#3327: FILE: tools/virtiofsd/fuse_lowlevel.h:964:
+^I * @param sleep locking operation may sleep$
ERROR: code indent should never use tabs
#3328: FILE: tools/virtiofsd/fuse_lowlevel.h:965:
+^I */$
ERROR: code indent should never use tabs
#3329: FILE: tools/virtiofsd/fuse_lowlevel.h:966:
+^Ivoid (*setlk) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#3330: FILE: tools/virtiofsd/fuse_lowlevel.h:967:
+^I^I struct fuse_file_info *fi,$
ERROR: code indent should never use tabs
#3331: FILE: tools/virtiofsd/fuse_lowlevel.h:968:
+^I^I struct flock *lock, int sleep);$
ERROR: code indent should never use tabs
#3333: FILE: tools/virtiofsd/fuse_lowlevel.h:970:
+^I/**$
ERROR: code indent should never use tabs
#3334: FILE: tools/virtiofsd/fuse_lowlevel.h:971:
+^I * Map block index within file to block index within device$
ERROR: code indent should never use tabs
#3335: FILE: tools/virtiofsd/fuse_lowlevel.h:972:
+^I *$
ERROR: code indent should never use tabs
#3336: FILE: tools/virtiofsd/fuse_lowlevel.h:973:
+^I * Note: This makes sense only for block device backed filesystems$
ERROR: code indent should never use tabs
#3337: FILE: tools/virtiofsd/fuse_lowlevel.h:974:
+^I * mounted with the 'blkdev' option$
ERROR: code indent should never use tabs
#3338: FILE: tools/virtiofsd/fuse_lowlevel.h:975:
+^I *$
ERROR: code indent should never use tabs
#3339: FILE: tools/virtiofsd/fuse_lowlevel.h:976:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3340: FILE: tools/virtiofsd/fuse_lowlevel.h:977:
+^I * treated as a permanent failure, i.e. all future bmap() requests will$
ERROR: code indent should never use tabs
#3341: FILE: tools/virtiofsd/fuse_lowlevel.h:978:
+^I * fail with the same error code without being send to the filesystem$
ERROR: code indent should never use tabs
#3342: FILE: tools/virtiofsd/fuse_lowlevel.h:979:
+^I * process.$
ERROR: code indent should never use tabs
#3343: FILE: tools/virtiofsd/fuse_lowlevel.h:980:
+^I *$
ERROR: code indent should never use tabs
#3344: FILE: tools/virtiofsd/fuse_lowlevel.h:981:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3345: FILE: tools/virtiofsd/fuse_lowlevel.h:982:
+^I * fuse_reply_bmap$
ERROR: code indent should never use tabs
#3346: FILE: tools/virtiofsd/fuse_lowlevel.h:983:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3347: FILE: tools/virtiofsd/fuse_lowlevel.h:984:
+^I *$
ERROR: code indent should never use tabs
#3348: FILE: tools/virtiofsd/fuse_lowlevel.h:985:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3349: FILE: tools/virtiofsd/fuse_lowlevel.h:986:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3350: FILE: tools/virtiofsd/fuse_lowlevel.h:987:
+^I * @param blocksize unit of block index$
ERROR: code indent should never use tabs
#3351: FILE: tools/virtiofsd/fuse_lowlevel.h:988:
+^I * @param idx block index within file$
ERROR: code indent should never use tabs
#3352: FILE: tools/virtiofsd/fuse_lowlevel.h:989:
+^I */$
ERROR: code indent should never use tabs
#3353: FILE: tools/virtiofsd/fuse_lowlevel.h:990:
+^Ivoid (*bmap) (fuse_req_t req, fuse_ino_t ino, size_t blocksize,$
ERROR: code indent should never use tabs
#3354: FILE: tools/virtiofsd/fuse_lowlevel.h:991:
+^I^I uint64_t idx);$
ERROR: code indent should never use tabs
#3356: FILE: tools/virtiofsd/fuse_lowlevel.h:993:
+^I/**$
ERROR: code indent should never use tabs
#3357: FILE: tools/virtiofsd/fuse_lowlevel.h:994:
+^I * Ioctl$
ERROR: code indent should never use tabs
#3358: FILE: tools/virtiofsd/fuse_lowlevel.h:995:
+^I *$
ERROR: code indent should never use tabs
#3359: FILE: tools/virtiofsd/fuse_lowlevel.h:996:
+^I * Note: For unrestricted ioctls (not allowed for FUSE$
ERROR: code indent should never use tabs
#3360: FILE: tools/virtiofsd/fuse_lowlevel.h:997:
+^I * servers), data in and out areas can be discovered by giving$
ERROR: code indent should never use tabs
#3361: FILE: tools/virtiofsd/fuse_lowlevel.h:998:
+^I * iovs and setting FUSE_IOCTL_RETRY in *flags*. For$
ERROR: code indent should never use tabs
#3362: FILE: tools/virtiofsd/fuse_lowlevel.h:999:
+^I * restricted ioctls, kernel prepares in/out data area$
ERROR: code indent should never use tabs
#3363: FILE: tools/virtiofsd/fuse_lowlevel.h:1000:
+^I * according to the information encoded in cmd.$
ERROR: code indent should never use tabs
#3364: FILE: tools/virtiofsd/fuse_lowlevel.h:1001:
+^I *$
ERROR: code indent should never use tabs
#3365: FILE: tools/virtiofsd/fuse_lowlevel.h:1002:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3366: FILE: tools/virtiofsd/fuse_lowlevel.h:1003:
+^I * fuse_reply_ioctl_retry$
ERROR: code indent should never use tabs
#3367: FILE: tools/virtiofsd/fuse_lowlevel.h:1004:
+^I * fuse_reply_ioctl$
ERROR: code indent should never use tabs
#3368: FILE: tools/virtiofsd/fuse_lowlevel.h:1005:
+^I * fuse_reply_ioctl_iov$
ERROR: code indent should never use tabs
#3369: FILE: tools/virtiofsd/fuse_lowlevel.h:1006:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3370: FILE: tools/virtiofsd/fuse_lowlevel.h:1007:
+^I *$
ERROR: code indent should never use tabs
#3371: FILE: tools/virtiofsd/fuse_lowlevel.h:1008:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3372: FILE: tools/virtiofsd/fuse_lowlevel.h:1009:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3373: FILE: tools/virtiofsd/fuse_lowlevel.h:1010:
+^I * @param cmd ioctl command$
ERROR: code indent should never use tabs
#3374: FILE: tools/virtiofsd/fuse_lowlevel.h:1011:
+^I * @param arg ioctl argument$
ERROR: code indent should never use tabs
#3375: FILE: tools/virtiofsd/fuse_lowlevel.h:1012:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3376: FILE: tools/virtiofsd/fuse_lowlevel.h:1013:
+^I * @param flags for FUSE_IOCTL_* flags$
ERROR: code indent should never use tabs
#3377: FILE: tools/virtiofsd/fuse_lowlevel.h:1014:
+^I * @param in_buf data fetched from the caller$
ERROR: code indent should never use tabs
#3378: FILE: tools/virtiofsd/fuse_lowlevel.h:1015:
+^I * @param in_bufsz number of fetched bytes$
ERROR: code indent should never use tabs
#3379: FILE: tools/virtiofsd/fuse_lowlevel.h:1016:
+^I * @param out_bufsz maximum size of output data$
ERROR: code indent should never use tabs
#3380: FILE: tools/virtiofsd/fuse_lowlevel.h:1017:
+^I *$
ERROR: code indent should never use tabs
#3381: FILE: tools/virtiofsd/fuse_lowlevel.h:1018:
+^I * Note : the unsigned long request submitted by the application$
ERROR: code indent should never use tabs
#3382: FILE: tools/virtiofsd/fuse_lowlevel.h:1019:
+^I * is truncated to 32 bits.$
ERROR: code indent should never use tabs
#3383: FILE: tools/virtiofsd/fuse_lowlevel.h:1020:
+^I */$
ERROR: code indent should never use tabs
#3384: FILE: tools/virtiofsd/fuse_lowlevel.h:1021:
+^Ivoid (*ioctl) (fuse_req_t req, fuse_ino_t ino, unsigned int cmd,$
ERROR: code indent should never use tabs
#3385: FILE: tools/virtiofsd/fuse_lowlevel.h:1022:
+^I^I void *arg, struct fuse_file_info *fi, unsigned flags,$
ERROR: code indent should never use tabs
#3386: FILE: tools/virtiofsd/fuse_lowlevel.h:1023:
+^I^I const void *in_buf, size_t in_bufsz, size_t out_bufsz);$
ERROR: code indent should never use tabs
#3388: FILE: tools/virtiofsd/fuse_lowlevel.h:1025:
+^I/**$
ERROR: code indent should never use tabs
#3389: FILE: tools/virtiofsd/fuse_lowlevel.h:1026:
+^I * Poll for IO readiness$
ERROR: code indent should never use tabs
#3390: FILE: tools/virtiofsd/fuse_lowlevel.h:1027:
+^I *$
ERROR: code indent should never use tabs
#3391: FILE: tools/virtiofsd/fuse_lowlevel.h:1028:
+^I * Note: If ph is non-NULL, the client should notify$
ERROR: code indent should never use tabs
#3392: FILE: tools/virtiofsd/fuse_lowlevel.h:1029:
+^I * when IO readiness events occur by calling$
ERROR: code indent should never use tabs
#3393: FILE: tools/virtiofsd/fuse_lowlevel.h:1030:
+^I * fuse_lowlevel_notify_poll() with the specified ph.$
ERROR: code indent should never use tabs
#3394: FILE: tools/virtiofsd/fuse_lowlevel.h:1031:
+^I *$
ERROR: code indent should never use tabs
#3395: FILE: tools/virtiofsd/fuse_lowlevel.h:1032:
+^I * Regardless of the number of times poll with a non-NULL ph$
ERROR: code indent should never use tabs
#3396: FILE: tools/virtiofsd/fuse_lowlevel.h:1033:
+^I * is received, single notification is enough to clear all.$
ERROR: code indent should never use tabs
#3397: FILE: tools/virtiofsd/fuse_lowlevel.h:1034:
+^I * Notifying more times incurs overhead but doesn't harm$
ERROR: code indent should never use tabs
#3398: FILE: tools/virtiofsd/fuse_lowlevel.h:1035:
+^I * correctness.$
ERROR: code indent should never use tabs
#3399: FILE: tools/virtiofsd/fuse_lowlevel.h:1036:
+^I *$
ERROR: code indent should never use tabs
#3400: FILE: tools/virtiofsd/fuse_lowlevel.h:1037:
+^I * The callee is responsible for destroying ph with$
ERROR: code indent should never use tabs
#3401: FILE: tools/virtiofsd/fuse_lowlevel.h:1038:
+^I * fuse_pollhandle_destroy() when no longer in use.$
ERROR: code indent should never use tabs
#3402: FILE: tools/virtiofsd/fuse_lowlevel.h:1039:
+^I *$
ERROR: code indent should never use tabs
#3403: FILE: tools/virtiofsd/fuse_lowlevel.h:1040:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3404: FILE: tools/virtiofsd/fuse_lowlevel.h:1041:
+^I * treated as success (with a kernel-defined default poll-mask) and$
ERROR: code indent should never use tabs
#3405: FILE: tools/virtiofsd/fuse_lowlevel.h:1042:
+^I * future calls to pull() will succeed the same way without being send$
ERROR: code indent should never use tabs
#3406: FILE: tools/virtiofsd/fuse_lowlevel.h:1043:
+^I * to the filesystem process.$
ERROR: code indent should never use tabs
#3407: FILE: tools/virtiofsd/fuse_lowlevel.h:1044:
+^I *$
ERROR: code indent should never use tabs
#3408: FILE: tools/virtiofsd/fuse_lowlevel.h:1045:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3409: FILE: tools/virtiofsd/fuse_lowlevel.h:1046:
+^I * fuse_reply_poll$
ERROR: code indent should never use tabs
#3410: FILE: tools/virtiofsd/fuse_lowlevel.h:1047:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3411: FILE: tools/virtiofsd/fuse_lowlevel.h:1048:
+^I *$
ERROR: code indent should never use tabs
#3412: FILE: tools/virtiofsd/fuse_lowlevel.h:1049:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3413: FILE: tools/virtiofsd/fuse_lowlevel.h:1050:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3414: FILE: tools/virtiofsd/fuse_lowlevel.h:1051:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3415: FILE: tools/virtiofsd/fuse_lowlevel.h:1052:
+^I * @param ph poll handle to be used for notification$
ERROR: code indent should never use tabs
#3416: FILE: tools/virtiofsd/fuse_lowlevel.h:1053:
+^I */$
ERROR: code indent should never use tabs
#3417: FILE: tools/virtiofsd/fuse_lowlevel.h:1054:
+^Ivoid (*poll) (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi,$
ERROR: code indent should never use tabs
#3418: FILE: tools/virtiofsd/fuse_lowlevel.h:1055:
+^I^I struct fuse_pollhandle *ph);$
ERROR: code indent should never use tabs
#3420: FILE: tools/virtiofsd/fuse_lowlevel.h:1057:
+^I/**$
ERROR: code indent should never use tabs
#3421: FILE: tools/virtiofsd/fuse_lowlevel.h:1058:
+^I * Write data made available in a buffer$
ERROR: code indent should never use tabs
#3422: FILE: tools/virtiofsd/fuse_lowlevel.h:1059:
+^I *$
ERROR: code indent should never use tabs
#3423: FILE: tools/virtiofsd/fuse_lowlevel.h:1060:
+^I * This is a more generic version of the ->write() method. If$
ERROR: code indent should never use tabs
#3424: FILE: tools/virtiofsd/fuse_lowlevel.h:1061:
+^I * FUSE_CAP_SPLICE_READ is set in fuse_conn_info.want and the$
ERROR: code indent should never use tabs
#3425: FILE: tools/virtiofsd/fuse_lowlevel.h:1062:
+^I * kernel supports splicing from the fuse device, then the$
ERROR: code indent should never use tabs
#3426: FILE: tools/virtiofsd/fuse_lowlevel.h:1063:
+^I * data will be made available in pipe for supporting zero$
ERROR: code indent should never use tabs
#3427: FILE: tools/virtiofsd/fuse_lowlevel.h:1064:
+^I * copy data transfer.$
ERROR: code indent should never use tabs
#3428: FILE: tools/virtiofsd/fuse_lowlevel.h:1065:
+^I *$
ERROR: code indent should never use tabs
#3429: FILE: tools/virtiofsd/fuse_lowlevel.h:1066:
+^I * buf->count is guaranteed to be one (and thus buf->idx is$
ERROR: code indent should never use tabs
#3430: FILE: tools/virtiofsd/fuse_lowlevel.h:1067:
+^I * always zero). The write_buf handler must ensure that$
ERROR: code indent should never use tabs
#3431: FILE: tools/virtiofsd/fuse_lowlevel.h:1068:
+^I * bufv->off is correctly updated (reflecting the number of$
ERROR: code indent should never use tabs
#3432: FILE: tools/virtiofsd/fuse_lowlevel.h:1069:
+^I * bytes read from bufv->buf[0]).$
ERROR: code indent should never use tabs
#3433: FILE: tools/virtiofsd/fuse_lowlevel.h:1070:
+^I *$
ERROR: code indent should never use tabs
#3434: FILE: tools/virtiofsd/fuse_lowlevel.h:1071:
+^I * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is$
ERROR: code indent should never use tabs
#3435: FILE: tools/virtiofsd/fuse_lowlevel.h:1072:
+^I * expected to reset the setuid and setgid bits.$
ERROR: code indent should never use tabs
#3436: FILE: tools/virtiofsd/fuse_lowlevel.h:1073:
+^I *$
ERROR: code indent should never use tabs
#3437: FILE: tools/virtiofsd/fuse_lowlevel.h:1074:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3438: FILE: tools/virtiofsd/fuse_lowlevel.h:1075:
+^I * fuse_reply_write$
ERROR: code indent should never use tabs
#3439: FILE: tools/virtiofsd/fuse_lowlevel.h:1076:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3440: FILE: tools/virtiofsd/fuse_lowlevel.h:1077:
+^I *$
ERROR: code indent should never use tabs
#3441: FILE: tools/virtiofsd/fuse_lowlevel.h:1078:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3442: FILE: tools/virtiofsd/fuse_lowlevel.h:1079:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3443: FILE: tools/virtiofsd/fuse_lowlevel.h:1080:
+^I * @param bufv buffer containing the data$
ERROR: code indent should never use tabs
#3444: FILE: tools/virtiofsd/fuse_lowlevel.h:1081:
+^I * @param off offset to write to$
ERROR: code indent should never use tabs
#3445: FILE: tools/virtiofsd/fuse_lowlevel.h:1082:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3446: FILE: tools/virtiofsd/fuse_lowlevel.h:1083:
+^I */$
ERROR: code indent should never use tabs
#3447: FILE: tools/virtiofsd/fuse_lowlevel.h:1084:
+^Ivoid (*write_buf) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#3448: FILE: tools/virtiofsd/fuse_lowlevel.h:1085:
+^I^I^I struct fuse_bufvec *bufv, off_t off,$
ERROR: code indent should never use tabs
#3449: FILE: tools/virtiofsd/fuse_lowlevel.h:1086:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3451: FILE: tools/virtiofsd/fuse_lowlevel.h:1088:
+^I/**$
ERROR: code indent should never use tabs
#3452: FILE: tools/virtiofsd/fuse_lowlevel.h:1089:
+^I * Callback function for the retrieve request$
ERROR: code indent should never use tabs
#3453: FILE: tools/virtiofsd/fuse_lowlevel.h:1090:
+^I *$
ERROR: code indent should never use tabs
#3454: FILE: tools/virtiofsd/fuse_lowlevel.h:1091:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3455: FILE: tools/virtiofsd/fuse_lowlevel.h:1092:
+^I *^Ifuse_reply_none$
ERROR: code indent should never use tabs
#3456: FILE: tools/virtiofsd/fuse_lowlevel.h:1093:
+^I *$
ERROR: code indent should never use tabs
#3457: FILE: tools/virtiofsd/fuse_lowlevel.h:1094:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3458: FILE: tools/virtiofsd/fuse_lowlevel.h:1095:
+^I * @param cookie user data supplied to fuse_lowlevel_notify_retrieve()$
WARNING: line over 80 characters
#3459: FILE: tools/virtiofsd/fuse_lowlevel.h:1096:
+ * @param ino the inode number supplied to fuse_lowlevel_notify_retrieve()
ERROR: code indent should never use tabs
#3459: FILE: tools/virtiofsd/fuse_lowlevel.h:1096:
+^I * @param ino the inode number supplied to fuse_lowlevel_notify_retrieve()$
ERROR: code indent should never use tabs
#3460: FILE: tools/virtiofsd/fuse_lowlevel.h:1097:
+^I * @param offset the offset supplied to fuse_lowlevel_notify_retrieve()$
ERROR: code indent should never use tabs
#3461: FILE: tools/virtiofsd/fuse_lowlevel.h:1098:
+^I * @param bufv the buffer containing the returned data$
ERROR: code indent should never use tabs
#3462: FILE: tools/virtiofsd/fuse_lowlevel.h:1099:
+^I */$
ERROR: code indent should never use tabs
#3463: FILE: tools/virtiofsd/fuse_lowlevel.h:1100:
+^Ivoid (*retrieve_reply) (fuse_req_t req, void *cookie, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#3464: FILE: tools/virtiofsd/fuse_lowlevel.h:1101:
+^I^I^I^Ioff_t offset, struct fuse_bufvec *bufv);$
ERROR: code indent should never use tabs
#3466: FILE: tools/virtiofsd/fuse_lowlevel.h:1103:
+^I/**$
ERROR: code indent should never use tabs
#3467: FILE: tools/virtiofsd/fuse_lowlevel.h:1104:
+^I * Forget about multiple inodes$
ERROR: code indent should never use tabs
#3468: FILE: tools/virtiofsd/fuse_lowlevel.h:1105:
+^I *$
ERROR: code indent should never use tabs
#3469: FILE: tools/virtiofsd/fuse_lowlevel.h:1106:
+^I * See description of the forget function for more$
ERROR: code indent should never use tabs
#3470: FILE: tools/virtiofsd/fuse_lowlevel.h:1107:
+^I * information.$
ERROR: code indent should never use tabs
#3471: FILE: tools/virtiofsd/fuse_lowlevel.h:1108:
+^I *$
ERROR: code indent should never use tabs
#3472: FILE: tools/virtiofsd/fuse_lowlevel.h:1109:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3473: FILE: tools/virtiofsd/fuse_lowlevel.h:1110:
+^I * fuse_reply_none$
ERROR: code indent should never use tabs
#3474: FILE: tools/virtiofsd/fuse_lowlevel.h:1111:
+^I *$
ERROR: code indent should never use tabs
#3475: FILE: tools/virtiofsd/fuse_lowlevel.h:1112:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3476: FILE: tools/virtiofsd/fuse_lowlevel.h:1113:
+^I */$
ERROR: code indent should never use tabs
#3477: FILE: tools/virtiofsd/fuse_lowlevel.h:1114:
+^Ivoid (*forget_multi) (fuse_req_t req, size_t count,$
ERROR: code indent should never use tabs
#3478: FILE: tools/virtiofsd/fuse_lowlevel.h:1115:
+^I^I^I struct fuse_forget_data *forgets);$
ERROR: code indent should never use tabs
#3480: FILE: tools/virtiofsd/fuse_lowlevel.h:1117:
+^I/**$
ERROR: code indent should never use tabs
#3481: FILE: tools/virtiofsd/fuse_lowlevel.h:1118:
+^I * Acquire, modify or release a BSD file lock$
ERROR: code indent should never use tabs
#3482: FILE: tools/virtiofsd/fuse_lowlevel.h:1119:
+^I *$
ERROR: code indent should never use tabs
#3483: FILE: tools/virtiofsd/fuse_lowlevel.h:1120:
+^I * Note: if the locking methods are not implemented, the kernel$
ERROR: code indent should never use tabs
#3484: FILE: tools/virtiofsd/fuse_lowlevel.h:1121:
+^I * will still allow file locking to work locally. Hence these are$
ERROR: code indent should never use tabs
#3485: FILE: tools/virtiofsd/fuse_lowlevel.h:1122:
+^I * only interesting for network filesystems and similar.$
ERROR: code indent should never use tabs
#3486: FILE: tools/virtiofsd/fuse_lowlevel.h:1123:
+^I *$
ERROR: code indent should never use tabs
#3487: FILE: tools/virtiofsd/fuse_lowlevel.h:1124:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3488: FILE: tools/virtiofsd/fuse_lowlevel.h:1125:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3489: FILE: tools/virtiofsd/fuse_lowlevel.h:1126:
+^I *$
ERROR: code indent should never use tabs
#3490: FILE: tools/virtiofsd/fuse_lowlevel.h:1127:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3491: FILE: tools/virtiofsd/fuse_lowlevel.h:1128:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3492: FILE: tools/virtiofsd/fuse_lowlevel.h:1129:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3493: FILE: tools/virtiofsd/fuse_lowlevel.h:1130:
+^I * @param op the locking operation, see flock(2)$
ERROR: code indent should never use tabs
#3494: FILE: tools/virtiofsd/fuse_lowlevel.h:1131:
+^I */$
ERROR: code indent should never use tabs
#3495: FILE: tools/virtiofsd/fuse_lowlevel.h:1132:
+^Ivoid (*flock) (fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#3496: FILE: tools/virtiofsd/fuse_lowlevel.h:1133:
+^I^I struct fuse_file_info *fi, int op);$
ERROR: code indent should never use tabs
#3498: FILE: tools/virtiofsd/fuse_lowlevel.h:1135:
+^I/**$
ERROR: code indent should never use tabs
#3499: FILE: tools/virtiofsd/fuse_lowlevel.h:1136:
+^I * Allocate requested space. If this function returns success then$
WARNING: line over 80 characters
#3500: FILE: tools/virtiofsd/fuse_lowlevel.h:1137:
+ * subsequent writes to the specified range shall not fail due to the lack
ERROR: code indent should never use tabs
#3500: FILE: tools/virtiofsd/fuse_lowlevel.h:1137:
+^I * subsequent writes to the specified range shall not fail due to the lack$
ERROR: code indent should never use tabs
#3501: FILE: tools/virtiofsd/fuse_lowlevel.h:1138:
+^I * of free space on the file system storage media.$
ERROR: code indent should never use tabs
#3502: FILE: tools/virtiofsd/fuse_lowlevel.h:1139:
+^I *$
ERROR: code indent should never use tabs
#3503: FILE: tools/virtiofsd/fuse_lowlevel.h:1140:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3504: FILE: tools/virtiofsd/fuse_lowlevel.h:1141:
+^I * treated as a permanent failure with error code EOPNOTSUPP, i.e. all$
ERROR: code indent should never use tabs
#3505: FILE: tools/virtiofsd/fuse_lowlevel.h:1142:
+^I * future fallocate() requests will fail with EOPNOTSUPP without being$
ERROR: code indent should never use tabs
#3506: FILE: tools/virtiofsd/fuse_lowlevel.h:1143:
+^I * send to the filesystem process.$
ERROR: code indent should never use tabs
#3507: FILE: tools/virtiofsd/fuse_lowlevel.h:1144:
+^I *$
ERROR: code indent should never use tabs
#3508: FILE: tools/virtiofsd/fuse_lowlevel.h:1145:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3509: FILE: tools/virtiofsd/fuse_lowlevel.h:1146:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3510: FILE: tools/virtiofsd/fuse_lowlevel.h:1147:
+^I *$
ERROR: code indent should never use tabs
#3511: FILE: tools/virtiofsd/fuse_lowlevel.h:1148:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3512: FILE: tools/virtiofsd/fuse_lowlevel.h:1149:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3513: FILE: tools/virtiofsd/fuse_lowlevel.h:1150:
+^I * @param offset starting point for allocated region$
ERROR: code indent should never use tabs
#3514: FILE: tools/virtiofsd/fuse_lowlevel.h:1151:
+^I * @param length size of allocated region$
WARNING: line over 80 characters
#3515: FILE: tools/virtiofsd/fuse_lowlevel.h:1152:
+ * @param mode determines the operation to be performed on the given range,
ERROR: code indent should never use tabs
#3515: FILE: tools/virtiofsd/fuse_lowlevel.h:1152:
+^I * @param mode determines the operation to be performed on the given range,$
ERROR: code indent should never use tabs
#3516: FILE: tools/virtiofsd/fuse_lowlevel.h:1153:
+^I * see fallocate(2)$
ERROR: code indent should never use tabs
#3517: FILE: tools/virtiofsd/fuse_lowlevel.h:1154:
+^I */$
ERROR: code indent should never use tabs
#3518: FILE: tools/virtiofsd/fuse_lowlevel.h:1155:
+^Ivoid (*fallocate) (fuse_req_t req, fuse_ino_t ino, int mode,$
ERROR: code indent should never use tabs
#3519: FILE: tools/virtiofsd/fuse_lowlevel.h:1156:
+^I^I off_t offset, off_t length, struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3521: FILE: tools/virtiofsd/fuse_lowlevel.h:1158:
+^I/**$
ERROR: code indent should never use tabs
#3522: FILE: tools/virtiofsd/fuse_lowlevel.h:1159:
+^I * Read directory with attributes$
ERROR: code indent should never use tabs
#3523: FILE: tools/virtiofsd/fuse_lowlevel.h:1160:
+^I *$
ERROR: code indent should never use tabs
#3524: FILE: tools/virtiofsd/fuse_lowlevel.h:1161:
+^I * Send a buffer filled using fuse_add_direntry_plus(), with size not$
ERROR: code indent should never use tabs
#3525: FILE: tools/virtiofsd/fuse_lowlevel.h:1162:
+^I * exceeding the requested size. Send an empty buffer on end of$
ERROR: code indent should never use tabs
#3526: FILE: tools/virtiofsd/fuse_lowlevel.h:1163:
+^I * stream.$
ERROR: code indent should never use tabs
#3527: FILE: tools/virtiofsd/fuse_lowlevel.h:1164:
+^I *$
ERROR: code indent should never use tabs
#3528: FILE: tools/virtiofsd/fuse_lowlevel.h:1165:
+^I * fi->fh will contain the value set by the opendir method, or$
ERROR: code indent should never use tabs
#3529: FILE: tools/virtiofsd/fuse_lowlevel.h:1166:
+^I * will be undefined if the opendir method didn't set any value.$
ERROR: code indent should never use tabs
#3530: FILE: tools/virtiofsd/fuse_lowlevel.h:1167:
+^I *$
ERROR: code indent should never use tabs
#3531: FILE: tools/virtiofsd/fuse_lowlevel.h:1168:
+^I * In contrast to readdir() (which does not affect the lookup counts),$
ERROR: code indent should never use tabs
#3532: FILE: tools/virtiofsd/fuse_lowlevel.h:1169:
+^I * the lookup count of every entry returned by readdirplus(), except "."$
ERROR: code indent should never use tabs
#3533: FILE: tools/virtiofsd/fuse_lowlevel.h:1170:
+^I * and "..", is incremented by one.$
ERROR: code indent should never use tabs
#3534: FILE: tools/virtiofsd/fuse_lowlevel.h:1171:
+^I *$
ERROR: code indent should never use tabs
#3535: FILE: tools/virtiofsd/fuse_lowlevel.h:1172:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3536: FILE: tools/virtiofsd/fuse_lowlevel.h:1173:
+^I * fuse_reply_buf$
ERROR: code indent should never use tabs
#3537: FILE: tools/virtiofsd/fuse_lowlevel.h:1174:
+^I * fuse_reply_data$
ERROR: code indent should never use tabs
#3538: FILE: tools/virtiofsd/fuse_lowlevel.h:1175:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3539: FILE: tools/virtiofsd/fuse_lowlevel.h:1176:
+^I *$
ERROR: code indent should never use tabs
#3540: FILE: tools/virtiofsd/fuse_lowlevel.h:1177:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3541: FILE: tools/virtiofsd/fuse_lowlevel.h:1178:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3542: FILE: tools/virtiofsd/fuse_lowlevel.h:1179:
+^I * @param size maximum number of bytes to send$
ERROR: code indent should never use tabs
#3543: FILE: tools/virtiofsd/fuse_lowlevel.h:1180:
+^I * @param off offset to continue reading the directory stream$
ERROR: code indent should never use tabs
#3544: FILE: tools/virtiofsd/fuse_lowlevel.h:1181:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3545: FILE: tools/virtiofsd/fuse_lowlevel.h:1182:
+^I */$
WARNING: line over 80 characters
#3546: FILE: tools/virtiofsd/fuse_lowlevel.h:1183:
+ void (*readdirplus) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
ERROR: code indent should never use tabs
#3546: FILE: tools/virtiofsd/fuse_lowlevel.h:1183:
+^Ivoid (*readdirplus) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,$
ERROR: code indent should never use tabs
#3547: FILE: tools/virtiofsd/fuse_lowlevel.h:1184:
+^I^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3549: FILE: tools/virtiofsd/fuse_lowlevel.h:1186:
+^I/**$
ERROR: code indent should never use tabs
#3550: FILE: tools/virtiofsd/fuse_lowlevel.h:1187:
+^I * Copy a range of data from one file to another$
ERROR: code indent should never use tabs
#3551: FILE: tools/virtiofsd/fuse_lowlevel.h:1188:
+^I *$
ERROR: code indent should never use tabs
#3552: FILE: tools/virtiofsd/fuse_lowlevel.h:1189:
+^I * Performs an optimized copy between two file descriptors without the$
ERROR: code indent should never use tabs
#3553: FILE: tools/virtiofsd/fuse_lowlevel.h:1190:
+^I * additional cost of transferring data through the FUSE kernel module$
ERROR: code indent should never use tabs
#3554: FILE: tools/virtiofsd/fuse_lowlevel.h:1191:
+^I * to user space (glibc) and then back into the FUSE filesystem again.$
ERROR: code indent should never use tabs
#3555: FILE: tools/virtiofsd/fuse_lowlevel.h:1192:
+^I *$
ERROR: code indent should never use tabs
#3556: FILE: tools/virtiofsd/fuse_lowlevel.h:1193:
+^I * In case this method is not implemented, glibc falls back to reading$
ERROR: code indent should never use tabs
#3557: FILE: tools/virtiofsd/fuse_lowlevel.h:1194:
+^I * data from the source and writing to the destination. Effectively$
ERROR: code indent should never use tabs
#3558: FILE: tools/virtiofsd/fuse_lowlevel.h:1195:
+^I * doing an inefficient copy of the data.$
ERROR: code indent should never use tabs
#3559: FILE: tools/virtiofsd/fuse_lowlevel.h:1196:
+^I *$
ERROR: code indent should never use tabs
#3560: FILE: tools/virtiofsd/fuse_lowlevel.h:1197:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3561: FILE: tools/virtiofsd/fuse_lowlevel.h:1198:
+^I * treated as a permanent failure with error code EOPNOTSUPP, i.e. all$
ERROR: code indent should never use tabs
#3562: FILE: tools/virtiofsd/fuse_lowlevel.h:1199:
+^I * future copy_file_range() requests will fail with EOPNOTSUPP without$
ERROR: code indent should never use tabs
#3563: FILE: tools/virtiofsd/fuse_lowlevel.h:1200:
+^I * being send to the filesystem process.$
ERROR: code indent should never use tabs
#3564: FILE: tools/virtiofsd/fuse_lowlevel.h:1201:
+^I *$
ERROR: code indent should never use tabs
#3565: FILE: tools/virtiofsd/fuse_lowlevel.h:1202:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3566: FILE: tools/virtiofsd/fuse_lowlevel.h:1203:
+^I * fuse_reply_write$
ERROR: code indent should never use tabs
#3567: FILE: tools/virtiofsd/fuse_lowlevel.h:1204:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3568: FILE: tools/virtiofsd/fuse_lowlevel.h:1205:
+^I *$
ERROR: code indent should never use tabs
#3569: FILE: tools/virtiofsd/fuse_lowlevel.h:1206:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3570: FILE: tools/virtiofsd/fuse_lowlevel.h:1207:
+^I * @param ino_in the inode number or the source file$
ERROR: code indent should never use tabs
#3571: FILE: tools/virtiofsd/fuse_lowlevel.h:1208:
+^I * @param off_in starting point from were the data should be read$
ERROR: code indent should never use tabs
#3572: FILE: tools/virtiofsd/fuse_lowlevel.h:1209:
+^I * @param fi_in file information of the source file$
ERROR: code indent should never use tabs
#3573: FILE: tools/virtiofsd/fuse_lowlevel.h:1210:
+^I * @param ino_out the inode number or the destination file$
ERROR: code indent should never use tabs
#3574: FILE: tools/virtiofsd/fuse_lowlevel.h:1211:
+^I * @param off_out starting point where the data should be written$
ERROR: code indent should never use tabs
#3575: FILE: tools/virtiofsd/fuse_lowlevel.h:1212:
+^I * @param fi_out file information of the destination file$
ERROR: code indent should never use tabs
#3576: FILE: tools/virtiofsd/fuse_lowlevel.h:1213:
+^I * @param len maximum size of the data to copy$
ERROR: code indent should never use tabs
#3577: FILE: tools/virtiofsd/fuse_lowlevel.h:1214:
+^I * @param flags passed along with the copy_file_range() syscall$
ERROR: code indent should never use tabs
#3578: FILE: tools/virtiofsd/fuse_lowlevel.h:1215:
+^I */$
ERROR: code indent should never use tabs
#3579: FILE: tools/virtiofsd/fuse_lowlevel.h:1216:
+^Ivoid (*copy_file_range) (fuse_req_t req, fuse_ino_t ino_in,$
ERROR: code indent should never use tabs
#3580: FILE: tools/virtiofsd/fuse_lowlevel.h:1217:
+^I^I^I^I off_t off_in, struct fuse_file_info *fi_in,$
ERROR: code indent should never use tabs
#3581: FILE: tools/virtiofsd/fuse_lowlevel.h:1218:
+^I^I^I^I fuse_ino_t ino_out, off_t off_out,$
ERROR: code indent should never use tabs
#3582: FILE: tools/virtiofsd/fuse_lowlevel.h:1219:
+^I^I^I^I struct fuse_file_info *fi_out, size_t len,$
ERROR: code indent should never use tabs
#3583: FILE: tools/virtiofsd/fuse_lowlevel.h:1220:
+^I^I^I^I int flags);$
ERROR: code indent should never use tabs
#3585: FILE: tools/virtiofsd/fuse_lowlevel.h:1222:
+^I/**$
ERROR: code indent should never use tabs
#3586: FILE: tools/virtiofsd/fuse_lowlevel.h:1223:
+^I * Find next data or hole after the specified offset$
ERROR: code indent should never use tabs
#3587: FILE: tools/virtiofsd/fuse_lowlevel.h:1224:
+^I *$
ERROR: code indent should never use tabs
#3588: FILE: tools/virtiofsd/fuse_lowlevel.h:1225:
+^I * If this request is answered with an error code of ENOSYS, this is$
ERROR: code indent should never use tabs
#3589: FILE: tools/virtiofsd/fuse_lowlevel.h:1226:
+^I * treated as a permanent failure, i.e. all future lseek() requests will$
ERROR: code indent should never use tabs
#3590: FILE: tools/virtiofsd/fuse_lowlevel.h:1227:
+^I * fail with the same error code without being send to the filesystem$
ERROR: code indent should never use tabs
#3591: FILE: tools/virtiofsd/fuse_lowlevel.h:1228:
+^I * process.$
ERROR: code indent should never use tabs
#3592: FILE: tools/virtiofsd/fuse_lowlevel.h:1229:
+^I *$
ERROR: code indent should never use tabs
#3593: FILE: tools/virtiofsd/fuse_lowlevel.h:1230:
+^I * Valid replies:$
ERROR: code indent should never use tabs
#3594: FILE: tools/virtiofsd/fuse_lowlevel.h:1231:
+^I * fuse_reply_lseek$
ERROR: code indent should never use tabs
#3595: FILE: tools/virtiofsd/fuse_lowlevel.h:1232:
+^I * fuse_reply_err$
ERROR: code indent should never use tabs
#3596: FILE: tools/virtiofsd/fuse_lowlevel.h:1233:
+^I *$
ERROR: code indent should never use tabs
#3597: FILE: tools/virtiofsd/fuse_lowlevel.h:1234:
+^I * @param req request handle$
ERROR: code indent should never use tabs
#3598: FILE: tools/virtiofsd/fuse_lowlevel.h:1235:
+^I * @param ino the inode number$
ERROR: code indent should never use tabs
#3599: FILE: tools/virtiofsd/fuse_lowlevel.h:1236:
+^I * @param off offset to start search from$
ERROR: code indent should never use tabs
#3600: FILE: tools/virtiofsd/fuse_lowlevel.h:1237:
+^I * @param whence either SEEK_DATA or SEEK_HOLE$
ERROR: code indent should never use tabs
#3601: FILE: tools/virtiofsd/fuse_lowlevel.h:1238:
+^I * @param fi file information$
ERROR: code indent should never use tabs
#3602: FILE: tools/virtiofsd/fuse_lowlevel.h:1239:
+^I */$
ERROR: code indent should never use tabs
#3603: FILE: tools/virtiofsd/fuse_lowlevel.h:1240:
+^Ivoid (*lseek) (fuse_req_t req, fuse_ino_t ino, off_t off, int whence,$
ERROR: code indent should never use tabs
#3604: FILE: tools/virtiofsd/fuse_lowlevel.h:1241:
+^I^I struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3675: FILE: tools/virtiofsd/fuse_lowlevel.h:1312:
+^I^I const struct fuse_file_info *fi);$
ERROR: code indent should never use tabs
#3685: FILE: tools/virtiofsd/fuse_lowlevel.h:1322:
+ * @param attr_timeout^Ivalidity timeout (in seconds) for the attributes$
ERROR: code indent should never use tabs
#3689: FILE: tools/virtiofsd/fuse_lowlevel.h:1326:
+^I^I double attr_timeout);$
ERROR: code indent should never use tabs
#3787: FILE: tools/virtiofsd/fuse_lowlevel.h:1424:
+^I^I enum fuse_buf_copy_flags flags);$
WARNING: Block comments use a leading /* on a separate line
#3850: FILE: tools/virtiofsd/fuse_lowlevel.h:1487:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#3851: FILE: tools/virtiofsd/fuse_lowlevel.h:1488:
+ * Filling a buffer in readdir^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#3852: FILE: tools/virtiofsd/fuse_lowlevel.h:1489:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#3882: FILE: tools/virtiofsd/fuse_lowlevel.h:1519:
+^I^I^I const char *name, const struct stat *stbuf,$
ERROR: code indent should never use tabs
#3883: FILE: tools/virtiofsd/fuse_lowlevel.h:1520:
+^I^I^I off_t off);$
ERROR: code indent should never use tabs
#3899: FILE: tools/virtiofsd/fuse_lowlevel.h:1536:
+^I^I^I const char *name,$
ERROR: code indent should never use tabs
#3900: FILE: tools/virtiofsd/fuse_lowlevel.h:1537:
+^I^I^I const struct fuse_entry_param *e, off_t off);$
ERROR: code indent should never use tabs
#3918: FILE: tools/virtiofsd/fuse_lowlevel.h:1555:
+^I^I^I const struct iovec *in_iov, size_t in_count,$
ERROR: code indent should never use tabs
#3919: FILE: tools/virtiofsd/fuse_lowlevel.h:1556:
+^I^I^I const struct iovec *out_iov, size_t out_count);$
ERROR: code indent should never use tabs
#3946: FILE: tools/virtiofsd/fuse_lowlevel.h:1583:
+^I^I^I int count);$
WARNING: Block comments use a leading /* on a separate line
#3968: FILE: tools/virtiofsd/fuse_lowlevel.h:1605:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#3969: FILE: tools/virtiofsd/fuse_lowlevel.h:1606:
+ * Notification^I^I^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#3970: FILE: tools/virtiofsd/fuse_lowlevel.h:1607:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#4005: FILE: tools/virtiofsd/fuse_lowlevel.h:1642:
+^I^I^I^I off_t off, off_t len);$
ERROR: code indent should never use tabs
#4033: FILE: tools/virtiofsd/fuse_lowlevel.h:1670:
+^I^I^I^I const char *name, size_t namelen);$
ERROR: code indent should never use tabs
#4064: FILE: tools/virtiofsd/fuse_lowlevel.h:1701:
+^I^I^I^Ifuse_ino_t parent, fuse_ino_t child,$
ERROR: code indent should never use tabs
#4065: FILE: tools/virtiofsd/fuse_lowlevel.h:1702:
+^I^I^I^Iconst char *name, size_t namelen);$
ERROR: code indent should never use tabs
#4093: FILE: tools/virtiofsd/fuse_lowlevel.h:1730:
+^I^I^I off_t offset, struct fuse_bufvec *bufv,$
ERROR: code indent should never use tabs
#4094: FILE: tools/virtiofsd/fuse_lowlevel.h:1731:
+^I^I^I enum fuse_buf_copy_flags flags);$
ERROR: code indent should never use tabs
#4125: FILE: tools/virtiofsd/fuse_lowlevel.h:1762:
+^I^I^I^I size_t size, off_t offset, void *cookie);$
WARNING: Block comments use a leading /* on a separate line
#4128: FILE: tools/virtiofsd/fuse_lowlevel.h:1765:
+/* ----------------------------------------------------------- *
ERROR: code indent should never use tabs
#4129: FILE: tools/virtiofsd/fuse_lowlevel.h:1766:
+ * Utility functions^I^I^I^I^I *$
WARNING: Block comments use a trailing */ on a separate line
#4130: FILE: tools/virtiofsd/fuse_lowlevel.h:1767:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#4192: FILE: tools/virtiofsd/fuse_lowlevel.h:1829:
+^I^I^I void *data);$
WARNING: Block comments use a leading /* on a separate line
#4203: FILE: tools/virtiofsd/fuse_lowlevel.h:1840:
+/* ----------------------------------------------------------- *
WARNING: Block comments use a trailing */ on a separate line
#4205: FILE: tools/virtiofsd/fuse_lowlevel.h:1842:
+ * ----------------------------------------------------------- */
WARNING: Block comments use a leading /* on a separate line
#4224: FILE: tools/virtiofsd/fuse_lowlevel.h:1861:
+/* ----------------------------------------------------------- *
WARNING: Block comments use a trailing */ on a separate line
#4226: FILE: tools/virtiofsd/fuse_lowlevel.h:1863:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#4229: FILE: tools/virtiofsd/fuse_lowlevel.h:1866:
+^Iint singlethread;$
ERROR: code indent should never use tabs
#4230: FILE: tools/virtiofsd/fuse_lowlevel.h:1867:
+^Iint foreground;$
ERROR: code indent should never use tabs
#4231: FILE: tools/virtiofsd/fuse_lowlevel.h:1868:
+^Iint debug;$
ERROR: code indent should never use tabs
#4232: FILE: tools/virtiofsd/fuse_lowlevel.h:1869:
+^Iint nodefault_subtype;$
ERROR: code indent should never use tabs
#4233: FILE: tools/virtiofsd/fuse_lowlevel.h:1870:
+^Ichar *mountpoint;$
ERROR: code indent should never use tabs
#4234: FILE: tools/virtiofsd/fuse_lowlevel.h:1871:
+^Iint show_version;$
ERROR: code indent should never use tabs
#4235: FILE: tools/virtiofsd/fuse_lowlevel.h:1872:
+^Iint show_help;$
ERROR: code indent should never use tabs
#4236: FILE: tools/virtiofsd/fuse_lowlevel.h:1873:
+^Iint clone_fd;$
ERROR: code indent should never use tabs
#4237: FILE: tools/virtiofsd/fuse_lowlevel.h:1874:
+^Iunsigned int max_idle_threads;$
ERROR: code indent should never use tabs
#4259: FILE: tools/virtiofsd/fuse_lowlevel.h:1896:
+^I^I struct fuse_cmdline_opts *opts);$
ERROR: code indent should never use tabs
#4290: FILE: tools/virtiofsd/fuse_lowlevel.h:1927:
+^I^I^I^I const struct fuse_lowlevel_ops *op,$
ERROR: code indent should never use tabs
#4291: FILE: tools/virtiofsd/fuse_lowlevel.h:1928:
+^I^I^I^I size_t op_size, void *userdata);$
ERROR: trailing whitespace
#4335: FILE: tools/virtiofsd/fuse_lowlevel.h:1972:
+ * @param config session loop configuration $
WARNING: line over 80 characters
#4342: FILE: tools/virtiofsd/fuse_lowlevel.h:1979:
+int fuse_session_loop_mt(struct fuse_session *se, struct fuse_loop_config *config);
WARNING: Block comments use a leading /* on a separate line
#4404: FILE: tools/virtiofsd/fuse_lowlevel.h:2041:
+/* ----------------------------------------------------------- *
WARNING: Block comments use a trailing */ on a separate line
#4406: FILE: tools/virtiofsd/fuse_lowlevel.h:2043:
+ * ----------------------------------------------------------- */
ERROR: code indent should never use tabs
#4433: FILE: tools/virtiofsd/fuse_lowlevel.h:2070:
+^I^I^I const struct fuse_buf *buf);$
WARNING: architecture specific defines should be avoided
#4448: FILE: tools/virtiofsd/fuse_lowlevel.h:2085:
+#ifdef __cplusplus
WARNING: Block comments use * on subsequent lines
#4460: FILE: tools/virtiofsd/fuse_misc.h:2:
+/*
+ FUSE: Filesystem in Userspace
WARNING: Block comments use * on subsequent lines
#4470: FILE: tools/virtiofsd/fuse_misc.h:12:
+/*
+ Versioned symbols cannot be used in some cases because it
WARNING: architecture specific defines should be avoided
#4474: FILE: tools/virtiofsd/fuse_misc.h:16:
+#if (!defined(__UCLIBC__) && !defined(__APPLE__))
ERROR: code indent should never use tabs
#4486: FILE: tools/virtiofsd/fuse_misc.h:28:
+^Ipthread_mutexattr_t attr;$
ERROR: code indent should never use tabs
#4487: FILE: tools/virtiofsd/fuse_misc.h:29:
+^Ipthread_mutexattr_init(&attr);$
ERROR: code indent should never use tabs
#4488: FILE: tools/virtiofsd/fuse_misc.h:30:
+^Ipthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);$
ERROR: code indent should never use tabs
#4489: FILE: tools/virtiofsd/fuse_misc.h:31:
+^Ipthread_mutex_init(mut, &attr);$
ERROR: code indent should never use tabs
#4490: FILE: tools/virtiofsd/fuse_misc.h:32:
+^Ipthread_mutexattr_destroy(&attr);$
WARNING: Block comments use * on subsequent lines
#4525: FILE: tools/virtiofsd/fuse_opt.h:2:
+/*
+ FUSE: Filesystem in Userspace
WARNING: Block comments use a leading /* on a separate line
#4535: FILE: tools/virtiofsd/fuse_opt.h:12:
+/** @file
WARNING: architecture specific defines should be avoided
#4540: FILE: tools/virtiofsd/fuse_opt.h:17:
+#ifdef __cplusplus
ERROR: code indent should never use tabs
#4567: FILE: tools/virtiofsd/fuse_opt.h:44:
+ * - -1^I^I^I action ii)$
ERROR: code indent should never use tabs
#4578: FILE: tools/virtiofsd/fuse_opt.h:55:
+ * 1) "-x", "-foo", "--foo", "--foo-bar", etc.^IThese match only$
ERROR: code indent should never use tabs
#4601: FILE: tools/virtiofsd/fuse_opt.h:78:
+^I/** Matching template and optional parameter formatting */$
ERROR: code indent should never use tabs
#4602: FILE: tools/virtiofsd/fuse_opt.h:79:
+^Iconst char *templ;$
ERROR: code indent should never use tabs
#4604: FILE: tools/virtiofsd/fuse_opt.h:81:
+^I/**$
ERROR: code indent should never use tabs
#4605: FILE: tools/virtiofsd/fuse_opt.h:82:
+^I * Offset of variable within 'data' parameter of fuse_opt_parse()$
ERROR: code indent should never use tabs
#4606: FILE: tools/virtiofsd/fuse_opt.h:83:
+^I * or -1$
ERROR: code indent should never use tabs
#4607: FILE: tools/virtiofsd/fuse_opt.h:84:
+^I */$
ERROR: code indent should never use tabs
#4608: FILE: tools/virtiofsd/fuse_opt.h:85:
+^Iunsigned long offset;$
ERROR: code indent should never use tabs
#4610: FILE: tools/virtiofsd/fuse_opt.h:87:
+^I/**$
ERROR: code indent should never use tabs
#4611: FILE: tools/virtiofsd/fuse_opt.h:88:
+^I * Value to set the variable to, or to be passed as 'key' to the$
ERROR: code indent should never use tabs
#4612: FILE: tools/virtiofsd/fuse_opt.h:89:
+^I * processing function.^I Ignored if template has a format$
ERROR: code indent should never use tabs
#4613: FILE: tools/virtiofsd/fuse_opt.h:90:
+^I */$
ERROR: code indent should never use tabs
#4614: FILE: tools/virtiofsd/fuse_opt.h:91:
+^Iint value;$
ERROR: code indent should never use tabs
#4618: FILE: tools/virtiofsd/fuse_opt.h:95:
+ * Key option.^IIn case of a match, the processing function will be$
ERROR: code indent should never use tabs
#4624: FILE: tools/virtiofsd/fuse_opt.h:101:
+ * Last option.^I An array of 'struct fuse_opt' must end with a NULL$
ERROR: code indent should never use tabs
#4633: FILE: tools/virtiofsd/fuse_opt.h:110:
+^I/** Argument count */$
ERROR: code indent should never use tabs
#4634: FILE: tools/virtiofsd/fuse_opt.h:111:
+^Iint argc;$
ERROR: code indent should never use tabs
#4636: FILE: tools/virtiofsd/fuse_opt.h:113:
+^I/** Argument vector. NULL terminated */$
ERROR: code indent should never use tabs
#4637: FILE: tools/virtiofsd/fuse_opt.h:114:
+^Ichar **argv;$
ERROR: code indent should never use tabs
#4639: FILE: tools/virtiofsd/fuse_opt.h:116:
+^I/** Is 'argv' allocated? */$
ERROR: code indent should never use tabs
#4640: FILE: tools/virtiofsd/fuse_opt.h:117:
+^Iint allocated;$
ERROR: code indent should never use tabs
#4704: FILE: tools/virtiofsd/fuse_opt.h:181:
+^I^I^I struct fuse_args *outargs);$
ERROR: code indent should never use tabs
#4727: FILE: tools/virtiofsd/fuse_opt.h:204:
+^I^I const struct fuse_opt opts[], fuse_opt_proc_t proc);$
WARNING: architecture specific defines should be avoided
#4790: FILE: tools/virtiofsd/fuse_opt.h:267:
+#ifdef __cplusplus
ERROR: code indent should never use tabs
#4831: FILE: tools/virtiofsd/passthrough_helpers.h:31:
+^Iint mode, dev_t rdev)$
ERROR: code indent should never use tabs
#4833: FILE: tools/virtiofsd/passthrough_helpers.h:33:
+^Iint res;$
ERROR: code indent should never use tabs
#4835: FILE: tools/virtiofsd/passthrough_helpers.h:35:
+^Iif (S_ISREG(mode)) {$
ERROR: code indent should never use tabs
#4836: FILE: tools/virtiofsd/passthrough_helpers.h:36:
+^I^Ires = openat(dirfd, path, O_CREAT | O_EXCL | O_WRONLY, mode);$
ERROR: code indent should never use tabs
#4837: FILE: tools/virtiofsd/passthrough_helpers.h:37:
+^I^Iif (res >= 0)$
ERROR: braces {} are necessary for all arms of this statement
#4837: FILE: tools/virtiofsd/passthrough_helpers.h:37:
+ if (res >= 0)
[...]
ERROR: code indent should never use tabs
#4838: FILE: tools/virtiofsd/passthrough_helpers.h:38:
+^I^I^Ires = close(res);$
ERROR: code indent should never use tabs
#4839: FILE: tools/virtiofsd/passthrough_helpers.h:39:
+^I} else if (S_ISDIR(mode)) {$
ERROR: code indent should never use tabs
#4840: FILE: tools/virtiofsd/passthrough_helpers.h:40:
+^I^Ires = mkdirat(dirfd, path, mode);$
ERROR: code indent should never use tabs
#4841: FILE: tools/virtiofsd/passthrough_helpers.h:41:
+^I} else if (S_ISLNK(mode) && link != NULL) {$
ERROR: code indent should never use tabs
#4842: FILE: tools/virtiofsd/passthrough_helpers.h:42:
+^I^Ires = symlinkat(link, dirfd, path);$
ERROR: code indent should never use tabs
#4843: FILE: tools/virtiofsd/passthrough_helpers.h:43:
+^I} else if (S_ISFIFO(mode)) {$
ERROR: code indent should never use tabs
#4844: FILE: tools/virtiofsd/passthrough_helpers.h:44:
+^I^Ires = mkfifoat(dirfd, path, mode);$
WARNING: architecture specific defines should be avoided
#4845: FILE: tools/virtiofsd/passthrough_helpers.h:45:
+#ifdef __FreeBSD__
ERROR: code indent should never use tabs
#4846: FILE: tools/virtiofsd/passthrough_helpers.h:46:
+^I} else if (S_ISSOCK(mode)) {$
ERROR: code indent should never use tabs
#4847: FILE: tools/virtiofsd/passthrough_helpers.h:47:
+^I^Istruct sockaddr_un su;$
ERROR: code indent should never use tabs
#4848: FILE: tools/virtiofsd/passthrough_helpers.h:48:
+^I^Iint fd;$
ERROR: code indent should never use tabs
#4850: FILE: tools/virtiofsd/passthrough_helpers.h:50:
+^I^Iif (strlen(path) >= sizeof(su.sun_path)) {$
ERROR: code indent should never use tabs
#4851: FILE: tools/virtiofsd/passthrough_helpers.h:51:
+^I^I^Ierrno = ENAMETOOLONG;$
ERROR: code indent should never use tabs
#4852: FILE: tools/virtiofsd/passthrough_helpers.h:52:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#4853: FILE: tools/virtiofsd/passthrough_helpers.h:53:
+^I^I}$
ERROR: code indent should never use tabs
#4854: FILE: tools/virtiofsd/passthrough_helpers.h:54:
+^I^Ifd = socket(AF_UNIX, SOCK_STREAM, 0);$
ERROR: code indent should never use tabs
#4855: FILE: tools/virtiofsd/passthrough_helpers.h:55:
+^I^Iif (fd >= 0) {$
ERROR: code indent should never use tabs
#4856: FILE: tools/virtiofsd/passthrough_helpers.h:56:
+^I^I^I/*$
ERROR: code indent should never use tabs
#4857: FILE: tools/virtiofsd/passthrough_helpers.h:57:
+^I^I^I * We must bind the socket to the underlying file$
ERROR: code indent should never use tabs
#4858: FILE: tools/virtiofsd/passthrough_helpers.h:58:
+^I^I^I * system to create the socket file, even though$
ERROR: code indent should never use tabs
#4859: FILE: tools/virtiofsd/passthrough_helpers.h:59:
+^I^I^I * we'll never listen on this socket.$
ERROR: code indent should never use tabs
#4860: FILE: tools/virtiofsd/passthrough_helpers.h:60:
+^I^I^I */$
ERROR: code indent should never use tabs
#4861: FILE: tools/virtiofsd/passthrough_helpers.h:61:
+^I^I^Isu.sun_family = AF_UNIX;$
ERROR: code indent should never use tabs
#4862: FILE: tools/virtiofsd/passthrough_helpers.h:62:
+^I^I^Istrncpy(su.sun_path, path, sizeof(su.sun_path));$
ERROR: code indent should never use tabs
#4863: FILE: tools/virtiofsd/passthrough_helpers.h:63:
+^I^I^Ires = bindat(dirfd, fd, (struct sockaddr*)&su,$
ERROR: "(foo*)" should be "(foo *)"
#4863: FILE: tools/virtiofsd/passthrough_helpers.h:63:
+ res = bindat(dirfd, fd, (struct sockaddr*)&su,
ERROR: code indent should never use tabs
#4864: FILE: tools/virtiofsd/passthrough_helpers.h:64:
+^I^I^I^Isizeof(su));$
ERROR: code indent should never use tabs
#4865: FILE: tools/virtiofsd/passthrough_helpers.h:65:
+^I^I^Iif (res == 0)$
ERROR: braces {} are necessary for all arms of this statement
#4865: FILE: tools/virtiofsd/passthrough_helpers.h:65:
+ if (res == 0)
[...]
ERROR: code indent should never use tabs
#4866: FILE: tools/virtiofsd/passthrough_helpers.h:66:
+^I^I^I^Iclose(fd);$
ERROR: code indent should never use tabs
#4867: FILE: tools/virtiofsd/passthrough_helpers.h:67:
+^I^I} else {$
ERROR: code indent should never use tabs
#4868: FILE: tools/virtiofsd/passthrough_helpers.h:68:
+^I^I^Ires = -1;$
ERROR: code indent should never use tabs
#4869: FILE: tools/virtiofsd/passthrough_helpers.h:69:
+^I^I}$
ERROR: code indent should never use tabs
#4871: FILE: tools/virtiofsd/passthrough_helpers.h:71:
+^I} else {$
ERROR: code indent should never use tabs
#4872: FILE: tools/virtiofsd/passthrough_helpers.h:72:
+^I^Ires = mknodat(dirfd, path, mode, rdev);$
ERROR: code indent should never use tabs
#4873: FILE: tools/virtiofsd/passthrough_helpers.h:73:
+^I}$
ERROR: code indent should never use tabs
#4875: FILE: tools/virtiofsd/passthrough_helpers.h:75:
+^Ireturn res;$
total: 2271 errors, 139 warnings, 4814 lines checked
Patch 1/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
2/108 Checking commit 63a5dafc867f (virtiofsd: Pull in kernel's fuse.h)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#16:
new file mode 100644
total: 0 errors, 1 warnings, 898 lines checked
Patch 2/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
3/108 Checking commit 40b67822938b (virtiofsd: Add auxiliary .c's)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#15:
new file mode 100644
WARNING: Block comments use * on subsequent lines
#21: FILE: tools/virtiofsd/buffer.c:2:
+/*
+ FUSE: Filesystem in Userspace
ERROR: code indent should never use tabs
#43: FILE: tools/virtiofsd/buffer.c:24:
+^Isize_t i;$
ERROR: code indent should never use tabs
#44: FILE: tools/virtiofsd/buffer.c:25:
+^Isize_t size = 0;$
ERROR: code indent should never use tabs
#46: FILE: tools/virtiofsd/buffer.c:27:
+^Ifor (i = 0; i < bufv->count; i++) {$
ERROR: code indent should never use tabs
#47: FILE: tools/virtiofsd/buffer.c:28:
+^I^Iif (bufv->buf[i].size == SIZE_MAX)$
ERROR: braces {} are necessary for all arms of this statement
#47: FILE: tools/virtiofsd/buffer.c:28:
+ if (bufv->buf[i].size == SIZE_MAX)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#48: FILE: tools/virtiofsd/buffer.c:29:
+^I^I^Isize = SIZE_MAX;$
ERROR: code indent should never use tabs
#49: FILE: tools/virtiofsd/buffer.c:30:
+^I^Ielse$
ERROR: code indent should never use tabs
#50: FILE: tools/virtiofsd/buffer.c:31:
+^I^I^Isize += bufv->buf[i].size;$
ERROR: code indent should never use tabs
#51: FILE: tools/virtiofsd/buffer.c:32:
+^I}$
ERROR: code indent should never use tabs
#53: FILE: tools/virtiofsd/buffer.c:34:
+^Ireturn size;$
ERROR: code indent should never use tabs
#58: FILE: tools/virtiofsd/buffer.c:39:
+^Ireturn s1 < s2 ? s1 : s2;$
ERROR: code indent should never use tabs
#62: FILE: tools/virtiofsd/buffer.c:43:
+^I^I^I const struct fuse_buf *src, size_t src_off,$
ERROR: code indent should never use tabs
#63: FILE: tools/virtiofsd/buffer.c:44:
+^I^I^I size_t len)$
ERROR: code indent should never use tabs
#65: FILE: tools/virtiofsd/buffer.c:46:
+^Issize_t res = 0;$
ERROR: code indent should never use tabs
#66: FILE: tools/virtiofsd/buffer.c:47:
+^Isize_t copied = 0;$
ERROR: code indent should never use tabs
#68: FILE: tools/virtiofsd/buffer.c:49:
+^Iwhile (len) {$
ERROR: code indent should never use tabs
#69: FILE: tools/virtiofsd/buffer.c:50:
+^I^Iif (dst->flags & FUSE_BUF_FD_SEEK) {$
ERROR: code indent should never use tabs
#70: FILE: tools/virtiofsd/buffer.c:51:
+^I^I^Ires = pwrite(dst->fd, (char *)src->mem + src_off, len,$
ERROR: code indent should never use tabs
#71: FILE: tools/virtiofsd/buffer.c:52:
+^I^I^I^I dst->pos + dst_off);$
ERROR: code indent should never use tabs
#72: FILE: tools/virtiofsd/buffer.c:53:
+^I^I} else {$
ERROR: code indent should never use tabs
#73: FILE: tools/virtiofsd/buffer.c:54:
+^I^I^Ires = write(dst->fd, (char *)src->mem + src_off, len);$
ERROR: code indent should never use tabs
#74: FILE: tools/virtiofsd/buffer.c:55:
+^I^I}$
ERROR: code indent should never use tabs
#75: FILE: tools/virtiofsd/buffer.c:56:
+^I^Iif (res == -1) {$
ERROR: code indent should never use tabs
#76: FILE: tools/virtiofsd/buffer.c:57:
+^I^I^Iif (!copied)$
ERROR: braces {} are necessary for all arms of this statement
#76: FILE: tools/virtiofsd/buffer.c:57:
+ if (!copied)
[...]
ERROR: code indent should never use tabs
#77: FILE: tools/virtiofsd/buffer.c:58:
+^I^I^I^Ireturn -errno;$
ERROR: code indent should never use tabs
#78: FILE: tools/virtiofsd/buffer.c:59:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#79: FILE: tools/virtiofsd/buffer.c:60:
+^I^I}$
ERROR: code indent should never use tabs
#80: FILE: tools/virtiofsd/buffer.c:61:
+^I^Iif (res == 0)$
ERROR: braces {} are necessary for all arms of this statement
#80: FILE: tools/virtiofsd/buffer.c:61:
+ if (res == 0)
[...]
ERROR: code indent should never use tabs
#81: FILE: tools/virtiofsd/buffer.c:62:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#83: FILE: tools/virtiofsd/buffer.c:64:
+^I^Icopied += res;$
ERROR: code indent should never use tabs
#84: FILE: tools/virtiofsd/buffer.c:65:
+^I^Iif (!(dst->flags & FUSE_BUF_FD_RETRY))$
ERROR: braces {} are necessary for all arms of this statement
#84: FILE: tools/virtiofsd/buffer.c:65:
+ if (!(dst->flags & FUSE_BUF_FD_RETRY))
[...]
ERROR: code indent should never use tabs
#85: FILE: tools/virtiofsd/buffer.c:66:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#87: FILE: tools/virtiofsd/buffer.c:68:
+^I^Isrc_off += res;$
ERROR: code indent should never use tabs
#88: FILE: tools/virtiofsd/buffer.c:69:
+^I^Idst_off += res;$
ERROR: code indent should never use tabs
#89: FILE: tools/virtiofsd/buffer.c:70:
+^I^Ilen -= res;$
ERROR: code indent should never use tabs
#90: FILE: tools/virtiofsd/buffer.c:71:
+^I}$
ERROR: code indent should never use tabs
#92: FILE: tools/virtiofsd/buffer.c:73:
+^Ireturn copied;$
ERROR: code indent should never use tabs
#96: FILE: tools/virtiofsd/buffer.c:77:
+^I^I^I const struct fuse_buf *src, size_t src_off,$
ERROR: code indent should never use tabs
#97: FILE: tools/virtiofsd/buffer.c:78:
+^I^I^I size_t len)$
ERROR: code indent should never use tabs
#99: FILE: tools/virtiofsd/buffer.c:80:
+^Issize_t res = 0;$
ERROR: code indent should never use tabs
#100: FILE: tools/virtiofsd/buffer.c:81:
+^Isize_t copied = 0;$
ERROR: code indent should never use tabs
#102: FILE: tools/virtiofsd/buffer.c:83:
+^Iwhile (len) {$
ERROR: code indent should never use tabs
#103: FILE: tools/virtiofsd/buffer.c:84:
+^I^Iif (src->flags & FUSE_BUF_FD_SEEK) {$
ERROR: code indent should never use tabs
#104: FILE: tools/virtiofsd/buffer.c:85:
+^I^I^Ires = pread(src->fd, (char *)dst->mem + dst_off, len,$
ERROR: code indent should never use tabs
#105: FILE: tools/virtiofsd/buffer.c:86:
+^I^I^I^I src->pos + src_off);$
ERROR: code indent should never use tabs
#106: FILE: tools/virtiofsd/buffer.c:87:
+^I^I} else {$
ERROR: code indent should never use tabs
#107: FILE: tools/virtiofsd/buffer.c:88:
+^I^I^Ires = read(src->fd, (char *)dst->mem + dst_off, len);$
ERROR: code indent should never use tabs
#108: FILE: tools/virtiofsd/buffer.c:89:
+^I^I}$
ERROR: code indent should never use tabs
#109: FILE: tools/virtiofsd/buffer.c:90:
+^I^Iif (res == -1) {$
ERROR: code indent should never use tabs
#110: FILE: tools/virtiofsd/buffer.c:91:
+^I^I^Iif (!copied)$
ERROR: braces {} are necessary for all arms of this statement
#110: FILE: tools/virtiofsd/buffer.c:91:
+ if (!copied)
[...]
ERROR: code indent should never use tabs
#111: FILE: tools/virtiofsd/buffer.c:92:
+^I^I^I^Ireturn -errno;$
ERROR: code indent should never use tabs
#112: FILE: tools/virtiofsd/buffer.c:93:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#113: FILE: tools/virtiofsd/buffer.c:94:
+^I^I}$
ERROR: code indent should never use tabs
#114: FILE: tools/virtiofsd/buffer.c:95:
+^I^Iif (res == 0)$
ERROR: braces {} are necessary for all arms of this statement
#114: FILE: tools/virtiofsd/buffer.c:95:
+ if (res == 0)
[...]
ERROR: code indent should never use tabs
#115: FILE: tools/virtiofsd/buffer.c:96:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#117: FILE: tools/virtiofsd/buffer.c:98:
+^I^Icopied += res;$
ERROR: code indent should never use tabs
#118: FILE: tools/virtiofsd/buffer.c:99:
+^I^Iif (!(src->flags & FUSE_BUF_FD_RETRY))$
ERROR: braces {} are necessary for all arms of this statement
#118: FILE: tools/virtiofsd/buffer.c:99:
+ if (!(src->flags & FUSE_BUF_FD_RETRY))
[...]
ERROR: code indent should never use tabs
#119: FILE: tools/virtiofsd/buffer.c:100:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#121: FILE: tools/virtiofsd/buffer.c:102:
+^I^Idst_off += res;$
ERROR: code indent should never use tabs
#122: FILE: tools/virtiofsd/buffer.c:103:
+^I^Isrc_off += res;$
ERROR: code indent should never use tabs
#123: FILE: tools/virtiofsd/buffer.c:104:
+^I^Ilen -= res;$
ERROR: code indent should never use tabs
#124: FILE: tools/virtiofsd/buffer.c:105:
+^I}$
ERROR: code indent should never use tabs
#126: FILE: tools/virtiofsd/buffer.c:107:
+^Ireturn copied;$
ERROR: code indent should never use tabs
#130: FILE: tools/virtiofsd/buffer.c:111:
+^I^I^I^I const struct fuse_buf *src, size_t src_off,$
ERROR: code indent should never use tabs
#131: FILE: tools/virtiofsd/buffer.c:112:
+^I^I^I^I size_t len)$
ERROR: code indent should never use tabs
#133: FILE: tools/virtiofsd/buffer.c:114:
+^Ichar buf[4096];$
ERROR: code indent should never use tabs
#134: FILE: tools/virtiofsd/buffer.c:115:
+^Istruct fuse_buf tmp = {$
ERROR: code indent should never use tabs
#135: FILE: tools/virtiofsd/buffer.c:116:
+^I^I.size = sizeof(buf),$
ERROR: code indent should never use tabs
#136: FILE: tools/virtiofsd/buffer.c:117:
+^I^I.flags = 0,$
ERROR: code indent should never use tabs
#137: FILE: tools/virtiofsd/buffer.c:118:
+^I};$
ERROR: code indent should never use tabs
#138: FILE: tools/virtiofsd/buffer.c:119:
+^Issize_t res;$
ERROR: code indent should never use tabs
#139: FILE: tools/virtiofsd/buffer.c:120:
+^Isize_t copied = 0;$
ERROR: code indent should never use tabs
#141: FILE: tools/virtiofsd/buffer.c:122:
+^Itmp.mem = buf;$
ERROR: code indent should never use tabs
#143: FILE: tools/virtiofsd/buffer.c:124:
+^Iwhile (len) {$
ERROR: code indent should never use tabs
#144: FILE: tools/virtiofsd/buffer.c:125:
+^I^Isize_t this_len = min_size(tmp.size, len);$
ERROR: code indent should never use tabs
#145: FILE: tools/virtiofsd/buffer.c:126:
+^I^Isize_t read_len;$
ERROR: code indent should never use tabs
#147: FILE: tools/virtiofsd/buffer.c:128:
+^I^Ires = fuse_buf_read(&tmp, 0, src, src_off, this_len);$
ERROR: code indent should never use tabs
#148: FILE: tools/virtiofsd/buffer.c:129:
+^I^Iif (res < 0) {$
ERROR: code indent should never use tabs
#149: FILE: tools/virtiofsd/buffer.c:130:
+^I^I^Iif (!copied)$
ERROR: braces {} are necessary for all arms of this statement
#149: FILE: tools/virtiofsd/buffer.c:130:
+ if (!copied)
[...]
ERROR: code indent should never use tabs
#150: FILE: tools/virtiofsd/buffer.c:131:
+^I^I^I^Ireturn res;$
ERROR: code indent should never use tabs
#151: FILE: tools/virtiofsd/buffer.c:132:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#152: FILE: tools/virtiofsd/buffer.c:133:
+^I^I}$
ERROR: code indent should never use tabs
#153: FILE: tools/virtiofsd/buffer.c:134:
+^I^Iif (res == 0)$
ERROR: braces {} are necessary for all arms of this statement
#153: FILE: tools/virtiofsd/buffer.c:134:
+ if (res == 0)
[...]
ERROR: code indent should never use tabs
#154: FILE: tools/virtiofsd/buffer.c:135:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#156: FILE: tools/virtiofsd/buffer.c:137:
+^I^Iread_len = res;$
ERROR: code indent should never use tabs
#157: FILE: tools/virtiofsd/buffer.c:138:
+^I^Ires = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);$
ERROR: code indent should never use tabs
#158: FILE: tools/virtiofsd/buffer.c:139:
+^I^Iif (res < 0) {$
ERROR: code indent should never use tabs
#159: FILE: tools/virtiofsd/buffer.c:140:
+^I^I^Iif (!copied)$
ERROR: braces {} are necessary for all arms of this statement
#159: FILE: tools/virtiofsd/buffer.c:140:
+ if (!copied)
[...]
ERROR: code indent should never use tabs
#160: FILE: tools/virtiofsd/buffer.c:141:
+^I^I^I^Ireturn res;$
ERROR: code indent should never use tabs
#161: FILE: tools/virtiofsd/buffer.c:142:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#162: FILE: tools/virtiofsd/buffer.c:143:
+^I^I}$
ERROR: code indent should never use tabs
#163: FILE: tools/virtiofsd/buffer.c:144:
+^I^Iif (res == 0)$
ERROR: braces {} are necessary for all arms of this statement
#163: FILE: tools/virtiofsd/buffer.c:144:
+ if (res == 0)
[...]
ERROR: code indent should never use tabs
#164: FILE: tools/virtiofsd/buffer.c:145:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#166: FILE: tools/virtiofsd/buffer.c:147:
+^I^Icopied += res;$
ERROR: code indent should never use tabs
#168: FILE: tools/virtiofsd/buffer.c:149:
+^I^Iif (res < this_len)$
ERROR: braces {} are necessary for all arms of this statement
#168: FILE: tools/virtiofsd/buffer.c:149:
+ if (res < this_len)
[...]
ERROR: code indent should never use tabs
#169: FILE: tools/virtiofsd/buffer.c:150:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#171: FILE: tools/virtiofsd/buffer.c:152:
+^I^Idst_off += res;$
ERROR: code indent should never use tabs
#172: FILE: tools/virtiofsd/buffer.c:153:
+^I^Isrc_off += res;$
ERROR: code indent should never use tabs
#173: FILE: tools/virtiofsd/buffer.c:154:
+^I^Ilen -= res;$
ERROR: code indent should never use tabs
#174: FILE: tools/virtiofsd/buffer.c:155:
+^I}$
ERROR: code indent should never use tabs
#176: FILE: tools/virtiofsd/buffer.c:157:
+^Ireturn copied;$
ERROR: code indent should never use tabs
#181: FILE: tools/virtiofsd/buffer.c:162:
+^I^I^I const struct fuse_buf *src, size_t src_off,$
ERROR: code indent should never use tabs
#182: FILE: tools/virtiofsd/buffer.c:163:
+^I^I^I size_t len, enum fuse_buf_copy_flags flags)$
ERROR: code indent should never use tabs
#184: FILE: tools/virtiofsd/buffer.c:165:
+^Iint splice_flags = 0;$
ERROR: code indent should never use tabs
#185: FILE: tools/virtiofsd/buffer.c:166:
+^Ioff_t *srcpos = NULL;$
ERROR: code indent should never use tabs
#186: FILE: tools/virtiofsd/buffer.c:167:
+^Ioff_t *dstpos = NULL;$
ERROR: code indent should never use tabs
#187: FILE: tools/virtiofsd/buffer.c:168:
+^Ioff_t srcpos_val;$
ERROR: code indent should never use tabs
#188: FILE: tools/virtiofsd/buffer.c:169:
+^Ioff_t dstpos_val;$
ERROR: code indent should never use tabs
#189: FILE: tools/virtiofsd/buffer.c:170:
+^Issize_t res;$
ERROR: code indent should never use tabs
#190: FILE: tools/virtiofsd/buffer.c:171:
+^Isize_t copied = 0;$
ERROR: code indent should never use tabs
#192: FILE: tools/virtiofsd/buffer.c:173:
+^Iif (flags & FUSE_BUF_SPLICE_MOVE)$
ERROR: braces {} are necessary for all arms of this statement
#192: FILE: tools/virtiofsd/buffer.c:173:
+ if (flags & FUSE_BUF_SPLICE_MOVE)
[...]
ERROR: code indent should never use tabs
#193: FILE: tools/virtiofsd/buffer.c:174:
+^I^Isplice_flags |= SPLICE_F_MOVE;$
ERROR: code indent should never use tabs
#194: FILE: tools/virtiofsd/buffer.c:175:
+^Iif (flags & FUSE_BUF_SPLICE_NONBLOCK)$
ERROR: braces {} are necessary for all arms of this statement
#194: FILE: tools/virtiofsd/buffer.c:175:
+ if (flags & FUSE_BUF_SPLICE_NONBLOCK)
[...]
ERROR: code indent should never use tabs
#195: FILE: tools/virtiofsd/buffer.c:176:
+^I^Isplice_flags |= SPLICE_F_NONBLOCK;$
ERROR: code indent should never use tabs
#197: FILE: tools/virtiofsd/buffer.c:178:
+^Iif (src->flags & FUSE_BUF_FD_SEEK) {$
ERROR: code indent should never use tabs
#198: FILE: tools/virtiofsd/buffer.c:179:
+^I^Isrcpos_val = src->pos + src_off;$
ERROR: code indent should never use tabs
#199: FILE: tools/virtiofsd/buffer.c:180:
+^I^Isrcpos = &srcpos_val;$
ERROR: code indent should never use tabs
#200: FILE: tools/virtiofsd/buffer.c:181:
+^I}$
ERROR: code indent should never use tabs
#201: FILE: tools/virtiofsd/buffer.c:182:
+^Iif (dst->flags & FUSE_BUF_FD_SEEK) {$
ERROR: code indent should never use tabs
#202: FILE: tools/virtiofsd/buffer.c:183:
+^I^Idstpos_val = dst->pos + dst_off;$
ERROR: code indent should never use tabs
#203: FILE: tools/virtiofsd/buffer.c:184:
+^I^Idstpos = &dstpos_val;$
ERROR: code indent should never use tabs
#204: FILE: tools/virtiofsd/buffer.c:185:
+^I}$
ERROR: code indent should never use tabs
#206: FILE: tools/virtiofsd/buffer.c:187:
+^Iwhile (len) {$
ERROR: code indent should never use tabs
#207: FILE: tools/virtiofsd/buffer.c:188:
+^I^Ires = splice(src->fd, srcpos, dst->fd, dstpos, len,$
ERROR: code indent should never use tabs
#208: FILE: tools/virtiofsd/buffer.c:189:
+^I^I^I splice_flags);$
ERROR: code indent should never use tabs
#209: FILE: tools/virtiofsd/buffer.c:190:
+^I^Iif (res == -1) {$
ERROR: code indent should never use tabs
#210: FILE: tools/virtiofsd/buffer.c:191:
+^I^I^Iif (copied)$
ERROR: braces {} are necessary for all arms of this statement
#210: FILE: tools/virtiofsd/buffer.c:191:
+ if (copied)
[...]
ERROR: code indent should never use tabs
#211: FILE: tools/virtiofsd/buffer.c:192:
+^I^I^I^Ibreak;$
ERROR: code indent should never use tabs
#213: FILE: tools/virtiofsd/buffer.c:194:
+^I^I^Iif (errno != EINVAL || (flags & FUSE_BUF_FORCE_SPLICE))$
ERROR: braces {} are necessary for all arms of this statement
#213: FILE: tools/virtiofsd/buffer.c:194:
+ if (errno != EINVAL || (flags & FUSE_BUF_FORCE_SPLICE))
[...]
ERROR: code indent should never use tabs
#214: FILE: tools/virtiofsd/buffer.c:195:
+^I^I^I^Ireturn -errno;$
ERROR: code indent should never use tabs
#216: FILE: tools/virtiofsd/buffer.c:197:
+^I^I^I/* Maybe splice is not supported for this combination */$
ERROR: code indent should never use tabs
#217: FILE: tools/virtiofsd/buffer.c:198:
+^I^I^Ireturn fuse_buf_fd_to_fd(dst, dst_off, src, src_off,$
ERROR: code indent should never use tabs
#218: FILE: tools/virtiofsd/buffer.c:199:
+^I^I^I^I^I^I len);$
ERROR: code indent should never use tabs
#219: FILE: tools/virtiofsd/buffer.c:200:
+^I^I}$
ERROR: code indent should never use tabs
#220: FILE: tools/virtiofsd/buffer.c:201:
+^I^Iif (res == 0)$
ERROR: braces {} are necessary for all arms of this statement
#220: FILE: tools/virtiofsd/buffer.c:201:
+ if (res == 0)
[...]
ERROR: code indent should never use tabs
#221: FILE: tools/virtiofsd/buffer.c:202:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#223: FILE: tools/virtiofsd/buffer.c:204:
+^I^Icopied += res;$
ERROR: code indent should never use tabs
#224: FILE: tools/virtiofsd/buffer.c:205:
+^I^Iif (!(src->flags & FUSE_BUF_FD_RETRY) &&$
ERROR: code indent should never use tabs
#225: FILE: tools/virtiofsd/buffer.c:206:
+^I^I !(dst->flags & FUSE_BUF_FD_RETRY)) {$
ERROR: code indent should never use tabs
#226: FILE: tools/virtiofsd/buffer.c:207:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#227: FILE: tools/virtiofsd/buffer.c:208:
+^I^I}$
ERROR: code indent should never use tabs
#229: FILE: tools/virtiofsd/buffer.c:210:
+^I^Ilen -= res;$
ERROR: code indent should never use tabs
#230: FILE: tools/virtiofsd/buffer.c:211:
+^I}$
ERROR: code indent should never use tabs
#232: FILE: tools/virtiofsd/buffer.c:213:
+^Ireturn copied;$
ERROR: code indent should never use tabs
#236: FILE: tools/virtiofsd/buffer.c:217:
+^I^I^I const struct fuse_buf *src, size_t src_off,$
ERROR: code indent should never use tabs
#237: FILE: tools/virtiofsd/buffer.c:218:
+^I^I^I size_t len, enum fuse_buf_copy_flags flags)$
ERROR: code indent should never use tabs
#239: FILE: tools/virtiofsd/buffer.c:220:
+^I(void) flags;$
ERROR: code indent should never use tabs
#241: FILE: tools/virtiofsd/buffer.c:222:
+^Ireturn fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);$
ERROR: code indent should never use tabs
#247: FILE: tools/virtiofsd/buffer.c:228:
+^I^I^I^I const struct fuse_buf *src, size_t src_off,$
ERROR: code indent should never use tabs
#248: FILE: tools/virtiofsd/buffer.c:229:
+^I^I^I^I size_t len, enum fuse_buf_copy_flags flags)$
ERROR: code indent should never use tabs
#250: FILE: tools/virtiofsd/buffer.c:231:
+^Iint src_is_fd = src->flags & FUSE_BUF_IS_FD;$
ERROR: code indent should never use tabs
#251: FILE: tools/virtiofsd/buffer.c:232:
+^Iint dst_is_fd = dst->flags & FUSE_BUF_IS_FD;$
ERROR: code indent should never use tabs
#253: FILE: tools/virtiofsd/buffer.c:234:
+^Iif (!src_is_fd && !dst_is_fd) {$
ERROR: code indent should never use tabs
#254: FILE: tools/virtiofsd/buffer.c:235:
+^I^Ichar *dstmem = (char *)dst->mem + dst_off;$
ERROR: code indent should never use tabs
#255: FILE: tools/virtiofsd/buffer.c:236:
+^I^Ichar *srcmem = (char *)src->mem + src_off;$
ERROR: code indent should never use tabs
#257: FILE: tools/virtiofsd/buffer.c:238:
+^I^Iif (dstmem != srcmem) {$
ERROR: code indent should never use tabs
#258: FILE: tools/virtiofsd/buffer.c:239:
+^I^I^Iif (dstmem + len <= srcmem || srcmem + len <= dstmem)$
ERROR: braces {} are necessary for all arms of this statement
#258: FILE: tools/virtiofsd/buffer.c:239:
+ if (dstmem + len <= srcmem || srcmem + len <= dstmem)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#259: FILE: tools/virtiofsd/buffer.c:240:
+^I^I^I^Imemcpy(dstmem, srcmem, len);$
ERROR: code indent should never use tabs
#260: FILE: tools/virtiofsd/buffer.c:241:
+^I^I^Ielse$
ERROR: code indent should never use tabs
#261: FILE: tools/virtiofsd/buffer.c:242:
+^I^I^I^Imemmove(dstmem, srcmem, len);$
ERROR: code indent should never use tabs
#262: FILE: tools/virtiofsd/buffer.c:243:
+^I^I}$
ERROR: code indent should never use tabs
#264: FILE: tools/virtiofsd/buffer.c:245:
+^I^Ireturn len;$
ERROR: code indent should never use tabs
#265: FILE: tools/virtiofsd/buffer.c:246:
+^I} else if (!src_is_fd) {$
ERROR: code indent should never use tabs
#266: FILE: tools/virtiofsd/buffer.c:247:
+^I^Ireturn fuse_buf_write(dst, dst_off, src, src_off, len);$
ERROR: code indent should never use tabs
#267: FILE: tools/virtiofsd/buffer.c:248:
+^I} else if (!dst_is_fd) {$
ERROR: code indent should never use tabs
#268: FILE: tools/virtiofsd/buffer.c:249:
+^I^Ireturn fuse_buf_read(dst, dst_off, src, src_off, len);$
ERROR: code indent should never use tabs
#269: FILE: tools/virtiofsd/buffer.c:250:
+^I} else if (flags & FUSE_BUF_NO_SPLICE) {$
ERROR: code indent should never use tabs
#270: FILE: tools/virtiofsd/buffer.c:251:
+^I^Ireturn fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);$
ERROR: code indent should never use tabs
#271: FILE: tools/virtiofsd/buffer.c:252:
+^I} else {$
ERROR: code indent should never use tabs
#272: FILE: tools/virtiofsd/buffer.c:253:
+^I^Ireturn fuse_buf_splice(dst, dst_off, src, src_off, len, flags);$
ERROR: code indent should never use tabs
#273: FILE: tools/virtiofsd/buffer.c:254:
+^I}$
ERROR: code indent should never use tabs
#278: FILE: tools/virtiofsd/buffer.c:259:
+^Iif (bufv->idx < bufv->count)$
ERROR: braces {} are necessary for all arms of this statement
#278: FILE: tools/virtiofsd/buffer.c:259:
+ if (bufv->idx < bufv->count)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#279: FILE: tools/virtiofsd/buffer.c:260:
+^I^Ireturn &bufv->buf[bufv->idx];$
ERROR: code indent should never use tabs
#280: FILE: tools/virtiofsd/buffer.c:261:
+^Ielse$
ERROR: code indent should never use tabs
#281: FILE: tools/virtiofsd/buffer.c:262:
+^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#286: FILE: tools/virtiofsd/buffer.c:267:
+^Iconst struct fuse_buf *buf = fuse_bufvec_current(bufv);$
ERROR: code indent should never use tabs
#288: FILE: tools/virtiofsd/buffer.c:269:
+^Ibufv->off += len;$
ERROR: code indent should never use tabs
#289: FILE: tools/virtiofsd/buffer.c:270:
+^Iassert(bufv->off <= buf->size);$
ERROR: code indent should never use tabs
#290: FILE: tools/virtiofsd/buffer.c:271:
+^Iif (bufv->off == buf->size) {$
ERROR: code indent should never use tabs
#291: FILE: tools/virtiofsd/buffer.c:272:
+^I^Iassert(bufv->idx < bufv->count);$
ERROR: code indent should never use tabs
#292: FILE: tools/virtiofsd/buffer.c:273:
+^I^Ibufv->idx++;$
ERROR: code indent should never use tabs
#293: FILE: tools/virtiofsd/buffer.c:274:
+^I^Iif (bufv->idx == bufv->count)$
ERROR: braces {} are necessary for all arms of this statement
#293: FILE: tools/virtiofsd/buffer.c:274:
+ if (bufv->idx == bufv->count)
[...]
ERROR: code indent should never use tabs
#294: FILE: tools/virtiofsd/buffer.c:275:
+^I^I^Ireturn 0;$
ERROR: code indent should never use tabs
#295: FILE: tools/virtiofsd/buffer.c:276:
+^I^Ibufv->off = 0;$
ERROR: code indent should never use tabs
#296: FILE: tools/virtiofsd/buffer.c:277:
+^I}$
ERROR: code indent should never use tabs
#297: FILE: tools/virtiofsd/buffer.c:278:
+^Ireturn 1;$
ERROR: code indent should never use tabs
#301: FILE: tools/virtiofsd/buffer.c:282:
+^I^I enum fuse_buf_copy_flags flags)$
ERROR: code indent should never use tabs
#303: FILE: tools/virtiofsd/buffer.c:284:
+^Isize_t copied = 0;$
ERROR: code indent should never use tabs
#305: FILE: tools/virtiofsd/buffer.c:286:
+^Iif (dstv == srcv)$
ERROR: braces {} are necessary for all arms of this statement
#305: FILE: tools/virtiofsd/buffer.c:286:
+ if (dstv == srcv)
[...]
ERROR: code indent should never use tabs
#306: FILE: tools/virtiofsd/buffer.c:287:
+^I^Ireturn fuse_buf_size(dstv);$
ERROR: code indent should never use tabs
#308: FILE: tools/virtiofsd/buffer.c:289:
+^Ifor (;;) {$
ERROR: code indent should never use tabs
#309: FILE: tools/virtiofsd/buffer.c:290:
+^I^Iconst struct fuse_buf *src = fuse_bufvec_current(srcv);$
ERROR: code indent should never use tabs
#310: FILE: tools/virtiofsd/buffer.c:291:
+^I^Iconst struct fuse_buf *dst = fuse_bufvec_current(dstv);$
ERROR: code indent should never use tabs
#311: FILE: tools/virtiofsd/buffer.c:292:
+^I^Isize_t src_len;$
ERROR: code indent should never use tabs
#312: FILE: tools/virtiofsd/buffer.c:293:
+^I^Isize_t dst_len;$
ERROR: code indent should never use tabs
#313: FILE: tools/virtiofsd/buffer.c:294:
+^I^Isize_t len;$
ERROR: code indent should never use tabs
#314: FILE: tools/virtiofsd/buffer.c:295:
+^I^Issize_t res;$
ERROR: code indent should never use tabs
#316: FILE: tools/virtiofsd/buffer.c:297:
+^I^Iif (src == NULL || dst == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#316: FILE: tools/virtiofsd/buffer.c:297:
+ if (src == NULL || dst == NULL)
[...]
ERROR: code indent should never use tabs
#317: FILE: tools/virtiofsd/buffer.c:298:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#319: FILE: tools/virtiofsd/buffer.c:300:
+^I^Isrc_len = src->size - srcv->off;$
ERROR: code indent should never use tabs
#320: FILE: tools/virtiofsd/buffer.c:301:
+^I^Idst_len = dst->size - dstv->off;$
ERROR: code indent should never use tabs
#321: FILE: tools/virtiofsd/buffer.c:302:
+^I^Ilen = min_size(src_len, dst_len);$
WARNING: line over 80 characters
#323: FILE: tools/virtiofsd/buffer.c:304:
+ res = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len, flags);
ERROR: code indent should never use tabs
#323: FILE: tools/virtiofsd/buffer.c:304:
+^I^Ires = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len, flags);$
ERROR: code indent should never use tabs
#324: FILE: tools/virtiofsd/buffer.c:305:
+^I^Iif (res < 0) {$
ERROR: code indent should never use tabs
#325: FILE: tools/virtiofsd/buffer.c:306:
+^I^I^Iif (!copied)$
ERROR: braces {} are necessary for all arms of this statement
#325: FILE: tools/virtiofsd/buffer.c:306:
+ if (!copied)
[...]
ERROR: code indent should never use tabs
#326: FILE: tools/virtiofsd/buffer.c:307:
+^I^I^I^Ireturn res;$
ERROR: code indent should never use tabs
#327: FILE: tools/virtiofsd/buffer.c:308:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#328: FILE: tools/virtiofsd/buffer.c:309:
+^I^I}$
ERROR: code indent should never use tabs
#329: FILE: tools/virtiofsd/buffer.c:310:
+^I^Icopied += res;$
ERROR: code indent should never use tabs
#331: FILE: tools/virtiofsd/buffer.c:312:
+^I^Iif (!fuse_bufvec_advance(srcv, res) ||$
ERROR: code indent should never use tabs
#332: FILE: tools/virtiofsd/buffer.c:313:
+^I^I !fuse_bufvec_advance(dstv, res))$
ERROR: code indent should never use tabs
#333: FILE: tools/virtiofsd/buffer.c:314:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#335: FILE: tools/virtiofsd/buffer.c:316:
+^I^Iif (res < len)$
ERROR: braces {} are necessary for all arms of this statement
#335: FILE: tools/virtiofsd/buffer.c:316:
+ if (res < len)
[...]
ERROR: code indent should never use tabs
#336: FILE: tools/virtiofsd/buffer.c:317:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#337: FILE: tools/virtiofsd/buffer.c:318:
+^I}$
ERROR: code indent should never use tabs
#339: FILE: tools/virtiofsd/buffer.c:320:
+^Ireturn copied;$
WARNING: Block comments use * on subsequent lines
#348: FILE: tools/virtiofsd/fuse_log.c:2:
+/*
+ FUSE: Filesystem in Userspace
ERROR: code indent should never use tabs
#363: FILE: tools/virtiofsd/fuse_log.c:17:
+^I^I__attribute__(( unused )) enum fuse_log_level level,$
ERROR: space prohibited after that open parenthesis '('
#363: FILE: tools/virtiofsd/fuse_log.c:17:
+ __attribute__(( unused )) enum fuse_log_level level,
ERROR: space prohibited before that close parenthesis ')'
#363: FILE: tools/virtiofsd/fuse_log.c:17:
+ __attribute__(( unused )) enum fuse_log_level level,
ERROR: code indent should never use tabs
#364: FILE: tools/virtiofsd/fuse_log.c:18:
+^I^Iconst char *fmt, va_list ap)$
ERROR: code indent should never use tabs
#366: FILE: tools/virtiofsd/fuse_log.c:20:
+^Ivfprintf(stderr, fmt, ap);$
ERROR: code indent should never use tabs
#373: FILE: tools/virtiofsd/fuse_log.c:27:
+^Iif (!func)$
ERROR: braces {} are necessary for all arms of this statement
#373: FILE: tools/virtiofsd/fuse_log.c:27:
+ if (!func)
[...]
ERROR: code indent should never use tabs
#374: FILE: tools/virtiofsd/fuse_log.c:28:
+^I^Ifunc = default_log_func;$
ERROR: code indent should never use tabs
#376: FILE: tools/virtiofsd/fuse_log.c:30:
+^Ilog_func = func;$
ERROR: code indent should never use tabs
#381: FILE: tools/virtiofsd/fuse_log.c:35:
+^Iva_list ap;$
ERROR: code indent should never use tabs
#383: FILE: tools/virtiofsd/fuse_log.c:37:
+^Iva_start(ap, fmt);$
ERROR: code indent should never use tabs
#384: FILE: tools/virtiofsd/fuse_log.c:38:
+^Ilog_func(level, fmt, ap);$
ERROR: code indent should never use tabs
#385: FILE: tools/virtiofsd/fuse_log.c:39:
+^Iva_end(ap);$
WARNING: Block comments use * on subsequent lines
#394: FILE: tools/virtiofsd/fuse_opt.c:2:
+/*
+ FUSE: Filesystem in Userspace
ERROR: code indent should never use tabs
#415: FILE: tools/virtiofsd/fuse_opt.c:23:
+^Ivoid *data;$
ERROR: code indent should never use tabs
#416: FILE: tools/virtiofsd/fuse_opt.c:24:
+^Iconst struct fuse_opt *opt;$
ERROR: code indent should never use tabs
#417: FILE: tools/virtiofsd/fuse_opt.c:25:
+^Ifuse_opt_proc_t proc;$
ERROR: code indent should never use tabs
#418: FILE: tools/virtiofsd/fuse_opt.c:26:
+^Iint argctr;$
ERROR: code indent should never use tabs
#419: FILE: tools/virtiofsd/fuse_opt.c:27:
+^Iint argc;$
ERROR: code indent should never use tabs
#420: FILE: tools/virtiofsd/fuse_opt.c:28:
+^Ichar **argv;$
ERROR: code indent should never use tabs
#421: FILE: tools/virtiofsd/fuse_opt.c:29:
+^Istruct fuse_args outargs;$
ERROR: code indent should never use tabs
#422: FILE: tools/virtiofsd/fuse_opt.c:30:
+^Ichar *opts;$
ERROR: code indent should never use tabs
#423: FILE: tools/virtiofsd/fuse_opt.c:31:
+^Iint nonopt;$
ERROR: code indent should never use tabs
#428: FILE: tools/virtiofsd/fuse_opt.c:36:
+^Iif (args) {$
ERROR: code indent should never use tabs
#429: FILE: tools/virtiofsd/fuse_opt.c:37:
+^I^Iif (args->argv && args->allocated) {$
ERROR: code indent should never use tabs
#430: FILE: tools/virtiofsd/fuse_opt.c:38:
+^I^I^Iint i;$
ERROR: code indent should never use tabs
#431: FILE: tools/virtiofsd/fuse_opt.c:39:
+^I^I^Ifor (i = 0; i < args->argc; i++)$
ERROR: braces {} are necessary for all arms of this statement
#431: FILE: tools/virtiofsd/fuse_opt.c:39:
+ for (i = 0; i < args->argc; i++)
[...]
ERROR: code indent should never use tabs
#432: FILE: tools/virtiofsd/fuse_opt.c:40:
+^I^I^I^Ifree(args->argv[i]);$
ERROR: code indent should never use tabs
#433: FILE: tools/virtiofsd/fuse_opt.c:41:
+^I^I^Ifree(args->argv);$
ERROR: code indent should never use tabs
#434: FILE: tools/virtiofsd/fuse_opt.c:42:
+^I^I}$
ERROR: code indent should never use tabs
#435: FILE: tools/virtiofsd/fuse_opt.c:43:
+^I^Iargs->argc = 0;$
ERROR: code indent should never use tabs
#436: FILE: tools/virtiofsd/fuse_opt.c:44:
+^I^Iargs->argv = NULL;$
ERROR: code indent should never use tabs
#437: FILE: tools/virtiofsd/fuse_opt.c:45:
+^I^Iargs->allocated = 0;$
ERROR: code indent should never use tabs
#438: FILE: tools/virtiofsd/fuse_opt.c:46:
+^I}$
ERROR: code indent should never use tabs
#443: FILE: tools/virtiofsd/fuse_opt.c:51:
+^Ifuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");$
ERROR: code indent should never use tabs
#444: FILE: tools/virtiofsd/fuse_opt.c:52:
+^Ireturn -1;$
ERROR: code indent should never use tabs
#449: FILE: tools/virtiofsd/fuse_opt.c:57:
+^Ichar **newargv;$
ERROR: code indent should never use tabs
#450: FILE: tools/virtiofsd/fuse_opt.c:58:
+^Ichar *newarg;$
ERROR: code indent should never use tabs
#452: FILE: tools/virtiofsd/fuse_opt.c:60:
+^Iassert(!args->argv || args->allocated);$
ERROR: code indent should never use tabs
#454: FILE: tools/virtiofsd/fuse_opt.c:62:
+^Inewarg = strdup(arg);$
ERROR: code indent should never use tabs
#455: FILE: tools/virtiofsd/fuse_opt.c:63:
+^Iif (!newarg)$
ERROR: braces {} are necessary for all arms of this statement
#455: FILE: tools/virtiofsd/fuse_opt.c:63:
+ if (!newarg)
[...]
ERROR: code indent should never use tabs
#456: FILE: tools/virtiofsd/fuse_opt.c:64:
+^I^Ireturn alloc_failed();$
ERROR: code indent should never use tabs
#458: FILE: tools/virtiofsd/fuse_opt.c:66:
+^Inewargv = realloc(args->argv, (args->argc + 2) * sizeof(char *));$
ERROR: code indent should never use tabs
#459: FILE: tools/virtiofsd/fuse_opt.c:67:
+^Iif (!newargv) {$
ERROR: code indent should never use tabs
#460: FILE: tools/virtiofsd/fuse_opt.c:68:
+^I^Ifree(newarg);$
ERROR: code indent should never use tabs
#461: FILE: tools/virtiofsd/fuse_opt.c:69:
+^I^Ireturn alloc_failed();$
ERROR: code indent should never use tabs
#462: FILE: tools/virtiofsd/fuse_opt.c:70:
+^I}$
ERROR: code indent should never use tabs
#464: FILE: tools/virtiofsd/fuse_opt.c:72:
+^Iargs->argv = newargv;$
ERROR: code indent should never use tabs
#465: FILE: tools/virtiofsd/fuse_opt.c:73:
+^Iargs->allocated = 1;$
ERROR: code indent should never use tabs
#466: FILE: tools/virtiofsd/fuse_opt.c:74:
+^Iargs->argv[args->argc++] = newarg;$
ERROR: code indent should never use tabs
#467: FILE: tools/virtiofsd/fuse_opt.c:75:
+^Iargs->argv[args->argc] = NULL;$
ERROR: code indent should never use tabs
#468: FILE: tools/virtiofsd/fuse_opt.c:76:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#472: FILE: tools/virtiofsd/fuse_opt.c:80:
+^I^I^I^I const char *arg)$
ERROR: code indent should never use tabs
#474: FILE: tools/virtiofsd/fuse_opt.c:82:
+^Iassert(pos <= args->argc);$
ERROR: code indent should never use tabs
#475: FILE: tools/virtiofsd/fuse_opt.c:83:
+^Iif (fuse_opt_add_arg(args, arg) == -1)$
ERROR: braces {} are necessary for all arms of this statement
#475: FILE: tools/virtiofsd/fuse_opt.c:83:
+ if (fuse_opt_add_arg(args, arg) == -1)
[...]
ERROR: code indent should never use tabs
#476: FILE: tools/virtiofsd/fuse_opt.c:84:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#478: FILE: tools/virtiofsd/fuse_opt.c:86:
+^Iif (pos != args->argc - 1) {$
ERROR: code indent should never use tabs
#479: FILE: tools/virtiofsd/fuse_opt.c:87:
+^I^Ichar *newarg = args->argv[args->argc - 1];$
ERROR: code indent should never use tabs
#480: FILE: tools/virtiofsd/fuse_opt.c:88:
+^I^Imemmove(&args->argv[pos + 1], &args->argv[pos],$
ERROR: code indent should never use tabs
#481: FILE: tools/virtiofsd/fuse_opt.c:89:
+^I^I^Isizeof(char *) * (args->argc - pos - 1));$
ERROR: code indent should never use tabs
#482: FILE: tools/virtiofsd/fuse_opt.c:90:
+^I^Iargs->argv[pos] = newarg;$
ERROR: code indent should never use tabs
#483: FILE: tools/virtiofsd/fuse_opt.c:91:
+^I}$
ERROR: code indent should never use tabs
#484: FILE: tools/virtiofsd/fuse_opt.c:92:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#489: FILE: tools/virtiofsd/fuse_opt.c:97:
+^Ireturn fuse_opt_insert_arg_common(args, pos, arg);$
ERROR: code indent should never use tabs
#494: FILE: tools/virtiofsd/fuse_opt.c:102:
+^Iif (ctx->argctr + 1 >= ctx->argc) {$
WARNING: line over 80 characters
#495: FILE: tools/virtiofsd/fuse_opt.c:103:
+ fuse_log(FUSE_LOG_ERR, "fuse: missing argument after `%s'\n", opt);
ERROR: code indent should never use tabs
#495: FILE: tools/virtiofsd/fuse_opt.c:103:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: missing argument after `%s'\n", opt);$
ERROR: code indent should never use tabs
#496: FILE: tools/virtiofsd/fuse_opt.c:104:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#497: FILE: tools/virtiofsd/fuse_opt.c:105:
+^I}$
ERROR: code indent should never use tabs
#498: FILE: tools/virtiofsd/fuse_opt.c:106:
+^Ictx->argctr++;$
ERROR: code indent should never use tabs
#499: FILE: tools/virtiofsd/fuse_opt.c:107:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#504: FILE: tools/virtiofsd/fuse_opt.c:112:
+^Ireturn fuse_opt_add_arg(&ctx->outargs, arg);$
ERROR: code indent should never use tabs
#509: FILE: tools/virtiofsd/fuse_opt.c:117:
+^Iunsigned oldlen = *opts ? strlen(*opts) : 0;$
ERROR: code indent should never use tabs
#510: FILE: tools/virtiofsd/fuse_opt.c:118:
+^Ichar *d = realloc(*opts, oldlen + 1 + strlen(opt) * 2 + 1);$
ERROR: code indent should never use tabs
#512: FILE: tools/virtiofsd/fuse_opt.c:120:
+^Iif (!d)$
ERROR: braces {} are necessary for all arms of this statement
#512: FILE: tools/virtiofsd/fuse_opt.c:120:
+ if (!d)
[...]
ERROR: code indent should never use tabs
#513: FILE: tools/virtiofsd/fuse_opt.c:121:
+^I^Ireturn alloc_failed();$
ERROR: code indent should never use tabs
#515: FILE: tools/virtiofsd/fuse_opt.c:123:
+^I*opts = d;$
ERROR: code indent should never use tabs
#516: FILE: tools/virtiofsd/fuse_opt.c:124:
+^Iif (oldlen) {$
ERROR: code indent should never use tabs
#517: FILE: tools/virtiofsd/fuse_opt.c:125:
+^I^Id += oldlen;$
ERROR: code indent should never use tabs
#518: FILE: tools/virtiofsd/fuse_opt.c:126:
+^I^I*d++ = ',';$
ERROR: code indent should never use tabs
#519: FILE: tools/virtiofsd/fuse_opt.c:127:
+^I}$
ERROR: code indent should never use tabs
#521: FILE: tools/virtiofsd/fuse_opt.c:129:
+^Ifor (; *opt; opt++) {$
ERROR: code indent should never use tabs
#522: FILE: tools/virtiofsd/fuse_opt.c:130:
+^I^Iif (esc && (*opt == ',' || *opt == '\\'))$
ERROR: braces {} are necessary for all arms of this statement
#522: FILE: tools/virtiofsd/fuse_opt.c:130:
+ if (esc && (*opt == ',' || *opt == '\\'))
[...]
ERROR: code indent should never use tabs
#523: FILE: tools/virtiofsd/fuse_opt.c:131:
+^I^I^I*d++ = '\\';$
ERROR: code indent should never use tabs
#524: FILE: tools/virtiofsd/fuse_opt.c:132:
+^I^I*d++ = *opt;$
ERROR: code indent should never use tabs
#525: FILE: tools/virtiofsd/fuse_opt.c:133:
+^I}$
ERROR: code indent should never use tabs
#526: FILE: tools/virtiofsd/fuse_opt.c:134:
+^I*d = '\0';$
ERROR: code indent should never use tabs
#528: FILE: tools/virtiofsd/fuse_opt.c:136:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#533: FILE: tools/virtiofsd/fuse_opt.c:141:
+^Ireturn add_opt_common(opts, opt, 0);$
ERROR: code indent should never use tabs
#538: FILE: tools/virtiofsd/fuse_opt.c:146:
+^Ireturn add_opt_common(opts, opt, 1);$
ERROR: code indent should never use tabs
#543: FILE: tools/virtiofsd/fuse_opt.c:151:
+^Ireturn add_opt_common(&ctx->opts, opt, 1);$
ERROR: code indent should never use tabs
#547: FILE: tools/virtiofsd/fuse_opt.c:155:
+^I^I int iso)$
ERROR: code indent should never use tabs
#549: FILE: tools/virtiofsd/fuse_opt.c:157:
+^Iif (key == FUSE_OPT_KEY_DISCARD)$
ERROR: braces {} are necessary for all arms of this statement
#549: FILE: tools/virtiofsd/fuse_opt.c:157:
+ if (key == FUSE_OPT_KEY_DISCARD)
[...]
ERROR: code indent should never use tabs
#550: FILE: tools/virtiofsd/fuse_opt.c:158:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#552: FILE: tools/virtiofsd/fuse_opt.c:160:
+^Iif (key != FUSE_OPT_KEY_KEEP && ctx->proc) {$
ERROR: code indent should never use tabs
#553: FILE: tools/virtiofsd/fuse_opt.c:161:
+^I^Iint res = ctx->proc(ctx->data, arg, key, &ctx->outargs);$
ERROR: code indent should never use tabs
#554: FILE: tools/virtiofsd/fuse_opt.c:162:
+^I^Iif (res == -1 || !res)$
ERROR: braces {} are necessary for all arms of this statement
#554: FILE: tools/virtiofsd/fuse_opt.c:162:
+ if (res == -1 || !res)
[...]
ERROR: code indent should never use tabs
#555: FILE: tools/virtiofsd/fuse_opt.c:163:
+^I^I^Ireturn res;$
ERROR: code indent should never use tabs
#556: FILE: tools/virtiofsd/fuse_opt.c:164:
+^I}$
ERROR: code indent should never use tabs
#557: FILE: tools/virtiofsd/fuse_opt.c:165:
+^Iif (iso)$
ERROR: braces {} are necessary for all arms of this statement
#557: FILE: tools/virtiofsd/fuse_opt.c:165:
+ if (iso)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#558: FILE: tools/virtiofsd/fuse_opt.c:166:
+^I^Ireturn add_opt(ctx, arg);$
ERROR: code indent should never use tabs
#559: FILE: tools/virtiofsd/fuse_opt.c:167:
+^Ielse$
ERROR: code indent should never use tabs
#560: FILE: tools/virtiofsd/fuse_opt.c:168:
+^I^Ireturn add_arg(ctx, arg);$
ERROR: code indent should never use tabs
#565: FILE: tools/virtiofsd/fuse_opt.c:173:
+^Iint arglen = strlen(arg);$
ERROR: code indent should never use tabs
#566: FILE: tools/virtiofsd/fuse_opt.c:174:
+^Iconst char *sep = strchr(t, '=');$
ERROR: code indent should never use tabs
#567: FILE: tools/virtiofsd/fuse_opt.c:175:
+^Isep = sep ? sep : strchr(t, ' ');$
ERROR: code indent should never use tabs
#568: FILE: tools/virtiofsd/fuse_opt.c:176:
+^Iif (sep && (!sep[1] || sep[1] == '%')) {$
ERROR: code indent should never use tabs
#569: FILE: tools/virtiofsd/fuse_opt.c:177:
+^I^Iint tlen = sep - t;$
ERROR: code indent should never use tabs
#570: FILE: tools/virtiofsd/fuse_opt.c:178:
+^I^Iif (sep[0] == '=')$
ERROR: braces {} are necessary for all arms of this statement
#570: FILE: tools/virtiofsd/fuse_opt.c:178:
+ if (sep[0] == '=')
[...]
ERROR: code indent should never use tabs
#571: FILE: tools/virtiofsd/fuse_opt.c:179:
+^I^I^Itlen ++;$
ERROR: space prohibited before that '++' (ctx:WxO)
#571: FILE: tools/virtiofsd/fuse_opt.c:179:
+ tlen ++;
^
ERROR: code indent should never use tabs
#572: FILE: tools/virtiofsd/fuse_opt.c:180:
+^I^Iif (arglen >= tlen && strncmp(arg, t, tlen) == 0) {$
ERROR: code indent should never use tabs
#573: FILE: tools/virtiofsd/fuse_opt.c:181:
+^I^I^I*sepp = sep - t;$
ERROR: code indent should never use tabs
#574: FILE: tools/virtiofsd/fuse_opt.c:182:
+^I^I^Ireturn 1;$
ERROR: code indent should never use tabs
#575: FILE: tools/virtiofsd/fuse_opt.c:183:
+^I^I}$
ERROR: code indent should never use tabs
#576: FILE: tools/virtiofsd/fuse_opt.c:184:
+^I}$
ERROR: code indent should never use tabs
#577: FILE: tools/virtiofsd/fuse_opt.c:185:
+^Iif (strcmp(t, arg) == 0) {$
ERROR: code indent should never use tabs
#578: FILE: tools/virtiofsd/fuse_opt.c:186:
+^I^I*sepp = 0;$
ERROR: code indent should never use tabs
#579: FILE: tools/virtiofsd/fuse_opt.c:187:
+^I^Ireturn 1;$
ERROR: code indent should never use tabs
#580: FILE: tools/virtiofsd/fuse_opt.c:188:
+^I}$
ERROR: code indent should never use tabs
#581: FILE: tools/virtiofsd/fuse_opt.c:189:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#585: FILE: tools/virtiofsd/fuse_opt.c:193:
+^I^I^I^I const char *arg, unsigned *sepp)$
ERROR: code indent should never use tabs
#587: FILE: tools/virtiofsd/fuse_opt.c:195:
+^Ifor (; opt && opt->templ; opt++)$
ERROR: code indent should never use tabs
#588: FILE: tools/virtiofsd/fuse_opt.c:196:
+^I^Iif (match_template(opt->templ, arg, sepp))$
ERROR: braces {} are necessary for all arms of this statement
#588: FILE: tools/virtiofsd/fuse_opt.c:196:
+ if (match_template(opt->templ, arg, sepp))
[...]
ERROR: code indent should never use tabs
#589: FILE: tools/virtiofsd/fuse_opt.c:197:
+^I^I^Ireturn opt;$
ERROR: code indent should never use tabs
#590: FILE: tools/virtiofsd/fuse_opt.c:198:
+^Ireturn NULL;$
ERROR: code indent should never use tabs
#595: FILE: tools/virtiofsd/fuse_opt.c:203:
+^Iunsigned dummy;$
ERROR: code indent should never use tabs
#596: FILE: tools/virtiofsd/fuse_opt.c:204:
+^Ireturn find_opt(opts, opt, &dummy) ? 1 : 0;$
ERROR: code indent should never use tabs
#600: FILE: tools/virtiofsd/fuse_opt.c:208:
+^I^I^I const char *arg)$
ERROR: code indent should never use tabs
#602: FILE: tools/virtiofsd/fuse_opt.c:210:
+^Iassert(format[0] == '%');$
ERROR: code indent should never use tabs
#603: FILE: tools/virtiofsd/fuse_opt.c:211:
+^Iif (format[1] == 's') {$
ERROR: code indent should never use tabs
#604: FILE: tools/virtiofsd/fuse_opt.c:212:
+^I^Ichar **s = var;$
ERROR: code indent should never use tabs
#605: FILE: tools/virtiofsd/fuse_opt.c:213:
+^I^Ichar *copy = strdup(param);$
ERROR: code indent should never use tabs
#606: FILE: tools/virtiofsd/fuse_opt.c:214:
+^I^Iif (!copy)$
ERROR: braces {} are necessary for all arms of this statement
#606: FILE: tools/virtiofsd/fuse_opt.c:214:
+ if (!copy)
[...]
ERROR: code indent should never use tabs
#607: FILE: tools/virtiofsd/fuse_opt.c:215:
+^I^I^Ireturn alloc_failed();$
ERROR: code indent should never use tabs
#609: FILE: tools/virtiofsd/fuse_opt.c:217:
+^I^Ifree(*s);$
ERROR: code indent should never use tabs
#610: FILE: tools/virtiofsd/fuse_opt.c:218:
+^I^I*s = copy;$
ERROR: code indent should never use tabs
#611: FILE: tools/virtiofsd/fuse_opt.c:219:
+^I} else {$
ERROR: code indent should never use tabs
#612: FILE: tools/virtiofsd/fuse_opt.c:220:
+^I^Iif (sscanf(param, format, var) != 1) {$
ERROR: line over 90 characters
#613: FILE: tools/virtiofsd/fuse_opt.c:221:
+ fuse_log(FUSE_LOG_ERR, "fuse: invalid parameter in option `%s'\n", arg);
ERROR: code indent should never use tabs
#613: FILE: tools/virtiofsd/fuse_opt.c:221:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "fuse: invalid parameter in option `%s'\n", arg);$
ERROR: code indent should never use tabs
#614: FILE: tools/virtiofsd/fuse_opt.c:222:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#615: FILE: tools/virtiofsd/fuse_opt.c:223:
+^I^I}$
ERROR: code indent should never use tabs
#616: FILE: tools/virtiofsd/fuse_opt.c:224:
+^I}$
ERROR: code indent should never use tabs
#617: FILE: tools/virtiofsd/fuse_opt.c:225:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#621: FILE: tools/virtiofsd/fuse_opt.c:229:
+^I^I const struct fuse_opt *opt, unsigned sep,$
ERROR: code indent should never use tabs
#622: FILE: tools/virtiofsd/fuse_opt.c:230:
+^I^I const char *arg, int iso)$
ERROR: code indent should never use tabs
#624: FILE: tools/virtiofsd/fuse_opt.c:232:
+^Iif (opt->offset == -1U) {$
ERROR: code indent should never use tabs
#625: FILE: tools/virtiofsd/fuse_opt.c:233:
+^I^Iif (call_proc(ctx, arg, opt->value, iso) == -1)$
ERROR: braces {} are necessary for all arms of this statement
#625: FILE: tools/virtiofsd/fuse_opt.c:233:
+ if (call_proc(ctx, arg, opt->value, iso) == -1)
[...]
ERROR: code indent should never use tabs
#626: FILE: tools/virtiofsd/fuse_opt.c:234:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#627: FILE: tools/virtiofsd/fuse_opt.c:235:
+^I} else {$
ERROR: code indent should never use tabs
#628: FILE: tools/virtiofsd/fuse_opt.c:236:
+^I^Ivoid *var = (char *)ctx->data + opt->offset;$
ERROR: code indent should never use tabs
#629: FILE: tools/virtiofsd/fuse_opt.c:237:
+^I^Iif (sep && opt->templ[sep + 1]) {$
ERROR: code indent should never use tabs
#630: FILE: tools/virtiofsd/fuse_opt.c:238:
+^I^I^Iconst char *param = arg + sep;$
ERROR: code indent should never use tabs
#631: FILE: tools/virtiofsd/fuse_opt.c:239:
+^I^I^Iif (opt->templ[sep] == '=')$
ERROR: braces {} are necessary for all arms of this statement
#631: FILE: tools/virtiofsd/fuse_opt.c:239:
+ if (opt->templ[sep] == '=')
[...]
ERROR: code indent should never use tabs
#632: FILE: tools/virtiofsd/fuse_opt.c:240:
+^I^I^I^Iparam ++;$
ERROR: space prohibited before that '++' (ctx:WxO)
#632: FILE: tools/virtiofsd/fuse_opt.c:240:
+ param ++;
^
ERROR: code indent should never use tabs
#633: FILE: tools/virtiofsd/fuse_opt.c:241:
+^I^I^Iif (process_opt_param(var, opt->templ + sep + 1,$
ERROR: code indent should never use tabs
#634: FILE: tools/virtiofsd/fuse_opt.c:242:
+^I^I^I^I^I param, arg) == -1)$
ERROR: code indent should never use tabs
#635: FILE: tools/virtiofsd/fuse_opt.c:243:
+^I^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#636: FILE: tools/virtiofsd/fuse_opt.c:244:
+^I^I} else$
ERROR: code indent should never use tabs
#637: FILE: tools/virtiofsd/fuse_opt.c:245:
+^I^I^I*(int *)var = opt->value;$
ERROR: code indent should never use tabs
#638: FILE: tools/virtiofsd/fuse_opt.c:246:
+^I}$
ERROR: code indent should never use tabs
#639: FILE: tools/virtiofsd/fuse_opt.c:247:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#643: FILE: tools/virtiofsd/fuse_opt.c:251:
+^I^I^I const struct fuse_opt *opt, unsigned sep,$
ERROR: code indent should never use tabs
#644: FILE: tools/virtiofsd/fuse_opt.c:252:
+^I^I^I const char *arg, int iso)$
ERROR: code indent should never use tabs
#646: FILE: tools/virtiofsd/fuse_opt.c:254:
+^Iint res;$
ERROR: code indent should never use tabs
#647: FILE: tools/virtiofsd/fuse_opt.c:255:
+^Ichar *newarg;$
ERROR: code indent should never use tabs
#648: FILE: tools/virtiofsd/fuse_opt.c:256:
+^Ichar *param;$
ERROR: code indent should never use tabs
#650: FILE: tools/virtiofsd/fuse_opt.c:258:
+^Iif (next_arg(ctx, arg) == -1)$
ERROR: braces {} are necessary for all arms of this statement
#650: FILE: tools/virtiofsd/fuse_opt.c:258:
+ if (next_arg(ctx, arg) == -1)
[...]
ERROR: code indent should never use tabs
#651: FILE: tools/virtiofsd/fuse_opt.c:259:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#653: FILE: tools/virtiofsd/fuse_opt.c:261:
+^Iparam = ctx->argv[ctx->argctr];$
ERROR: code indent should never use tabs
#654: FILE: tools/virtiofsd/fuse_opt.c:262:
+^Inewarg = malloc(sep + strlen(param) + 1);$
ERROR: code indent should never use tabs
#655: FILE: tools/virtiofsd/fuse_opt.c:263:
+^Iif (!newarg)$
ERROR: braces {} are necessary for all arms of this statement
#655: FILE: tools/virtiofsd/fuse_opt.c:263:
+ if (!newarg)
[...]
ERROR: code indent should never use tabs
#656: FILE: tools/virtiofsd/fuse_opt.c:264:
+^I^Ireturn alloc_failed();$
ERROR: code indent should never use tabs
#658: FILE: tools/virtiofsd/fuse_opt.c:266:
+^Imemcpy(newarg, arg, sep);$
ERROR: code indent should never use tabs
#659: FILE: tools/virtiofsd/fuse_opt.c:267:
+^Istrcpy(newarg + sep, param);$
ERROR: code indent should never use tabs
#660: FILE: tools/virtiofsd/fuse_opt.c:268:
+^Ires = process_opt(ctx, opt, sep, newarg, iso);$
ERROR: code indent should never use tabs
#661: FILE: tools/virtiofsd/fuse_opt.c:269:
+^Ifree(newarg);$
ERROR: code indent should never use tabs
#663: FILE: tools/virtiofsd/fuse_opt.c:271:
+^Ireturn res;$
ERROR: code indent should never use tabs
#668: FILE: tools/virtiofsd/fuse_opt.c:276:
+^Iunsigned sep;$
ERROR: code indent should never use tabs
#669: FILE: tools/virtiofsd/fuse_opt.c:277:
+^Iconst struct fuse_opt *opt = find_opt(ctx->opt, arg, &sep);$
ERROR: code indent should never use tabs
#670: FILE: tools/virtiofsd/fuse_opt.c:278:
+^Iif (opt) {$
ERROR: code indent should never use tabs
#671: FILE: tools/virtiofsd/fuse_opt.c:279:
+^I^Ifor (; opt; opt = find_opt(opt + 1, arg, &sep)) {$
ERROR: code indent should never use tabs
#672: FILE: tools/virtiofsd/fuse_opt.c:280:
+^I^I^Iint res;$
ERROR: code indent should never use tabs
#673: FILE: tools/virtiofsd/fuse_opt.c:281:
+^I^I^Iif (sep && opt->templ[sep] == ' ' && !arg[sep])$
ERROR: code indent should never use tabs
#674: FILE: tools/virtiofsd/fuse_opt.c:282:
+^I^I^I^Ires = process_opt_sep_arg(ctx, opt, sep, arg,$
ERROR: code indent should never use tabs
#675: FILE: tools/virtiofsd/fuse_opt.c:283:
+^I^I^I^I^I^I^I iso);$
ERROR: code indent should never use tabs
#676: FILE: tools/virtiofsd/fuse_opt.c:284:
+^I^I^Ielse$
ERROR: code indent should never use tabs
#677: FILE: tools/virtiofsd/fuse_opt.c:285:
+^I^I^I^Ires = process_opt(ctx, opt, sep, arg, iso);$
ERROR: code indent should never use tabs
#678: FILE: tools/virtiofsd/fuse_opt.c:286:
+^I^I^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#678: FILE: tools/virtiofsd/fuse_opt.c:286:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#679: FILE: tools/virtiofsd/fuse_opt.c:287:
+^I^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#680: FILE: tools/virtiofsd/fuse_opt.c:288:
+^I^I}$
ERROR: code indent should never use tabs
#681: FILE: tools/virtiofsd/fuse_opt.c:289:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#682: FILE: tools/virtiofsd/fuse_opt.c:290:
+^I} else$
ERROR: code indent should never use tabs
#683: FILE: tools/virtiofsd/fuse_opt.c:291:
+^I^Ireturn call_proc(ctx, arg, FUSE_OPT_KEY_OPT, iso);$
ERROR: code indent should never use tabs
#688: FILE: tools/virtiofsd/fuse_opt.c:296:
+^Ichar *s = opts;$
ERROR: code indent should never use tabs
#689: FILE: tools/virtiofsd/fuse_opt.c:297:
+^Ichar *d = s;$
ERROR: code indent should never use tabs
#690: FILE: tools/virtiofsd/fuse_opt.c:298:
+^Iint end = 0;$
ERROR: code indent should never use tabs
#692: FILE: tools/virtiofsd/fuse_opt.c:300:
+^Iwhile (!end) {$
ERROR: code indent should never use tabs
#693: FILE: tools/virtiofsd/fuse_opt.c:301:
+^I^Iif (*s == '\0')$
ERROR: braces {} are necessary for all arms of this statement
#693: FILE: tools/virtiofsd/fuse_opt.c:301:
+ if (*s == '\0')
[...]
ERROR: code indent should never use tabs
#694: FILE: tools/virtiofsd/fuse_opt.c:302:
+^I^I^Iend = 1;$
ERROR: code indent should never use tabs
#695: FILE: tools/virtiofsd/fuse_opt.c:303:
+^I^Iif (*s == ',' || end) {$
ERROR: code indent should never use tabs
#696: FILE: tools/virtiofsd/fuse_opt.c:304:
+^I^I^Iint res;$
ERROR: code indent should never use tabs
#698: FILE: tools/virtiofsd/fuse_opt.c:306:
+^I^I^I*d = '\0';$
ERROR: code indent should never use tabs
#699: FILE: tools/virtiofsd/fuse_opt.c:307:
+^I^I^Ires = process_gopt(ctx, opts, 1);$
ERROR: code indent should never use tabs
#700: FILE: tools/virtiofsd/fuse_opt.c:308:
+^I^I^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#700: FILE: tools/virtiofsd/fuse_opt.c:308:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#701: FILE: tools/virtiofsd/fuse_opt.c:309:
+^I^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#702: FILE: tools/virtiofsd/fuse_opt.c:310:
+^I^I^Id = opts;$
ERROR: code indent should never use tabs
#703: FILE: tools/virtiofsd/fuse_opt.c:311:
+^I^I} else {$
ERROR: code indent should never use tabs
#704: FILE: tools/virtiofsd/fuse_opt.c:312:
+^I^I^Iif (s[0] == '\\' && s[1] != '\0') {$
ERROR: code indent should never use tabs
#705: FILE: tools/virtiofsd/fuse_opt.c:313:
+^I^I^I^Is++;$
ERROR: code indent should never use tabs
#706: FILE: tools/virtiofsd/fuse_opt.c:314:
+^I^I^I^Iif (s[0] >= '0' && s[0] <= '3' &&$
ERROR: code indent should never use tabs
#707: FILE: tools/virtiofsd/fuse_opt.c:315:
+^I^I^I^I s[1] >= '0' && s[1] <= '7' &&$
ERROR: code indent should never use tabs
#708: FILE: tools/virtiofsd/fuse_opt.c:316:
+^I^I^I^I s[2] >= '0' && s[2] <= '7') {$
ERROR: code indent should never use tabs
#709: FILE: tools/virtiofsd/fuse_opt.c:317:
+^I^I^I^I^I*d++ = (s[0] - '0') * 0100 +$
ERROR: code indent should never use tabs
#710: FILE: tools/virtiofsd/fuse_opt.c:318:
+^I^I^I^I^I^I(s[1] - '0') * 0010 +$
ERROR: code indent should never use tabs
#711: FILE: tools/virtiofsd/fuse_opt.c:319:
+^I^I^I^I^I^I(s[2] - '0');$
ERROR: code indent should never use tabs
#712: FILE: tools/virtiofsd/fuse_opt.c:320:
+^I^I^I^I^Is += 2;$
ERROR: code indent should never use tabs
#713: FILE: tools/virtiofsd/fuse_opt.c:321:
+^I^I^I^I} else {$
ERROR: code indent should never use tabs
#714: FILE: tools/virtiofsd/fuse_opt.c:322:
+^I^I^I^I^I*d++ = *s;$
ERROR: code indent should never use tabs
#715: FILE: tools/virtiofsd/fuse_opt.c:323:
+^I^I^I^I}$
ERROR: code indent should never use tabs
#716: FILE: tools/virtiofsd/fuse_opt.c:324:
+^I^I^I} else {$
ERROR: code indent should never use tabs
#717: FILE: tools/virtiofsd/fuse_opt.c:325:
+^I^I^I^I*d++ = *s;$
ERROR: code indent should never use tabs
#718: FILE: tools/virtiofsd/fuse_opt.c:326:
+^I^I^I}$
ERROR: code indent should never use tabs
#719: FILE: tools/virtiofsd/fuse_opt.c:327:
+^I^I}$
ERROR: code indent should never use tabs
#720: FILE: tools/virtiofsd/fuse_opt.c:328:
+^I^Is++;$
ERROR: code indent should never use tabs
#721: FILE: tools/virtiofsd/fuse_opt.c:329:
+^I}$
ERROR: code indent should never use tabs
#723: FILE: tools/virtiofsd/fuse_opt.c:331:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#728: FILE: tools/virtiofsd/fuse_opt.c:336:
+^Iint res;$
ERROR: code indent should never use tabs
#729: FILE: tools/virtiofsd/fuse_opt.c:337:
+^Ichar *copy = strdup(opts);$
ERROR: code indent should never use tabs
#731: FILE: tools/virtiofsd/fuse_opt.c:339:
+^Iif (!copy) {$
ERROR: code indent should never use tabs
#732: FILE: tools/virtiofsd/fuse_opt.c:340:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");$
ERROR: code indent should never use tabs
#733: FILE: tools/virtiofsd/fuse_opt.c:341:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#734: FILE: tools/virtiofsd/fuse_opt.c:342:
+^I}$
ERROR: code indent should never use tabs
#735: FILE: tools/virtiofsd/fuse_opt.c:343:
+^Ires = process_real_option_group(ctx, copy);$
ERROR: code indent should never use tabs
#736: FILE: tools/virtiofsd/fuse_opt.c:344:
+^Ifree(copy);$
ERROR: code indent should never use tabs
#737: FILE: tools/virtiofsd/fuse_opt.c:345:
+^Ireturn res;$
ERROR: code indent should never use tabs
#742: FILE: tools/virtiofsd/fuse_opt.c:350:
+^Iif (ctx->nonopt || arg[0] != '-')$
ERROR: code indent should never use tabs
#743: FILE: tools/virtiofsd/fuse_opt.c:351:
+^I^Ireturn call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);$
ERROR: code indent should never use tabs
#744: FILE: tools/virtiofsd/fuse_opt.c:352:
+^Ielse if (arg[1] == 'o') {$
ERROR: code indent should never use tabs
#745: FILE: tools/virtiofsd/fuse_opt.c:353:
+^I^Iif (arg[2])$
ERROR: code indent should never use tabs
#746: FILE: tools/virtiofsd/fuse_opt.c:354:
+^I^I^Ireturn process_option_group(ctx, arg + 2);$
ERROR: code indent should never use tabs
#747: FILE: tools/virtiofsd/fuse_opt.c:355:
+^I^Ielse {$
ERROR: code indent should never use tabs
#748: FILE: tools/virtiofsd/fuse_opt.c:356:
+^I^I^Iif (next_arg(ctx, arg) == -1)$
ERROR: braces {} are necessary for all arms of this statement
#748: FILE: tools/virtiofsd/fuse_opt.c:356:
+ if (next_arg(ctx, arg) == -1)
[...]
ERROR: code indent should never use tabs
#749: FILE: tools/virtiofsd/fuse_opt.c:357:
+^I^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#751: FILE: tools/virtiofsd/fuse_opt.c:359:
+^I^I^Ireturn process_option_group(ctx,$
ERROR: code indent should never use tabs
#752: FILE: tools/virtiofsd/fuse_opt.c:360:
+^I^I^I^I^I^I ctx->argv[ctx->argctr]);$
ERROR: code indent should never use tabs
#753: FILE: tools/virtiofsd/fuse_opt.c:361:
+^I^I}$
ERROR: code indent should never use tabs
#754: FILE: tools/virtiofsd/fuse_opt.c:362:
+^I} else if (arg[1] == '-' && !arg[2]) {$
ERROR: code indent should never use tabs
#755: FILE: tools/virtiofsd/fuse_opt.c:363:
+^I^Iif (add_arg(ctx, arg) == -1)$
ERROR: braces {} are necessary for all arms of this statement
#755: FILE: tools/virtiofsd/fuse_opt.c:363:
+ if (add_arg(ctx, arg) == -1)
[...]
ERROR: code indent should never use tabs
#756: FILE: tools/virtiofsd/fuse_opt.c:364:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#757: FILE: tools/virtiofsd/fuse_opt.c:365:
+^I^Ictx->nonopt = ctx->outargs.argc;$
ERROR: code indent should never use tabs
#758: FILE: tools/virtiofsd/fuse_opt.c:366:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#759: FILE: tools/virtiofsd/fuse_opt.c:367:
+^I} else$
ERROR: code indent should never use tabs
#760: FILE: tools/virtiofsd/fuse_opt.c:368:
+^I^Ireturn process_gopt(ctx, arg, 0);$
ERROR: code indent should never use tabs
#765: FILE: tools/virtiofsd/fuse_opt.c:373:
+^Iif (ctx->argc) {$
ERROR: code indent should never use tabs
#766: FILE: tools/virtiofsd/fuse_opt.c:374:
+^I^Iif (add_arg(ctx, ctx->argv[0]) == -1)$
ERROR: braces {} are necessary for all arms of this statement
#766: FILE: tools/virtiofsd/fuse_opt.c:374:
+ if (add_arg(ctx, ctx->argv[0]) == -1)
[...]
ERROR: code indent should never use tabs
#767: FILE: tools/virtiofsd/fuse_opt.c:375:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#768: FILE: tools/virtiofsd/fuse_opt.c:376:
+^I}$
ERROR: code indent should never use tabs
#770: FILE: tools/virtiofsd/fuse_opt.c:378:
+^Ifor (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)$
ERROR: code indent should never use tabs
#771: FILE: tools/virtiofsd/fuse_opt.c:379:
+^I^Iif (process_one(ctx, ctx->argv[ctx->argctr]) == -1)$
ERROR: braces {} are necessary for all arms of this statement
#771: FILE: tools/virtiofsd/fuse_opt.c:379:
+ if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
[...]
ERROR: code indent should never use tabs
#772: FILE: tools/virtiofsd/fuse_opt.c:380:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#774: FILE: tools/virtiofsd/fuse_opt.c:382:
+^Iif (ctx->opts) {$
ERROR: code indent should never use tabs
#775: FILE: tools/virtiofsd/fuse_opt.c:383:
+^I^Iif (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||$
ERROR: code indent should never use tabs
#776: FILE: tools/virtiofsd/fuse_opt.c:384:
+^I^I fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)$
ERROR: code indent should never use tabs
#777: FILE: tools/virtiofsd/fuse_opt.c:385:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#778: FILE: tools/virtiofsd/fuse_opt.c:386:
+^I}$
ERROR: code indent should never use tabs
#780: FILE: tools/virtiofsd/fuse_opt.c:388:
+^I/* If option separator ("--") is the last argument, remove it */$
ERROR: code indent should never use tabs
#781: FILE: tools/virtiofsd/fuse_opt.c:389:
+^Iif (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&$
ERROR: code indent should never use tabs
#782: FILE: tools/virtiofsd/fuse_opt.c:390:
+^I strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {$
ERROR: code indent should never use tabs
#783: FILE: tools/virtiofsd/fuse_opt.c:391:
+^I^Ifree(ctx->outargs.argv[ctx->outargs.argc - 1]);$
ERROR: code indent should never use tabs
#784: FILE: tools/virtiofsd/fuse_opt.c:392:
+^I^Ictx->outargs.argv[--ctx->outargs.argc] = NULL;$
ERROR: code indent should never use tabs
#785: FILE: tools/virtiofsd/fuse_opt.c:393:
+^I}$
ERROR: code indent should never use tabs
#787: FILE: tools/virtiofsd/fuse_opt.c:395:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#791: FILE: tools/virtiofsd/fuse_opt.c:399:
+^I^I const struct fuse_opt opts[], fuse_opt_proc_t proc)$
ERROR: code indent should never use tabs
#793: FILE: tools/virtiofsd/fuse_opt.c:401:
+^Iint res;$
ERROR: code indent should never use tabs
#794: FILE: tools/virtiofsd/fuse_opt.c:402:
+^Istruct fuse_opt_context ctx = {$
ERROR: code indent should never use tabs
#795: FILE: tools/virtiofsd/fuse_opt.c:403:
+^I^I.data = data,$
ERROR: code indent should never use tabs
#796: FILE: tools/virtiofsd/fuse_opt.c:404:
+^I^I.opt = opts,$
ERROR: code indent should never use tabs
#797: FILE: tools/virtiofsd/fuse_opt.c:405:
+^I^I.proc = proc,$
ERROR: code indent should never use tabs
#798: FILE: tools/virtiofsd/fuse_opt.c:406:
+^I};$
ERROR: code indent should never use tabs
#800: FILE: tools/virtiofsd/fuse_opt.c:408:
+^Iif (!args || !args->argv || !args->argc)$
ERROR: braces {} are necessary for all arms of this statement
#800: FILE: tools/virtiofsd/fuse_opt.c:408:
+ if (!args || !args->argv || !args->argc)
[...]
ERROR: code indent should never use tabs
#801: FILE: tools/virtiofsd/fuse_opt.c:409:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#803: FILE: tools/virtiofsd/fuse_opt.c:411:
+^Ictx.argc = args->argc;$
ERROR: code indent should never use tabs
#804: FILE: tools/virtiofsd/fuse_opt.c:412:
+^Ictx.argv = args->argv;$
ERROR: code indent should never use tabs
#806: FILE: tools/virtiofsd/fuse_opt.c:414:
+^Ires = opt_parse(&ctx);$
ERROR: code indent should never use tabs
#807: FILE: tools/virtiofsd/fuse_opt.c:415:
+^Iif (res != -1) {$
ERROR: code indent should never use tabs
#808: FILE: tools/virtiofsd/fuse_opt.c:416:
+^I^Istruct fuse_args tmp = *args;$
ERROR: code indent should never use tabs
#809: FILE: tools/virtiofsd/fuse_opt.c:417:
+^I^I*args = ctx.outargs;$
ERROR: code indent should never use tabs
#810: FILE: tools/virtiofsd/fuse_opt.c:418:
+^I^Ictx.outargs = tmp;$
ERROR: code indent should never use tabs
#811: FILE: tools/virtiofsd/fuse_opt.c:419:
+^I}$
ERROR: code indent should never use tabs
#812: FILE: tools/virtiofsd/fuse_opt.c:420:
+^Ifree(ctx.opts);$
ERROR: code indent should never use tabs
#813: FILE: tools/virtiofsd/fuse_opt.c:421:
+^Ifuse_opt_free_args(&ctx.outargs);$
ERROR: code indent should never use tabs
#814: FILE: tools/virtiofsd/fuse_opt.c:422:
+^Ireturn res;$
WARNING: Block comments use * on subsequent lines
#823: FILE: tools/virtiofsd/fuse_signals.c:2:
+/*
+ FUSE: Filesystem in Userspace
ERROR: code indent should never use tabs
#845: FILE: tools/virtiofsd/fuse_signals.c:24:
+^Iif (fuse_instance) {$
ERROR: code indent should never use tabs
#846: FILE: tools/virtiofsd/fuse_signals.c:25:
+^I^Ifuse_session_exit(fuse_instance);$
ERROR: code indent should never use tabs
#847: FILE: tools/virtiofsd/fuse_signals.c:26:
+^I^Iif(sig <= 0) {$
ERROR: space required before the open parenthesis '('
#847: FILE: tools/virtiofsd/fuse_signals.c:26:
+ if(sig <= 0) {
WARNING: line over 80 characters
#848: FILE: tools/virtiofsd/fuse_signals.c:27:
+ fuse_log(FUSE_LOG_ERR, "assertion error: signal value <= 0\n");
ERROR: code indent should never use tabs
#848: FILE: tools/virtiofsd/fuse_signals.c:27:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "assertion error: signal value <= 0\n");$
ERROR: code indent should never use tabs
#849: FILE: tools/virtiofsd/fuse_signals.c:28:
+^I^I^Iabort();$
ERROR: code indent should never use tabs
#850: FILE: tools/virtiofsd/fuse_signals.c:29:
+^I^I}$
ERROR: code indent should never use tabs
#851: FILE: tools/virtiofsd/fuse_signals.c:30:
+^I^Ifuse_instance->error = sig;$
ERROR: code indent should never use tabs
#852: FILE: tools/virtiofsd/fuse_signals.c:31:
+^I}$
ERROR: code indent should never use tabs
#857: FILE: tools/virtiofsd/fuse_signals.c:36:
+^I(void) sig;$
ERROR: code indent should never use tabs
#862: FILE: tools/virtiofsd/fuse_signals.c:41:
+^Istruct sigaction sa;$
ERROR: code indent should never use tabs
#863: FILE: tools/virtiofsd/fuse_signals.c:42:
+^Istruct sigaction old_sa;$
ERROR: code indent should never use tabs
#865: FILE: tools/virtiofsd/fuse_signals.c:44:
+^Imemset(&sa, 0, sizeof(struct sigaction));$
ERROR: code indent should never use tabs
#866: FILE: tools/virtiofsd/fuse_signals.c:45:
+^Isa.sa_handler = remove ? SIG_DFL : handler;$
ERROR: code indent should never use tabs
#867: FILE: tools/virtiofsd/fuse_signals.c:46:
+^Isigemptyset(&(sa.sa_mask));$
ERROR: code indent should never use tabs
#868: FILE: tools/virtiofsd/fuse_signals.c:47:
+^Isa.sa_flags = 0;$
ERROR: code indent should never use tabs
#870: FILE: tools/virtiofsd/fuse_signals.c:49:
+^Iif (sigaction(sig, NULL, &old_sa) == -1) {$
ERROR: code indent should never use tabs
#871: FILE: tools/virtiofsd/fuse_signals.c:50:
+^I^Iperror("fuse: cannot get old signal handler");$
ERROR: code indent should never use tabs
#872: FILE: tools/virtiofsd/fuse_signals.c:51:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#873: FILE: tools/virtiofsd/fuse_signals.c:52:
+^I}$
ERROR: code indent should never use tabs
#875: FILE: tools/virtiofsd/fuse_signals.c:54:
+^Iif (old_sa.sa_handler == (remove ? handler : SIG_DFL) &&$
ERROR: code indent should never use tabs
#876: FILE: tools/virtiofsd/fuse_signals.c:55:
+^I sigaction(sig, &sa, NULL) == -1) {$
ERROR: code indent should never use tabs
#877: FILE: tools/virtiofsd/fuse_signals.c:56:
+^I^Iperror("fuse: cannot set signal handler");$
ERROR: code indent should never use tabs
#878: FILE: tools/virtiofsd/fuse_signals.c:57:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#879: FILE: tools/virtiofsd/fuse_signals.c:58:
+^I}$
ERROR: code indent should never use tabs
#880: FILE: tools/virtiofsd/fuse_signals.c:59:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#885: FILE: tools/virtiofsd/fuse_signals.c:64:
+^I/* If we used SIG_IGN instead of the do_nothing function,$
WARNING: Block comments use a leading /* on a separate line
#885: FILE: tools/virtiofsd/fuse_signals.c:64:
+ /* If we used SIG_IGN instead of the do_nothing function,
ERROR: code indent should never use tabs
#886: FILE: tools/virtiofsd/fuse_signals.c:65:
+^I then we would be unable to tell if we set SIG_IGN (and$
WARNING: Block comments use * on subsequent lines
#886: FILE: tools/virtiofsd/fuse_signals.c:65:
+ /* If we used SIG_IGN instead of the do_nothing function,
+ then we would be unable to tell if we set SIG_IGN (and
ERROR: code indent should never use tabs
#887: FILE: tools/virtiofsd/fuse_signals.c:66:
+^I thus should reset to SIG_DFL in fuse_remove_signal_handlers)$
ERROR: code indent should never use tabs
#888: FILE: tools/virtiofsd/fuse_signals.c:67:
+^I or if it was already set to SIG_IGN (and should be left$
ERROR: code indent should never use tabs
#889: FILE: tools/virtiofsd/fuse_signals.c:68:
+^I untouched. */$
WARNING: Block comments use a trailing */ on a separate line
#889: FILE: tools/virtiofsd/fuse_signals.c:68:
+ untouched. */
ERROR: code indent should never use tabs
#890: FILE: tools/virtiofsd/fuse_signals.c:69:
+^Iif (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||$
ERROR: code indent should never use tabs
#891: FILE: tools/virtiofsd/fuse_signals.c:70:
+^I set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||$
ERROR: code indent should never use tabs
#892: FILE: tools/virtiofsd/fuse_signals.c:71:
+^I set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||$
ERROR: code indent should never use tabs
#893: FILE: tools/virtiofsd/fuse_signals.c:72:
+^I set_one_signal_handler(SIGPIPE, do_nothing, 0) == -1)$
ERROR: code indent should never use tabs
#894: FILE: tools/virtiofsd/fuse_signals.c:73:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#896: FILE: tools/virtiofsd/fuse_signals.c:75:
+^Ifuse_instance = se;$
ERROR: code indent should never use tabs
#897: FILE: tools/virtiofsd/fuse_signals.c:76:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#902: FILE: tools/virtiofsd/fuse_signals.c:81:
+^Iif (fuse_instance != se)$
ERROR: code indent should never use tabs
#903: FILE: tools/virtiofsd/fuse_signals.c:82:
+^I^Ifuse_log(FUSE_LOG_ERR,$
ERROR: code indent should never use tabs
#904: FILE: tools/virtiofsd/fuse_signals.c:83:
+^I^I^I"fuse: fuse_remove_signal_handlers: unknown session\n");$
ERROR: code indent should never use tabs
#905: FILE: tools/virtiofsd/fuse_signals.c:84:
+^Ielse$
ERROR: code indent should never use tabs
#906: FILE: tools/virtiofsd/fuse_signals.c:85:
+^I^Ifuse_instance = NULL;$
ERROR: code indent should never use tabs
#908: FILE: tools/virtiofsd/fuse_signals.c:87:
+^Iset_one_signal_handler(SIGHUP, exit_handler, 1);$
ERROR: code indent should never use tabs
#909: FILE: tools/virtiofsd/fuse_signals.c:88:
+^Iset_one_signal_handler(SIGINT, exit_handler, 1);$
ERROR: code indent should never use tabs
#910: FILE: tools/virtiofsd/fuse_signals.c:89:
+^Iset_one_signal_handler(SIGTERM, exit_handler, 1);$
ERROR: code indent should never use tabs
#911: FILE: tools/virtiofsd/fuse_signals.c:90:
+^Iset_one_signal_handler(SIGPIPE, do_nothing, 1);$
WARNING: Block comments use * on subsequent lines
#920: FILE: tools/virtiofsd/helper.c:2:
+/*
+ FUSE: Filesystem in Userspace
ERROR: code indent should never use tabs
#948: FILE: tools/virtiofsd/helper.c:30:
+^I{ t, offsetof(struct fuse_cmdline_opts, p), 1 }$
ERROR: code indent should never use tabs
#951: FILE: tools/virtiofsd/helper.c:33:
+^IFUSE_HELPER_OPT("-h",^I^Ishow_help),$
ERROR: code indent should never use tabs
#952: FILE: tools/virtiofsd/helper.c:34:
+^IFUSE_HELPER_OPT("--help",^Ishow_help),$
ERROR: code indent should never use tabs
#953: FILE: tools/virtiofsd/helper.c:35:
+^IFUSE_HELPER_OPT("-V",^I^Ishow_version),$
ERROR: code indent should never use tabs
#954: FILE: tools/virtiofsd/helper.c:36:
+^IFUSE_HELPER_OPT("--version",^Ishow_version),$
ERROR: code indent should never use tabs
#955: FILE: tools/virtiofsd/helper.c:37:
+^IFUSE_HELPER_OPT("-d",^I^Idebug),$
ERROR: code indent should never use tabs
#956: FILE: tools/virtiofsd/helper.c:38:
+^IFUSE_HELPER_OPT("debug",^Idebug),$
ERROR: code indent should never use tabs
#957: FILE: tools/virtiofsd/helper.c:39:
+^IFUSE_HELPER_OPT("-d",^I^Iforeground),$
ERROR: code indent should never use tabs
#958: FILE: tools/virtiofsd/helper.c:40:
+^IFUSE_HELPER_OPT("debug",^Iforeground),$
ERROR: code indent should never use tabs
#959: FILE: tools/virtiofsd/helper.c:41:
+^IFUSE_OPT_KEY("-d",^I^IFUSE_OPT_KEY_KEEP),$
ERROR: code indent should never use tabs
#960: FILE: tools/virtiofsd/helper.c:42:
+^IFUSE_OPT_KEY("debug",^I^IFUSE_OPT_KEY_KEEP),$
ERROR: code indent should never use tabs
#961: FILE: tools/virtiofsd/helper.c:43:
+^IFUSE_HELPER_OPT("-f",^I^Iforeground),$
ERROR: code indent should never use tabs
#962: FILE: tools/virtiofsd/helper.c:44:
+^IFUSE_HELPER_OPT("-s",^I^Isinglethread),$
ERROR: code indent should never use tabs
#963: FILE: tools/virtiofsd/helper.c:45:
+^IFUSE_HELPER_OPT("fsname=",^Inodefault_subtype),$
ERROR: code indent should never use tabs
#964: FILE: tools/virtiofsd/helper.c:46:
+^IFUSE_OPT_KEY("fsname=",^I^IFUSE_OPT_KEY_KEEP),$
WARNING: architecture specific defines should be avoided
#965: FILE: tools/virtiofsd/helper.c:47:
+#ifndef __FreeBSD__
ERROR: code indent should never use tabs
#966: FILE: tools/virtiofsd/helper.c:48:
+^IFUSE_HELPER_OPT("subtype=",^Inodefault_subtype),$
ERROR: code indent should never use tabs
#967: FILE: tools/virtiofsd/helper.c:49:
+^IFUSE_OPT_KEY("subtype=",^IFUSE_OPT_KEY_KEEP),$
ERROR: code indent should never use tabs
#969: FILE: tools/virtiofsd/helper.c:51:
+^IFUSE_HELPER_OPT("clone_fd",^Iclone_fd),$
ERROR: code indent should never use tabs
#970: FILE: tools/virtiofsd/helper.c:52:
+^IFUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),$
ERROR: code indent should never use tabs
#971: FILE: tools/virtiofsd/helper.c:53:
+^IFUSE_OPT_END$
ERROR: code indent should never use tabs
#975: FILE: tools/virtiofsd/helper.c:57:
+^Iint atomic_o_trunc;$
ERROR: code indent should never use tabs
#976: FILE: tools/virtiofsd/helper.c:58:
+^Iint no_remote_posix_lock;$
ERROR: code indent should never use tabs
#977: FILE: tools/virtiofsd/helper.c:59:
+^Iint no_remote_flock;$
ERROR: code indent should never use tabs
#978: FILE: tools/virtiofsd/helper.c:60:
+^Iint splice_write;$
ERROR: code indent should never use tabs
#979: FILE: tools/virtiofsd/helper.c:61:
+^Iint splice_move;$
ERROR: code indent should never use tabs
#980: FILE: tools/virtiofsd/helper.c:62:
+^Iint splice_read;$
ERROR: code indent should never use tabs
#981: FILE: tools/virtiofsd/helper.c:63:
+^Iint no_splice_write;$
ERROR: code indent should never use tabs
#982: FILE: tools/virtiofsd/helper.c:64:
+^Iint no_splice_move;$
ERROR: code indent should never use tabs
#983: FILE: tools/virtiofsd/helper.c:65:
+^Iint no_splice_read;$
ERROR: code indent should never use tabs
#984: FILE: tools/virtiofsd/helper.c:66:
+^Iint auto_inval_data;$
ERROR: code indent should never use tabs
#985: FILE: tools/virtiofsd/helper.c:67:
+^Iint no_auto_inval_data;$
ERROR: code indent should never use tabs
#986: FILE: tools/virtiofsd/helper.c:68:
+^Iint no_readdirplus;$
ERROR: code indent should never use tabs
#987: FILE: tools/virtiofsd/helper.c:69:
+^Iint no_readdirplus_auto;$
ERROR: code indent should never use tabs
#988: FILE: tools/virtiofsd/helper.c:70:
+^Iint async_dio;$
ERROR: code indent should never use tabs
#989: FILE: tools/virtiofsd/helper.c:71:
+^Iint no_async_dio;$
ERROR: code indent should never use tabs
#990: FILE: tools/virtiofsd/helper.c:72:
+^Iint writeback_cache;$
ERROR: code indent should never use tabs
#991: FILE: tools/virtiofsd/helper.c:73:
+^Iint no_writeback_cache;$
ERROR: code indent should never use tabs
#992: FILE: tools/virtiofsd/helper.c:74:
+^Iint async_read;$
ERROR: code indent should never use tabs
#993: FILE: tools/virtiofsd/helper.c:75:
+^Iint sync_read;$
ERROR: code indent should never use tabs
#994: FILE: tools/virtiofsd/helper.c:76:
+^Iunsigned max_write;$
ERROR: code indent should never use tabs
#995: FILE: tools/virtiofsd/helper.c:77:
+^Iunsigned max_readahead;$
ERROR: code indent should never use tabs
#996: FILE: tools/virtiofsd/helper.c:78:
+^Iunsigned max_background;$
ERROR: code indent should never use tabs
#997: FILE: tools/virtiofsd/helper.c:79:
+^Iunsigned congestion_threshold;$
ERROR: code indent should never use tabs
#998: FILE: tools/virtiofsd/helper.c:80:
+^Iunsigned time_gran;$
ERROR: code indent should never use tabs
#999: FILE: tools/virtiofsd/helper.c:81:
+^Iint set_max_write;$
ERROR: code indent should never use tabs
#1000: FILE: tools/virtiofsd/helper.c:82:
+^Iint set_max_readahead;$
ERROR: code indent should never use tabs
#1001: FILE: tools/virtiofsd/helper.c:83:
+^Iint set_max_background;$
ERROR: code indent should never use tabs
#1002: FILE: tools/virtiofsd/helper.c:84:
+^Iint set_congestion_threshold;$
ERROR: code indent should never use tabs
#1003: FILE: tools/virtiofsd/helper.c:85:
+^Iint set_time_gran;$
ERROR: code indent should never use tabs
#1006: FILE: tools/virtiofsd/helper.c:88:
+#define CONN_OPTION(t, p, v)^I^I^I^I^I\$
ERROR: code indent should never use tabs
#1007: FILE: tools/virtiofsd/helper.c:89:
+^I{ t, offsetof(struct fuse_conn_info_opts, p), v }$
ERROR: code indent should never use tabs
#1009: FILE: tools/virtiofsd/helper.c:91:
+^ICONN_OPTION("max_write=%u", max_write, 0),$
ERROR: code indent should never use tabs
#1010: FILE: tools/virtiofsd/helper.c:92:
+^ICONN_OPTION("max_write=", set_max_write, 1),$
ERROR: code indent should never use tabs
#1011: FILE: tools/virtiofsd/helper.c:93:
+^ICONN_OPTION("max_readahead=%u", max_readahead, 0),$
ERROR: code indent should never use tabs
#1012: FILE: tools/virtiofsd/helper.c:94:
+^ICONN_OPTION("max_readahead=", set_max_readahead, 1),$
ERROR: code indent should never use tabs
#1013: FILE: tools/virtiofsd/helper.c:95:
+^ICONN_OPTION("max_background=%u", max_background, 0),$
ERROR: code indent should never use tabs
#1014: FILE: tools/virtiofsd/helper.c:96:
+^ICONN_OPTION("max_background=", set_max_background, 1),$
ERROR: code indent should never use tabs
#1015: FILE: tools/virtiofsd/helper.c:97:
+^ICONN_OPTION("congestion_threshold=%u", congestion_threshold, 0),$
ERROR: code indent should never use tabs
#1016: FILE: tools/virtiofsd/helper.c:98:
+^ICONN_OPTION("congestion_threshold=", set_congestion_threshold, 1),$
ERROR: code indent should never use tabs
#1017: FILE: tools/virtiofsd/helper.c:99:
+^ICONN_OPTION("sync_read", sync_read, 1),$
ERROR: code indent should never use tabs
#1018: FILE: tools/virtiofsd/helper.c:100:
+^ICONN_OPTION("async_read", async_read, 1),$
ERROR: code indent should never use tabs
#1019: FILE: tools/virtiofsd/helper.c:101:
+^ICONN_OPTION("atomic_o_trunc", atomic_o_trunc, 1),$
ERROR: code indent should never use tabs
#1020: FILE: tools/virtiofsd/helper.c:102:
+^ICONN_OPTION("no_remote_lock", no_remote_posix_lock, 1),$
ERROR: code indent should never use tabs
#1021: FILE: tools/virtiofsd/helper.c:103:
+^ICONN_OPTION("no_remote_lock", no_remote_flock, 1),$
ERROR: code indent should never use tabs
#1022: FILE: tools/virtiofsd/helper.c:104:
+^ICONN_OPTION("no_remote_flock", no_remote_flock, 1),$
ERROR: code indent should never use tabs
#1023: FILE: tools/virtiofsd/helper.c:105:
+^ICONN_OPTION("no_remote_posix_lock", no_remote_posix_lock, 1),$
ERROR: code indent should never use tabs
#1024: FILE: tools/virtiofsd/helper.c:106:
+^ICONN_OPTION("splice_write", splice_write, 1),$
ERROR: code indent should never use tabs
#1025: FILE: tools/virtiofsd/helper.c:107:
+^ICONN_OPTION("no_splice_write", no_splice_write, 1),$
ERROR: code indent should never use tabs
#1026: FILE: tools/virtiofsd/helper.c:108:
+^ICONN_OPTION("splice_move", splice_move, 1),$
ERROR: code indent should never use tabs
#1027: FILE: tools/virtiofsd/helper.c:109:
+^ICONN_OPTION("no_splice_move", no_splice_move, 1),$
ERROR: code indent should never use tabs
#1028: FILE: tools/virtiofsd/helper.c:110:
+^ICONN_OPTION("splice_read", splice_read, 1),$
ERROR: code indent should never use tabs
#1029: FILE: tools/virtiofsd/helper.c:111:
+^ICONN_OPTION("no_splice_read", no_splice_read, 1),$
ERROR: code indent should never use tabs
#1030: FILE: tools/virtiofsd/helper.c:112:
+^ICONN_OPTION("auto_inval_data", auto_inval_data, 1),$
ERROR: code indent should never use tabs
#1031: FILE: tools/virtiofsd/helper.c:113:
+^ICONN_OPTION("no_auto_inval_data", no_auto_inval_data, 1),$
ERROR: code indent should never use tabs
#1032: FILE: tools/virtiofsd/helper.c:114:
+^ICONN_OPTION("readdirplus=no", no_readdirplus, 1),$
ERROR: code indent should never use tabs
#1033: FILE: tools/virtiofsd/helper.c:115:
+^ICONN_OPTION("readdirplus=yes", no_readdirplus, 0),$
ERROR: code indent should never use tabs
#1034: FILE: tools/virtiofsd/helper.c:116:
+^ICONN_OPTION("readdirplus=yes", no_readdirplus_auto, 1),$
ERROR: code indent should never use tabs
#1035: FILE: tools/virtiofsd/helper.c:117:
+^ICONN_OPTION("readdirplus=auto", no_readdirplus, 0),$
ERROR: code indent should never use tabs
#1036: FILE: tools/virtiofsd/helper.c:118:
+^ICONN_OPTION("readdirplus=auto", no_readdirplus_auto, 0),$
ERROR: code indent should never use tabs
#1037: FILE: tools/virtiofsd/helper.c:119:
+^ICONN_OPTION("async_dio", async_dio, 1),$
ERROR: code indent should never use tabs
#1038: FILE: tools/virtiofsd/helper.c:120:
+^ICONN_OPTION("no_async_dio", no_async_dio, 1),$
ERROR: code indent should never use tabs
#1039: FILE: tools/virtiofsd/helper.c:121:
+^ICONN_OPTION("writeback_cache", writeback_cache, 1),$
ERROR: code indent should never use tabs
#1040: FILE: tools/virtiofsd/helper.c:122:
+^ICONN_OPTION("no_writeback_cache", no_writeback_cache, 1),$
ERROR: code indent should never use tabs
#1041: FILE: tools/virtiofsd/helper.c:123:
+^ICONN_OPTION("time_gran=%u", time_gran, 0),$
ERROR: code indent should never use tabs
#1042: FILE: tools/virtiofsd/helper.c:124:
+^ICONN_OPTION("time_gran=", set_time_gran, 1),$
ERROR: code indent should never use tabs
#1043: FILE: tools/virtiofsd/helper.c:125:
+^IFUSE_OPT_END$
ERROR: code indent should never use tabs
#1049: FILE: tools/virtiofsd/helper.c:131:
+^Iprintf(" -h --help print help\n"$
ERROR: code indent should never use tabs
#1050: FILE: tools/virtiofsd/helper.c:132:
+^I " -V --version print version\n"$
ERROR: code indent should never use tabs
#1051: FILE: tools/virtiofsd/helper.c:133:
+^I " -d -o debug enable debug output (implies -f)\n"$
ERROR: code indent should never use tabs
#1052: FILE: tools/virtiofsd/helper.c:134:
+^I " -f foreground operation\n"$
ERROR: code indent should never use tabs
#1053: FILE: tools/virtiofsd/helper.c:135:
+^I " -s disable multi-threaded operation\n"$
ERROR: code indent should never use tabs
#1054: FILE: tools/virtiofsd/helper.c:136:
+^I " -o clone_fd use separate fuse device fd for each thread\n"$
ERROR: code indent should never use tabs
#1055: FILE: tools/virtiofsd/helper.c:137:
+^I " (may improve performance)\n"$
ERROR: code indent should never use tabs
#1056: FILE: tools/virtiofsd/helper.c:138:
+^I " -o max_idle_threads the maximum number of idle worker threads\n"$
ERROR: code indent should never use tabs
#1057: FILE: tools/virtiofsd/helper.c:139:
+^I " allowed (default: 10)\n");$
ERROR: code indent should never use tabs
#1061: FILE: tools/virtiofsd/helper.c:143:
+^I^I^I^Istruct fuse_args *outargs)$
ERROR: code indent should never use tabs
#1063: FILE: tools/virtiofsd/helper.c:145:
+^I(void) outargs;$
ERROR: code indent should never use tabs
#1064: FILE: tools/virtiofsd/helper.c:146:
+^Istruct fuse_cmdline_opts *opts = data;$
ERROR: code indent should never use tabs
#1066: FILE: tools/virtiofsd/helper.c:148:
+^Iswitch (key) {$
ERROR: code indent should never use tabs
#1067: FILE: tools/virtiofsd/helper.c:149:
+^Icase FUSE_OPT_KEY_NONOPT:$
ERROR: code indent should never use tabs
#1068: FILE: tools/virtiofsd/helper.c:150:
+^I^Iif (!opts->mountpoint) {$
ERROR: code indent should never use tabs
#1069: FILE: tools/virtiofsd/helper.c:151:
+^I^I^Iif (fuse_mnt_parse_fuse_fd(arg) != -1) {$
ERROR: code indent should never use tabs
#1070: FILE: tools/virtiofsd/helper.c:152:
+^I^I^I^Ireturn fuse_opt_add_opt(&opts->mountpoint, arg);$
ERROR: code indent should never use tabs
#1071: FILE: tools/virtiofsd/helper.c:153:
+^I^I^I}$
ERROR: code indent should never use tabs
#1073: FILE: tools/virtiofsd/helper.c:155:
+^I^I^Ichar mountpoint[PATH_MAX] = "";$
ERROR: code indent should never use tabs
#1074: FILE: tools/virtiofsd/helper.c:156:
+^I^I^Iif (realpath(arg, mountpoint) == NULL) {$
ERROR: code indent should never use tabs
#1075: FILE: tools/virtiofsd/helper.c:157:
+^I^I^I^Ifuse_log(FUSE_LOG_ERR,$
ERROR: code indent should never use tabs
#1076: FILE: tools/virtiofsd/helper.c:158:
+^I^I^I^I^I"fuse: bad mount point `%s': %s\n",$
ERROR: code indent should never use tabs
#1077: FILE: tools/virtiofsd/helper.c:159:
+^I^I^I^I^Iarg, strerror(errno));$
ERROR: code indent should never use tabs
#1078: FILE: tools/virtiofsd/helper.c:160:
+^I^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1079: FILE: tools/virtiofsd/helper.c:161:
+^I^I^I}$
ERROR: code indent should never use tabs
#1080: FILE: tools/virtiofsd/helper.c:162:
+^I^I^Ireturn fuse_opt_add_opt(&opts->mountpoint, mountpoint);$
ERROR: code indent should never use tabs
#1081: FILE: tools/virtiofsd/helper.c:163:
+^I^I} else {$
WARNING: line over 80 characters
#1082: FILE: tools/virtiofsd/helper.c:164:
+ fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
ERROR: code indent should never use tabs
#1082: FILE: tools/virtiofsd/helper.c:164:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);$
ERROR: code indent should never use tabs
#1083: FILE: tools/virtiofsd/helper.c:165:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1084: FILE: tools/virtiofsd/helper.c:166:
+^I^I}$
ERROR: code indent should never use tabs
#1086: FILE: tools/virtiofsd/helper.c:168:
+^Idefault:$
ERROR: code indent should never use tabs
#1087: FILE: tools/virtiofsd/helper.c:169:
+^I^I/* Pass through unknown options */$
ERROR: code indent should never use tabs
#1088: FILE: tools/virtiofsd/helper.c:170:
+^I^Ireturn 1;$
ERROR: code indent should never use tabs
#1089: FILE: tools/virtiofsd/helper.c:171:
+^I}$
WARNING: Block comments use a leading /* on a separate line
#1092: FILE: tools/virtiofsd/helper.c:174:
+/* Under FreeBSD, there is no subtype option so this
WARNING: Block comments use * on subsequent lines
#1093: FILE: tools/virtiofsd/helper.c:175:
+/* Under FreeBSD, there is no subtype option so this
+ function actually sets the fsname */
WARNING: Block comments use a trailing */ on a separate line
#1093: FILE: tools/virtiofsd/helper.c:175:
+ function actually sets the fsname */
ERROR: code indent should never use tabs
#1096: FILE: tools/virtiofsd/helper.c:178:
+^Iint res;$
ERROR: code indent should never use tabs
#1097: FILE: tools/virtiofsd/helper.c:179:
+^Ichar *subtype_opt;$
ERROR: code indent should never use tabs
#1099: FILE: tools/virtiofsd/helper.c:181:
+^Iconst char *basename = strrchr(progname, '/');$
ERROR: code indent should never use tabs
#1100: FILE: tools/virtiofsd/helper.c:182:
+^Iif (basename == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#1100: FILE: tools/virtiofsd/helper.c:182:
+ if (basename == NULL)
[...]
+ else if (basename[1] != '\0')
[...]
ERROR: code indent should never use tabs
#1101: FILE: tools/virtiofsd/helper.c:183:
+^I^Ibasename = progname;$
ERROR: code indent should never use tabs
#1102: FILE: tools/virtiofsd/helper.c:184:
+^Ielse if (basename[1] != '\0')$
ERROR: braces {} are necessary for all arms of this statement
#1102: FILE: tools/virtiofsd/helper.c:184:
+ else if (basename[1] != '\0')
[...]
ERROR: code indent should never use tabs
#1103: FILE: tools/virtiofsd/helper.c:185:
+^I^Ibasename++;$
ERROR: code indent should never use tabs
#1105: FILE: tools/virtiofsd/helper.c:187:
+^Isubtype_opt = (char *) malloc(strlen(basename) + 64);$
ERROR: code indent should never use tabs
#1106: FILE: tools/virtiofsd/helper.c:188:
+^Iif (subtype_opt == NULL) {$
ERROR: code indent should never use tabs
#1107: FILE: tools/virtiofsd/helper.c:189:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");$
ERROR: code indent should never use tabs
#1108: FILE: tools/virtiofsd/helper.c:190:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1109: FILE: tools/virtiofsd/helper.c:191:
+^I}$
WARNING: architecture specific defines should be avoided
#1110: FILE: tools/virtiofsd/helper.c:192:
+#ifdef __FreeBSD__
ERROR: code indent should never use tabs
#1111: FILE: tools/virtiofsd/helper.c:193:
+^Isprintf(subtype_opt, "-ofsname=%s", basename);$
ERROR: code indent should never use tabs
#1113: FILE: tools/virtiofsd/helper.c:195:
+^Isprintf(subtype_opt, "-osubtype=%s", basename);$
ERROR: code indent should never use tabs
#1115: FILE: tools/virtiofsd/helper.c:197:
+^Ires = fuse_opt_add_arg(args, subtype_opt);$
ERROR: code indent should never use tabs
#1116: FILE: tools/virtiofsd/helper.c:198:
+^Ifree(subtype_opt);$
ERROR: code indent should never use tabs
#1117: FILE: tools/virtiofsd/helper.c:199:
+^Ireturn res;$
ERROR: code indent should never use tabs
#1121: FILE: tools/virtiofsd/helper.c:203:
+^I^I struct fuse_cmdline_opts *opts)$
ERROR: code indent should never use tabs
#1123: FILE: tools/virtiofsd/helper.c:205:
+^Imemset(opts, 0, sizeof(struct fuse_cmdline_opts));$
ERROR: code indent should never use tabs
#1125: FILE: tools/virtiofsd/helper.c:207:
+^Iopts->max_idle_threads = 10;$
ERROR: code indent should never use tabs
#1127: FILE: tools/virtiofsd/helper.c:209:
+^Iif (fuse_opt_parse(args, opts, fuse_helper_opts,$
ERROR: code indent should never use tabs
#1128: FILE: tools/virtiofsd/helper.c:210:
+^I^I^I fuse_helper_opt_proc) == -1)$
ERROR: code indent should never use tabs
#1129: FILE: tools/virtiofsd/helper.c:211:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1131: FILE: tools/virtiofsd/helper.c:213:
+^I/* *Linux*: if neither -o subtype nor -o fsname are specified,$
WARNING: Block comments use a leading /* on a separate line
#1131: FILE: tools/virtiofsd/helper.c:213:
+ /* *Linux*: if neither -o subtype nor -o fsname are specified,
ERROR: code indent should never use tabs
#1132: FILE: tools/virtiofsd/helper.c:214:
+^I set subtype to program's basename.$
WARNING: Block comments use * on subsequent lines
#1132: FILE: tools/virtiofsd/helper.c:214:
+ /* *Linux*: if neither -o subtype nor -o fsname are specified,
+ set subtype to program's basename.
ERROR: code indent should never use tabs
#1133: FILE: tools/virtiofsd/helper.c:215:
+^I *FreeBSD*: if fsname is not specified, set to program's$
ERROR: code indent should never use tabs
#1134: FILE: tools/virtiofsd/helper.c:216:
+^I basename. */$
WARNING: Block comments use a trailing */ on a separate line
#1134: FILE: tools/virtiofsd/helper.c:216:
+ basename. */
ERROR: code indent should never use tabs
#1135: FILE: tools/virtiofsd/helper.c:217:
+^Iif (!opts->nodefault_subtype)$
ERROR: code indent should never use tabs
#1136: FILE: tools/virtiofsd/helper.c:218:
+^I^Iif (add_default_subtype(args->argv[0], args) == -1)$
ERROR: braces {} are necessary for all arms of this statement
#1136: FILE: tools/virtiofsd/helper.c:218:
+ if (add_default_subtype(args->argv[0], args) == -1)
[...]
ERROR: code indent should never use tabs
#1137: FILE: tools/virtiofsd/helper.c:219:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1139: FILE: tools/virtiofsd/helper.c:221:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#1145: FILE: tools/virtiofsd/helper.c:227:
+^Iif (!foreground) {$
ERROR: code indent should never use tabs
#1146: FILE: tools/virtiofsd/helper.c:228:
+^I^Iint nullfd;$
ERROR: code indent should never use tabs
#1147: FILE: tools/virtiofsd/helper.c:229:
+^I^Iint waiter[2];$
ERROR: code indent should never use tabs
#1148: FILE: tools/virtiofsd/helper.c:230:
+^I^Ichar completed;$
ERROR: code indent should never use tabs
#1150: FILE: tools/virtiofsd/helper.c:232:
+^I^Iif (pipe(waiter)) {$
ERROR: code indent should never use tabs
#1151: FILE: tools/virtiofsd/helper.c:233:
+^I^I^Iperror("fuse_daemonize: pipe");$
ERROR: code indent should never use tabs
#1152: FILE: tools/virtiofsd/helper.c:234:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1153: FILE: tools/virtiofsd/helper.c:235:
+^I^I}$
ERROR: code indent should never use tabs
#1155: FILE: tools/virtiofsd/helper.c:237:
+^I^I/*$
ERROR: code indent should never use tabs
#1156: FILE: tools/virtiofsd/helper.c:238:
+^I^I * demonize current process by forking it and killing the$
ERROR: code indent should never use tabs
#1157: FILE: tools/virtiofsd/helper.c:239:
+^I^I * parent. This makes current process as a child of 'init'.$
ERROR: code indent should never use tabs
#1158: FILE: tools/virtiofsd/helper.c:240:
+^I^I */$
ERROR: code indent should never use tabs
#1159: FILE: tools/virtiofsd/helper.c:241:
+^I^Iswitch(fork()) {$
ERROR: space required before the open parenthesis '('
#1159: FILE: tools/virtiofsd/helper.c:241:
+ switch(fork()) {
ERROR: code indent should never use tabs
#1160: FILE: tools/virtiofsd/helper.c:242:
+^I^Icase -1:$
ERROR: code indent should never use tabs
#1161: FILE: tools/virtiofsd/helper.c:243:
+^I^I^Iperror("fuse_daemonize: fork");$
ERROR: code indent should never use tabs
#1162: FILE: tools/virtiofsd/helper.c:244:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1163: FILE: tools/virtiofsd/helper.c:245:
+^I^Icase 0:$
ERROR: code indent should never use tabs
#1164: FILE: tools/virtiofsd/helper.c:246:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#1165: FILE: tools/virtiofsd/helper.c:247:
+^I^Idefault:$
ERROR: code indent should never use tabs
#1166: FILE: tools/virtiofsd/helper.c:248:
+^I^I^I(void) read(waiter[0], &completed, sizeof(completed));$
ERROR: code indent should never use tabs
#1167: FILE: tools/virtiofsd/helper.c:249:
+^I^I^I_exit(0);$
ERROR: code indent should never use tabs
#1168: FILE: tools/virtiofsd/helper.c:250:
+^I^I}$
ERROR: code indent should never use tabs
#1170: FILE: tools/virtiofsd/helper.c:252:
+^I^Iif (setsid() == -1) {$
ERROR: code indent should never use tabs
#1171: FILE: tools/virtiofsd/helper.c:253:
+^I^I^Iperror("fuse_daemonize: setsid");$
ERROR: code indent should never use tabs
#1172: FILE: tools/virtiofsd/helper.c:254:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1173: FILE: tools/virtiofsd/helper.c:255:
+^I^I}$
ERROR: code indent should never use tabs
#1175: FILE: tools/virtiofsd/helper.c:257:
+^I^I(void) chdir("/");$
ERROR: code indent should never use tabs
#1177: FILE: tools/virtiofsd/helper.c:259:
+^I^Inullfd = open("/dev/null", O_RDWR, 0);$
ERROR: code indent should never use tabs
#1178: FILE: tools/virtiofsd/helper.c:260:
+^I^Iif (nullfd != -1) {$
ERROR: code indent should never use tabs
#1179: FILE: tools/virtiofsd/helper.c:261:
+^I^I^I(void) dup2(nullfd, 0);$
ERROR: code indent should never use tabs
#1180: FILE: tools/virtiofsd/helper.c:262:
+^I^I^I(void) dup2(nullfd, 1);$
ERROR: code indent should never use tabs
#1181: FILE: tools/virtiofsd/helper.c:263:
+^I^I^I(void) dup2(nullfd, 2);$
ERROR: code indent should never use tabs
#1182: FILE: tools/virtiofsd/helper.c:264:
+^I^I^Iif (nullfd > 2)$
ERROR: braces {} are necessary for all arms of this statement
#1182: FILE: tools/virtiofsd/helper.c:264:
+ if (nullfd > 2)
[...]
ERROR: code indent should never use tabs
#1183: FILE: tools/virtiofsd/helper.c:265:
+^I^I^I^Iclose(nullfd);$
ERROR: code indent should never use tabs
#1184: FILE: tools/virtiofsd/helper.c:266:
+^I^I}$
ERROR: code indent should never use tabs
#1186: FILE: tools/virtiofsd/helper.c:268:
+^I^I/* Propagate completion of daemon initialization */$
ERROR: code indent should never use tabs
#1187: FILE: tools/virtiofsd/helper.c:269:
+^I^Icompleted = 1;$
ERROR: code indent should never use tabs
#1188: FILE: tools/virtiofsd/helper.c:270:
+^I^I(void) write(waiter[1], &completed, sizeof(completed));$
ERROR: code indent should never use tabs
#1189: FILE: tools/virtiofsd/helper.c:271:
+^I^Iclose(waiter[0]);$
ERROR: code indent should never use tabs
#1190: FILE: tools/virtiofsd/helper.c:272:
+^I^Iclose(waiter[1]);$
ERROR: code indent should never use tabs
#1191: FILE: tools/virtiofsd/helper.c:273:
+^I} else {$
ERROR: code indent should never use tabs
#1192: FILE: tools/virtiofsd/helper.c:274:
+^I^I(void) chdir("/");$
ERROR: code indent should never use tabs
#1193: FILE: tools/virtiofsd/helper.c:275:
+^I}$
ERROR: code indent should never use tabs
#1194: FILE: tools/virtiofsd/helper.c:276:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#1198: FILE: tools/virtiofsd/helper.c:280:
+^I^I size_t op_size, void *user_data)$
ERROR: code indent should never use tabs
#1200: FILE: tools/virtiofsd/helper.c:282:
+^Istruct fuse_args args = FUSE_ARGS_INIT(argc, argv);$
ERROR: code indent should never use tabs
#1201: FILE: tools/virtiofsd/helper.c:283:
+^Istruct fuse *fuse;$
ERROR: code indent should never use tabs
#1202: FILE: tools/virtiofsd/helper.c:284:
+^Istruct fuse_cmdline_opts opts;$
ERROR: code indent should never use tabs
#1203: FILE: tools/virtiofsd/helper.c:285:
+^Iint res;$
ERROR: code indent should never use tabs
#1205: FILE: tools/virtiofsd/helper.c:287:
+^Iif (fuse_parse_cmdline(&args, &opts) != 0)$
ERROR: braces {} are necessary for all arms of this statement
#1205: FILE: tools/virtiofsd/helper.c:287:
+ if (fuse_parse_cmdline(&args, &opts) != 0)
[...]
ERROR: code indent should never use tabs
#1206: FILE: tools/virtiofsd/helper.c:288:
+^I^Ireturn 1;$
ERROR: code indent should never use tabs
#1208: FILE: tools/virtiofsd/helper.c:290:
+^Iif (opts.show_version) {$
ERROR: code indent should never use tabs
#1209: FILE: tools/virtiofsd/helper.c:291:
+^I^Iprintf("FUSE library version %s\n", PACKAGE_VERSION);$
ERROR: code indent should never use tabs
#1210: FILE: tools/virtiofsd/helper.c:292:
+^I^Ifuse_lowlevel_version();$
ERROR: code indent should never use tabs
#1211: FILE: tools/virtiofsd/helper.c:293:
+^I^Ires = 0;$
ERROR: code indent should never use tabs
#1212: FILE: tools/virtiofsd/helper.c:294:
+^I^Igoto out1;$
ERROR: code indent should never use tabs
#1213: FILE: tools/virtiofsd/helper.c:295:
+^I}$
ERROR: code indent should never use tabs
#1215: FILE: tools/virtiofsd/helper.c:297:
+^Iif (opts.show_help) {$
ERROR: code indent should never use tabs
#1216: FILE: tools/virtiofsd/helper.c:298:
+^I^Iif(args.argv[0][0] != '\0')$
ERROR: space required before the open parenthesis '('
#1216: FILE: tools/virtiofsd/helper.c:298:
+ if(args.argv[0][0] != '\0')
ERROR: code indent should never use tabs
#1217: FILE: tools/virtiofsd/helper.c:299:
+^I^I^Iprintf("usage: %s [options] <mountpoint>\n\n",$
ERROR: code indent should never use tabs
#1218: FILE: tools/virtiofsd/helper.c:300:
+^I^I^I args.argv[0]);$
ERROR: code indent should never use tabs
#1219: FILE: tools/virtiofsd/helper.c:301:
+^I^Iprintf("FUSE options:\n");$
ERROR: code indent should never use tabs
#1220: FILE: tools/virtiofsd/helper.c:302:
+^I^Ifuse_cmdline_help();$
ERROR: code indent should never use tabs
#1221: FILE: tools/virtiofsd/helper.c:303:
+^I^Ifuse_lib_help(&args);$
ERROR: code indent should never use tabs
#1222: FILE: tools/virtiofsd/helper.c:304:
+^I^Ires = 0;$
ERROR: code indent should never use tabs
#1223: FILE: tools/virtiofsd/helper.c:305:
+^I^Igoto out1;$
ERROR: code indent should never use tabs
#1224: FILE: tools/virtiofsd/helper.c:306:
+^I}$
ERROR: code indent should never use tabs
#1226: FILE: tools/virtiofsd/helper.c:308:
+^Iif (!opts.show_help &&$
ERROR: code indent should never use tabs
#1227: FILE: tools/virtiofsd/helper.c:309:
+^I !opts.mountpoint) {$
ERROR: code indent should never use tabs
#1228: FILE: tools/virtiofsd/helper.c:310:
+^I^Ifuse_log(FUSE_LOG_ERR, "error: no mountpoint specified\n");$
ERROR: code indent should never use tabs
#1229: FILE: tools/virtiofsd/helper.c:311:
+^I^Ires = 2;$
ERROR: code indent should never use tabs
#1230: FILE: tools/virtiofsd/helper.c:312:
+^I^Igoto out1;$
ERROR: code indent should never use tabs
#1231: FILE: tools/virtiofsd/helper.c:313:
+^I}$
ERROR: code indent should never use tabs
#1234: FILE: tools/virtiofsd/helper.c:316:
+^Ifuse = fuse_new_31(&args, op, op_size, user_data);$
ERROR: code indent should never use tabs
#1235: FILE: tools/virtiofsd/helper.c:317:
+^Iif (fuse == NULL) {$
ERROR: code indent should never use tabs
#1236: FILE: tools/virtiofsd/helper.c:318:
+^I^Ires = 3;$
ERROR: code indent should never use tabs
#1237: FILE: tools/virtiofsd/helper.c:319:
+^I^Igoto out1;$
ERROR: code indent should never use tabs
#1238: FILE: tools/virtiofsd/helper.c:320:
+^I}$
ERROR: code indent should never use tabs
#1240: FILE: tools/virtiofsd/helper.c:322:
+^Iif (fuse_mount(fuse,opts.mountpoint) != 0) {$
ERROR: space required after that ',' (ctx:VxV)
#1240: FILE: tools/virtiofsd/helper.c:322:
+ if (fuse_mount(fuse,opts.mountpoint) != 0) {
^
ERROR: code indent should never use tabs
#1241: FILE: tools/virtiofsd/helper.c:323:
+^I^Ires = 4;$
ERROR: code indent should never use tabs
#1242: FILE: tools/virtiofsd/helper.c:324:
+^I^Igoto out2;$
ERROR: code indent should never use tabs
#1243: FILE: tools/virtiofsd/helper.c:325:
+^I}$
ERROR: code indent should never use tabs
#1245: FILE: tools/virtiofsd/helper.c:327:
+^Iif (fuse_daemonize(opts.foreground) != 0) {$
ERROR: code indent should never use tabs
#1246: FILE: tools/virtiofsd/helper.c:328:
+^I^Ires = 5;$
ERROR: code indent should never use tabs
#1247: FILE: tools/virtiofsd/helper.c:329:
+^I^Igoto out3;$
ERROR: code indent should never use tabs
#1248: FILE: tools/virtiofsd/helper.c:330:
+^I}$
ERROR: code indent should never use tabs
#1250: FILE: tools/virtiofsd/helper.c:332:
+^Istruct fuse_session *se = fuse_get_session(fuse);$
ERROR: code indent should never use tabs
#1251: FILE: tools/virtiofsd/helper.c:333:
+^Iif (fuse_set_signal_handlers(se) != 0) {$
ERROR: code indent should never use tabs
#1252: FILE: tools/virtiofsd/helper.c:334:
+^I^Ires = 6;$
ERROR: code indent should never use tabs
#1253: FILE: tools/virtiofsd/helper.c:335:
+^I^Igoto out3;$
ERROR: code indent should never use tabs
#1254: FILE: tools/virtiofsd/helper.c:336:
+^I}$
ERROR: code indent should never use tabs
#1256: FILE: tools/virtiofsd/helper.c:338:
+^Iif (opts.singlethread)$
ERROR: code indent should never use tabs
#1257: FILE: tools/virtiofsd/helper.c:339:
+^I^Ires = fuse_loop(fuse);$
ERROR: code indent should never use tabs
#1258: FILE: tools/virtiofsd/helper.c:340:
+^Ielse {$
ERROR: code indent should never use tabs
#1259: FILE: tools/virtiofsd/helper.c:341:
+^I^Istruct fuse_loop_config loop_config;$
ERROR: code indent should never use tabs
#1260: FILE: tools/virtiofsd/helper.c:342:
+^I^Iloop_config.clone_fd = opts.clone_fd;$
ERROR: code indent should never use tabs
#1261: FILE: tools/virtiofsd/helper.c:343:
+^I^Iloop_config.max_idle_threads = opts.max_idle_threads;$
ERROR: code indent should never use tabs
#1262: FILE: tools/virtiofsd/helper.c:344:
+^I^Ires = fuse_loop_mt_32(fuse, &loop_config);$
ERROR: code indent should never use tabs
#1263: FILE: tools/virtiofsd/helper.c:345:
+^I}$
ERROR: code indent should never use tabs
#1264: FILE: tools/virtiofsd/helper.c:346:
+^Iif (res)$
ERROR: braces {} are necessary for all arms of this statement
#1264: FILE: tools/virtiofsd/helper.c:346:
+ if (res)
[...]
ERROR: code indent should never use tabs
#1265: FILE: tools/virtiofsd/helper.c:347:
+^I^Ires = 7;$
ERROR: code indent should never use tabs
#1267: FILE: tools/virtiofsd/helper.c:349:
+^Ifuse_remove_signal_handlers(se);$
ERROR: code indent should never use tabs
#1269: FILE: tools/virtiofsd/helper.c:351:
+^Ifuse_unmount(fuse);$
ERROR: code indent should never use tabs
#1271: FILE: tools/virtiofsd/helper.c:353:
+^Ifuse_destroy(fuse);$
ERROR: code indent should never use tabs
#1273: FILE: tools/virtiofsd/helper.c:355:
+^Ifree(opts.mountpoint);$
ERROR: code indent should never use tabs
#1274: FILE: tools/virtiofsd/helper.c:356:
+^Ifuse_opt_free_args(&args);$
ERROR: code indent should never use tabs
#1275: FILE: tools/virtiofsd/helper.c:357:
+^Ireturn res;$
ERROR: code indent should never use tabs
#1280: FILE: tools/virtiofsd/helper.c:362:
+^I^I^I struct fuse_conn_info *conn)$
ERROR: code indent should never use tabs
#1282: FILE: tools/virtiofsd/helper.c:364:
+^Iif(opts->set_max_write)$
ERROR: space required before the open parenthesis '('
#1282: FILE: tools/virtiofsd/helper.c:364:
+ if(opts->set_max_write)
ERROR: braces {} are necessary for all arms of this statement
#1282: FILE: tools/virtiofsd/helper.c:364:
+ if(opts->set_max_write)
[...]
ERROR: code indent should never use tabs
#1283: FILE: tools/virtiofsd/helper.c:365:
+^I^Iconn->max_write = opts->max_write;$
ERROR: code indent should never use tabs
#1284: FILE: tools/virtiofsd/helper.c:366:
+^Iif(opts->set_max_background)$
ERROR: space required before the open parenthesis '('
#1284: FILE: tools/virtiofsd/helper.c:366:
+ if(opts->set_max_background)
ERROR: braces {} are necessary for all arms of this statement
#1284: FILE: tools/virtiofsd/helper.c:366:
+ if(opts->set_max_background)
[...]
ERROR: code indent should never use tabs
#1285: FILE: tools/virtiofsd/helper.c:367:
+^I^Iconn->max_background = opts->max_background;$
ERROR: code indent should never use tabs
#1286: FILE: tools/virtiofsd/helper.c:368:
+^Iif(opts->set_congestion_threshold)$
ERROR: space required before the open parenthesis '('
#1286: FILE: tools/virtiofsd/helper.c:368:
+ if(opts->set_congestion_threshold)
ERROR: braces {} are necessary for all arms of this statement
#1286: FILE: tools/virtiofsd/helper.c:368:
+ if(opts->set_congestion_threshold)
[...]
ERROR: code indent should never use tabs
#1287: FILE: tools/virtiofsd/helper.c:369:
+^I^Iconn->congestion_threshold = opts->congestion_threshold;$
ERROR: code indent should never use tabs
#1288: FILE: tools/virtiofsd/helper.c:370:
+^Iif(opts->set_time_gran)$
ERROR: space required before the open parenthesis '('
#1288: FILE: tools/virtiofsd/helper.c:370:
+ if(opts->set_time_gran)
ERROR: braces {} are necessary for all arms of this statement
#1288: FILE: tools/virtiofsd/helper.c:370:
+ if(opts->set_time_gran)
[...]
ERROR: code indent should never use tabs
#1289: FILE: tools/virtiofsd/helper.c:371:
+^I^Iconn->time_gran = opts->time_gran;$
ERROR: code indent should never use tabs
#1290: FILE: tools/virtiofsd/helper.c:372:
+^Iif(opts->set_max_readahead)$
ERROR: space required before the open parenthesis '('
#1290: FILE: tools/virtiofsd/helper.c:372:
+ if(opts->set_max_readahead)
ERROR: braces {} are necessary for all arms of this statement
#1290: FILE: tools/virtiofsd/helper.c:372:
+ if(opts->set_max_readahead)
[...]
ERROR: code indent should never use tabs
#1291: FILE: tools/virtiofsd/helper.c:373:
+^I^Iconn->max_readahead = opts->max_readahead;$
ERROR: space required after that ',' (ctx:VxV)
#1293: FILE: tools/virtiofsd/helper.c:375:
+#define LL_ENABLE(cond,cap) \
^
ERROR: Macros with complex values should be enclosed in parenthesis
#1293: FILE: tools/virtiofsd/helper.c:375:
+#define LL_ENABLE(cond,cap) \
+ if (cond) conn->want |= (cap)
ERROR: code indent should never use tabs
#1294: FILE: tools/virtiofsd/helper.c:376:
+^Iif (cond) conn->want |= (cap)$
ERROR: trailing statements should be on next line
#1294: FILE: tools/virtiofsd/helper.c:376:
+ if (cond) conn->want |= (cap)
ERROR: space required after that ',' (ctx:VxV)
#1295: FILE: tools/virtiofsd/helper.c:377:
+#define LL_DISABLE(cond,cap) \
^
ERROR: Macros with complex values should be enclosed in parenthesis
#1295: FILE: tools/virtiofsd/helper.c:377:
+#define LL_DISABLE(cond,cap) \
+ if (cond) conn->want &= ~(cap)
ERROR: code indent should never use tabs
#1296: FILE: tools/virtiofsd/helper.c:378:
+^Iif (cond) conn->want &= ~(cap)$
ERROR: trailing statements should be on next line
#1296: FILE: tools/virtiofsd/helper.c:378:
+ if (cond) conn->want &= ~(cap)
ERROR: code indent should never use tabs
#1298: FILE: tools/virtiofsd/helper.c:380:
+^ILL_ENABLE(opts->splice_read, FUSE_CAP_SPLICE_READ);$
ERROR: code indent should never use tabs
#1299: FILE: tools/virtiofsd/helper.c:381:
+^ILL_DISABLE(opts->no_splice_read, FUSE_CAP_SPLICE_READ);$
ERROR: code indent should never use tabs
#1301: FILE: tools/virtiofsd/helper.c:383:
+^ILL_ENABLE(opts->splice_write, FUSE_CAP_SPLICE_WRITE);$
ERROR: code indent should never use tabs
#1302: FILE: tools/virtiofsd/helper.c:384:
+^ILL_DISABLE(opts->no_splice_write, FUSE_CAP_SPLICE_WRITE);$
ERROR: code indent should never use tabs
#1304: FILE: tools/virtiofsd/helper.c:386:
+^ILL_ENABLE(opts->splice_move, FUSE_CAP_SPLICE_MOVE);$
ERROR: code indent should never use tabs
#1305: FILE: tools/virtiofsd/helper.c:387:
+^ILL_DISABLE(opts->no_splice_move, FUSE_CAP_SPLICE_MOVE);$
ERROR: code indent should never use tabs
#1307: FILE: tools/virtiofsd/helper.c:389:
+^ILL_ENABLE(opts->auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);$
ERROR: code indent should never use tabs
#1308: FILE: tools/virtiofsd/helper.c:390:
+^ILL_DISABLE(opts->no_auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);$
ERROR: code indent should never use tabs
#1310: FILE: tools/virtiofsd/helper.c:392:
+^ILL_DISABLE(opts->no_readdirplus, FUSE_CAP_READDIRPLUS);$
ERROR: code indent should never use tabs
#1311: FILE: tools/virtiofsd/helper.c:393:
+^ILL_DISABLE(opts->no_readdirplus_auto, FUSE_CAP_READDIRPLUS_AUTO);$
ERROR: code indent should never use tabs
#1313: FILE: tools/virtiofsd/helper.c:395:
+^ILL_ENABLE(opts->async_dio, FUSE_CAP_ASYNC_DIO);$
ERROR: code indent should never use tabs
#1314: FILE: tools/virtiofsd/helper.c:396:
+^ILL_DISABLE(opts->no_async_dio, FUSE_CAP_ASYNC_DIO);$
ERROR: code indent should never use tabs
#1316: FILE: tools/virtiofsd/helper.c:398:
+^ILL_ENABLE(opts->writeback_cache, FUSE_CAP_WRITEBACK_CACHE);$
ERROR: code indent should never use tabs
#1317: FILE: tools/virtiofsd/helper.c:399:
+^ILL_DISABLE(opts->no_writeback_cache, FUSE_CAP_WRITEBACK_CACHE);$
ERROR: code indent should never use tabs
#1319: FILE: tools/virtiofsd/helper.c:401:
+^ILL_ENABLE(opts->async_read, FUSE_CAP_ASYNC_READ);$
ERROR: code indent should never use tabs
#1320: FILE: tools/virtiofsd/helper.c:402:
+^ILL_DISABLE(opts->sync_read, FUSE_CAP_ASYNC_READ);$
ERROR: code indent should never use tabs
#1322: FILE: tools/virtiofsd/helper.c:404:
+^ILL_DISABLE(opts->no_remote_posix_lock, FUSE_CAP_POSIX_LOCKS);$
ERROR: code indent should never use tabs
#1323: FILE: tools/virtiofsd/helper.c:405:
+^ILL_DISABLE(opts->no_remote_flock, FUSE_CAP_FLOCK_LOCKS);$
ERROR: "foo* bar" should be "foo *bar"
#1326: FILE: tools/virtiofsd/helper.c:408:
+struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args)
ERROR: code indent should never use tabs
#1328: FILE: tools/virtiofsd/helper.c:410:
+^Istruct fuse_conn_info_opts *opts;$
ERROR: code indent should never use tabs
#1330: FILE: tools/virtiofsd/helper.c:412:
+^Iopts = calloc(1, sizeof(struct fuse_conn_info_opts));$
ERROR: code indent should never use tabs
#1331: FILE: tools/virtiofsd/helper.c:413:
+^Iif(opts == NULL) {$
ERROR: space required before the open parenthesis '('
#1331: FILE: tools/virtiofsd/helper.c:413:
+ if(opts == NULL) {
ERROR: code indent should never use tabs
#1332: FILE: tools/virtiofsd/helper.c:414:
+^I^Ifuse_log(FUSE_LOG_ERR, "calloc failed\n");$
ERROR: code indent should never use tabs
#1333: FILE: tools/virtiofsd/helper.c:415:
+^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#1334: FILE: tools/virtiofsd/helper.c:416:
+^I}$
ERROR: code indent should never use tabs
#1335: FILE: tools/virtiofsd/helper.c:417:
+^Iif(fuse_opt_parse(args, opts, conn_info_opt_spec, NULL) == -1) {$
ERROR: space required before the open parenthesis '('
#1335: FILE: tools/virtiofsd/helper.c:417:
+ if(fuse_opt_parse(args, opts, conn_info_opt_spec, NULL) == -1) {
ERROR: code indent should never use tabs
#1336: FILE: tools/virtiofsd/helper.c:418:
+^I^Ifree(opts);$
ERROR: code indent should never use tabs
#1337: FILE: tools/virtiofsd/helper.c:419:
+^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#1338: FILE: tools/virtiofsd/helper.c:420:
+^I}$
ERROR: code indent should never use tabs
#1339: FILE: tools/virtiofsd/helper.c:421:
+^Ireturn opts;$
ERROR: code indent should never use tabs
#1344: FILE: tools/virtiofsd/helper.c:426:
+^Istruct mount_opts *opts = NULL;$
ERROR: code indent should never use tabs
#1345: FILE: tools/virtiofsd/helper.c:427:
+^Iint fd = -1;$
ERROR: code indent should never use tabs
#1346: FILE: tools/virtiofsd/helper.c:428:
+^Iconst char *argv[] = { "", "-o", options };$
ERROR: code indent should never use tabs
#1347: FILE: tools/virtiofsd/helper.c:429:
+^Iint argc = sizeof(argv) / sizeof(argv[0]);$
ERROR: code indent should never use tabs
#1348: FILE: tools/virtiofsd/helper.c:430:
+^Istruct fuse_args args = FUSE_ARGS_INIT(argc, (char**) argv);$
ERROR: "(foo**)" should be "(foo **)"
#1348: FILE: tools/virtiofsd/helper.c:430:
+ struct fuse_args args = FUSE_ARGS_INIT(argc, (char**) argv);
ERROR: code indent should never use tabs
#1350: FILE: tools/virtiofsd/helper.c:432:
+^Iopts = parse_mount_opts(&args);$
ERROR: code indent should never use tabs
#1351: FILE: tools/virtiofsd/helper.c:433:
+^Iif (opts == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#1351: FILE: tools/virtiofsd/helper.c:433:
+ if (opts == NULL)
[...]
ERROR: code indent should never use tabs
#1352: FILE: tools/virtiofsd/helper.c:434:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#1354: FILE: tools/virtiofsd/helper.c:436:
+^Ifd = fuse_kern_mount(mountpoint, opts);$
ERROR: code indent should never use tabs
#1355: FILE: tools/virtiofsd/helper.c:437:
+^Idestroy_mount_opts(opts);$
ERROR: code indent should never use tabs
#1357: FILE: tools/virtiofsd/helper.c:439:
+^Ireturn fd;$
total: 943 errors, 21 warnings, 1315 lines checked
Patch 3/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
4/108 Checking commit dcd7ad1f8b54 (virtiofsd: Add fuse_lowlevel.c)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#18:
new file mode 100644
WARNING: Block comments use * on subsequent lines
#24: FILE: tools/virtiofsd/fuse_lowlevel.c:2:
+/*
+ FUSE: Filesystem in Userspace
ERROR: code indent should never use tabs
#57: FILE: tools/virtiofsd/fuse_lowlevel.c:35:
+#define F_SETPIPE_SZ^I(F_LINUX_SPECIFIC_BASE + 7)$
ERROR: code indent should never use tabs
#64: FILE: tools/virtiofsd/fuse_lowlevel.c:42:
+#define container_of(ptr, type, member) ({^I^I^I^I\$
ERROR: code indent should never use tabs
#65: FILE: tools/virtiofsd/fuse_lowlevel.c:43:
+^I^I^Iconst typeof( ((type *)0)->member ) *__mptr = (ptr); \$
ERROR: spaces required around that '*' (ctx:WxV)
#65: FILE: tools/virtiofsd/fuse_lowlevel.c:43:
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
^
ERROR: space prohibited after that open parenthesis '('
#65: FILE: tools/virtiofsd/fuse_lowlevel.c:43:
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
ERROR: space prohibited before that close parenthesis ')'
#65: FILE: tools/virtiofsd/fuse_lowlevel.c:43:
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
ERROR: code indent should never use tabs
#66: FILE: tools/virtiofsd/fuse_lowlevel.c:44:
+^I^I^I(type *)( (char *)__mptr - offsetof(type,member) );})$
ERROR: space required after that ',' (ctx:VxV)
#66: FILE: tools/virtiofsd/fuse_lowlevel.c:44:
+ (type *)( (char *)__mptr - offsetof(type,member) );})
^
ERROR: space required after that ';' (ctx:VxV)
#66: FILE: tools/virtiofsd/fuse_lowlevel.c:44:
+ (type *)( (char *)__mptr - offsetof(type,member) );})
^
ERROR: space prohibited after that open parenthesis '('
#66: FILE: tools/virtiofsd/fuse_lowlevel.c:44:
+ (type *)( (char *)__mptr - offsetof(type,member) );})
ERROR: space prohibited before that close parenthesis ')'
#66: FILE: tools/virtiofsd/fuse_lowlevel.c:44:
+ (type *)( (char *)__mptr - offsetof(type,member) );})
ERROR: code indent should never use tabs
#69: FILE: tools/virtiofsd/fuse_lowlevel.c:47:
+^Iuint64_t kh;$
ERROR: code indent should never use tabs
#70: FILE: tools/virtiofsd/fuse_lowlevel.c:48:
+^Istruct fuse_session *se;$
ERROR: code indent should never use tabs
#77: FILE: tools/virtiofsd/fuse_lowlevel.c:55:
+^Ipagesize = getpagesize();$
ERROR: use qemu_real_host_page_size instead of getpagesize()
#77: FILE: tools/virtiofsd/fuse_lowlevel.c:55:
+ pagesize = getpagesize();
ERROR: code indent should never use tabs
#82: FILE: tools/virtiofsd/fuse_lowlevel.c:60:
+^Iattr->ino^I= stbuf->st_ino;$
ERROR: code indent should never use tabs
#83: FILE: tools/virtiofsd/fuse_lowlevel.c:61:
+^Iattr->mode^I= stbuf->st_mode;$
ERROR: code indent should never use tabs
#84: FILE: tools/virtiofsd/fuse_lowlevel.c:62:
+^Iattr->nlink^I= stbuf->st_nlink;$
ERROR: code indent should never use tabs
#85: FILE: tools/virtiofsd/fuse_lowlevel.c:63:
+^Iattr->uid^I= stbuf->st_uid;$
ERROR: code indent should never use tabs
#86: FILE: tools/virtiofsd/fuse_lowlevel.c:64:
+^Iattr->gid^I= stbuf->st_gid;$
ERROR: code indent should never use tabs
#87: FILE: tools/virtiofsd/fuse_lowlevel.c:65:
+^Iattr->rdev^I= stbuf->st_rdev;$
ERROR: code indent should never use tabs
#88: FILE: tools/virtiofsd/fuse_lowlevel.c:66:
+^Iattr->size^I= stbuf->st_size;$
ERROR: code indent should never use tabs
#89: FILE: tools/virtiofsd/fuse_lowlevel.c:67:
+^Iattr->blksize^I= stbuf->st_blksize;$
ERROR: code indent should never use tabs
#90: FILE: tools/virtiofsd/fuse_lowlevel.c:68:
+^Iattr->blocks^I= stbuf->st_blocks;$
ERROR: code indent should never use tabs
#91: FILE: tools/virtiofsd/fuse_lowlevel.c:69:
+^Iattr->atime^I= stbuf->st_atime;$
ERROR: code indent should never use tabs
#92: FILE: tools/virtiofsd/fuse_lowlevel.c:70:
+^Iattr->mtime^I= stbuf->st_mtime;$
ERROR: code indent should never use tabs
#93: FILE: tools/virtiofsd/fuse_lowlevel.c:71:
+^Iattr->ctime^I= stbuf->st_ctime;$
ERROR: code indent should never use tabs
#94: FILE: tools/virtiofsd/fuse_lowlevel.c:72:
+^Iattr->atimensec = ST_ATIM_NSEC(stbuf);$
ERROR: code indent should never use tabs
#95: FILE: tools/virtiofsd/fuse_lowlevel.c:73:
+^Iattr->mtimensec = ST_MTIM_NSEC(stbuf);$
ERROR: code indent should never use tabs
#96: FILE: tools/virtiofsd/fuse_lowlevel.c:74:
+^Iattr->ctimensec = ST_CTIM_NSEC(stbuf);$
ERROR: code indent should never use tabs
#101: FILE: tools/virtiofsd/fuse_lowlevel.c:79:
+^Istbuf->st_mode^I = attr->mode;$
ERROR: code indent should never use tabs
#102: FILE: tools/virtiofsd/fuse_lowlevel.c:80:
+^Istbuf->st_uid^I = attr->uid;$
ERROR: code indent should never use tabs
#103: FILE: tools/virtiofsd/fuse_lowlevel.c:81:
+^Istbuf->st_gid^I = attr->gid;$
ERROR: code indent should never use tabs
#104: FILE: tools/virtiofsd/fuse_lowlevel.c:82:
+^Istbuf->st_size^I = attr->size;$
ERROR: code indent should never use tabs
#105: FILE: tools/virtiofsd/fuse_lowlevel.c:83:
+^Istbuf->st_atime^I = attr->atime;$
ERROR: code indent should never use tabs
#106: FILE: tools/virtiofsd/fuse_lowlevel.c:84:
+^Istbuf->st_mtime^I = attr->mtime;$
ERROR: code indent should never use tabs
#107: FILE: tools/virtiofsd/fuse_lowlevel.c:85:
+^Istbuf->st_ctime = attr->ctime;$
ERROR: code indent should never use tabs
#108: FILE: tools/virtiofsd/fuse_lowlevel.c:86:
+^IST_ATIM_NSEC_SET(stbuf, attr->atimensec);$
ERROR: code indent should never use tabs
#109: FILE: tools/virtiofsd/fuse_lowlevel.c:87:
+^IST_MTIM_NSEC_SET(stbuf, attr->mtimensec);$
ERROR: code indent should never use tabs
#110: FILE: tools/virtiofsd/fuse_lowlevel.c:88:
+^IST_CTIM_NSEC_SET(stbuf, attr->ctimensec);$
ERROR: code indent should never use tabs
#113: FILE: tools/virtiofsd/fuse_lowlevel.c:91:
+static^Isize_t iov_length(const struct iovec *iov, size_t count)$
ERROR: code indent should never use tabs
#115: FILE: tools/virtiofsd/fuse_lowlevel.c:93:
+^Isize_t seg;$
ERROR: code indent should never use tabs
#116: FILE: tools/virtiofsd/fuse_lowlevel.c:94:
+^Isize_t ret = 0;$
ERROR: code indent should never use tabs
#118: FILE: tools/virtiofsd/fuse_lowlevel.c:96:
+^Ifor (seg = 0; seg < count; seg++)$
ERROR: braces {} are necessary for all arms of this statement
#118: FILE: tools/virtiofsd/fuse_lowlevel.c:96:
+ for (seg = 0; seg < count; seg++)
[...]
ERROR: code indent should never use tabs
#119: FILE: tools/virtiofsd/fuse_lowlevel.c:97:
+^I^Iret += iov[seg].iov_len;$
ERROR: code indent should never use tabs
#120: FILE: tools/virtiofsd/fuse_lowlevel.c:98:
+^Ireturn ret;$
ERROR: code indent should never use tabs
#125: FILE: tools/virtiofsd/fuse_lowlevel.c:103:
+^Ireq->next = req;$
ERROR: code indent should never use tabs
#126: FILE: tools/virtiofsd/fuse_lowlevel.c:104:
+^Ireq->prev = req;$
ERROR: code indent should never use tabs
#131: FILE: tools/virtiofsd/fuse_lowlevel.c:109:
+^Istruct fuse_req *prev = req->prev;$
ERROR: code indent should never use tabs
#132: FILE: tools/virtiofsd/fuse_lowlevel.c:110:
+^Istruct fuse_req *next = req->next;$
ERROR: code indent should never use tabs
#133: FILE: tools/virtiofsd/fuse_lowlevel.c:111:
+^Iprev->next = next;$
ERROR: code indent should never use tabs
#134: FILE: tools/virtiofsd/fuse_lowlevel.c:112:
+^Inext->prev = prev;$
ERROR: code indent should never use tabs
#139: FILE: tools/virtiofsd/fuse_lowlevel.c:117:
+^Istruct fuse_req *prev = next->prev;$
ERROR: code indent should never use tabs
#140: FILE: tools/virtiofsd/fuse_lowlevel.c:118:
+^Ireq->next = next;$
ERROR: code indent should never use tabs
#141: FILE: tools/virtiofsd/fuse_lowlevel.c:119:
+^Ireq->prev = prev;$
ERROR: code indent should never use tabs
#142: FILE: tools/virtiofsd/fuse_lowlevel.c:120:
+^Iprev->next = req;$
ERROR: code indent should never use tabs
#143: FILE: tools/virtiofsd/fuse_lowlevel.c:121:
+^Inext->prev = req;$
ERROR: code indent should never use tabs
#148: FILE: tools/virtiofsd/fuse_lowlevel.c:126:
+^Ipthread_mutex_destroy(&req->lock);$
ERROR: code indent should never use tabs
#149: FILE: tools/virtiofsd/fuse_lowlevel.c:127:
+^Ifree(req);$
ERROR: code indent should never use tabs
#154: FILE: tools/virtiofsd/fuse_lowlevel.c:132:
+^Iint ctr;$
ERROR: code indent should never use tabs
#155: FILE: tools/virtiofsd/fuse_lowlevel.c:133:
+^Istruct fuse_session *se = req->se;$
ERROR: code indent should never use tabs
#157: FILE: tools/virtiofsd/fuse_lowlevel.c:135:
+^Ipthread_mutex_lock(&se->lock);$
ERROR: code indent should never use tabs
#158: FILE: tools/virtiofsd/fuse_lowlevel.c:136:
+^Ireq->u.ni.func = NULL;$
ERROR: code indent should never use tabs
#159: FILE: tools/virtiofsd/fuse_lowlevel.c:137:
+^Ireq->u.ni.data = NULL;$
ERROR: code indent should never use tabs
#160: FILE: tools/virtiofsd/fuse_lowlevel.c:138:
+^Ilist_del_req(req);$
ERROR: code indent should never use tabs
#161: FILE: tools/virtiofsd/fuse_lowlevel.c:139:
+^Ictr = --req->ctr;$
ERROR: code indent should never use tabs
#162: FILE: tools/virtiofsd/fuse_lowlevel.c:140:
+^Ifuse_chan_put(req->ch);$
ERROR: code indent should never use tabs
#163: FILE: tools/virtiofsd/fuse_lowlevel.c:141:
+^Ireq->ch = NULL;$
ERROR: code indent should never use tabs
#164: FILE: tools/virtiofsd/fuse_lowlevel.c:142:
+^Ipthread_mutex_unlock(&se->lock);$
ERROR: code indent should never use tabs
#165: FILE: tools/virtiofsd/fuse_lowlevel.c:143:
+^Iif (!ctr)$
ERROR: braces {} are necessary for all arms of this statement
#165: FILE: tools/virtiofsd/fuse_lowlevel.c:143:
+ if (!ctr)
[...]
ERROR: code indent should never use tabs
#166: FILE: tools/virtiofsd/fuse_lowlevel.c:144:
+^I^Idestroy_req(req);$
ERROR: code indent should never use tabs
#171: FILE: tools/virtiofsd/fuse_lowlevel.c:149:
+^Istruct fuse_req *req;$
ERROR: code indent should never use tabs
#173: FILE: tools/virtiofsd/fuse_lowlevel.c:151:
+^Ireq = (struct fuse_req *) calloc(1, sizeof(struct fuse_req));$
ERROR: code indent should never use tabs
#174: FILE: tools/virtiofsd/fuse_lowlevel.c:152:
+^Iif (req == NULL) {$
ERROR: code indent should never use tabs
#175: FILE: tools/virtiofsd/fuse_lowlevel.c:153:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: failed to allocate request\n");$
ERROR: code indent should never use tabs
#176: FILE: tools/virtiofsd/fuse_lowlevel.c:154:
+^I} else {$
ERROR: code indent should never use tabs
#177: FILE: tools/virtiofsd/fuse_lowlevel.c:155:
+^I^Ireq->se = se;$
ERROR: code indent should never use tabs
#178: FILE: tools/virtiofsd/fuse_lowlevel.c:156:
+^I^Ireq->ctr = 1;$
ERROR: code indent should never use tabs
#179: FILE: tools/virtiofsd/fuse_lowlevel.c:157:
+^I^Ilist_init_req(req);$
ERROR: code indent should never use tabs
#180: FILE: tools/virtiofsd/fuse_lowlevel.c:158:
+^I^Ifuse_mutex_init(&req->lock);$
ERROR: code indent should never use tabs
#181: FILE: tools/virtiofsd/fuse_lowlevel.c:159:
+^I}$
ERROR: code indent should never use tabs
#183: FILE: tools/virtiofsd/fuse_lowlevel.c:161:
+^Ireturn req;$
ERROR: code indent should never use tabs
#188: FILE: tools/virtiofsd/fuse_lowlevel.c:166:
+^I^I^I struct iovec *iov, int count)$
ERROR: code indent should never use tabs
#190: FILE: tools/virtiofsd/fuse_lowlevel.c:168:
+^Istruct fuse_out_header *out = iov[0].iov_base;$
ERROR: code indent should never use tabs
#192: FILE: tools/virtiofsd/fuse_lowlevel.c:170:
+^Iout->len = iov_length(iov, count);$
ERROR: code indent should never use tabs
#193: FILE: tools/virtiofsd/fuse_lowlevel.c:171:
+^Iif (se->debug) {$
ERROR: code indent should never use tabs
#194: FILE: tools/virtiofsd/fuse_lowlevel.c:172:
+^I^Iif (out->unique == 0) {$
ERROR: code indent should never use tabs
#195: FILE: tools/virtiofsd/fuse_lowlevel.c:173:
+^I^I^Ifuse_log(FUSE_LOG_DEBUG, "NOTIFY: code=%d length=%u\n",$
ERROR: code indent should never use tabs
#196: FILE: tools/virtiofsd/fuse_lowlevel.c:174:
+^I^I^I^Iout->error, out->len);$
ERROR: code indent should never use tabs
#197: FILE: tools/virtiofsd/fuse_lowlevel.c:175:
+^I^I} else if (out->error) {$
ERROR: code indent should never use tabs
#198: FILE: tools/virtiofsd/fuse_lowlevel.c:176:
+^I^I^Ifuse_log(FUSE_LOG_DEBUG,$
ERROR: code indent should never use tabs
#199: FILE: tools/virtiofsd/fuse_lowlevel.c:177:
+^I^I^I^I" unique: %llu, error: %i (%s), outsize: %i\n",$
ERROR: code indent should never use tabs
#200: FILE: tools/virtiofsd/fuse_lowlevel.c:178:
+^I^I^I^I(unsigned long long) out->unique, out->error,$
ERROR: code indent should never use tabs
#201: FILE: tools/virtiofsd/fuse_lowlevel.c:179:
+^I^I^I^Istrerror(-out->error), out->len);$
ERROR: code indent should never use tabs
#202: FILE: tools/virtiofsd/fuse_lowlevel.c:180:
+^I^I} else {$
ERROR: code indent should never use tabs
#203: FILE: tools/virtiofsd/fuse_lowlevel.c:181:
+^I^I^Ifuse_log(FUSE_LOG_DEBUG,$
ERROR: code indent should never use tabs
#204: FILE: tools/virtiofsd/fuse_lowlevel.c:182:
+^I^I^I^I" unique: %llu, success, outsize: %i\n",$
ERROR: code indent should never use tabs
#205: FILE: tools/virtiofsd/fuse_lowlevel.c:183:
+^I^I^I^I(unsigned long long) out->unique, out->len);$
ERROR: code indent should never use tabs
#206: FILE: tools/virtiofsd/fuse_lowlevel.c:184:
+^I^I}$
ERROR: code indent should never use tabs
#207: FILE: tools/virtiofsd/fuse_lowlevel.c:185:
+^I}$
ERROR: code indent should never use tabs
#209: FILE: tools/virtiofsd/fuse_lowlevel.c:187:
+^Issize_t res = writev(ch ? ch->fd : se->fd,$
ERROR: code indent should never use tabs
#210: FILE: tools/virtiofsd/fuse_lowlevel.c:188:
+^I^I^I iov, count);$
ERROR: code indent should never use tabs
#211: FILE: tools/virtiofsd/fuse_lowlevel.c:189:
+^Iint err = errno;$
ERROR: code indent should never use tabs
#213: FILE: tools/virtiofsd/fuse_lowlevel.c:191:
+^Iif (res == -1) {$
ERROR: code indent should never use tabs
#214: FILE: tools/virtiofsd/fuse_lowlevel.c:192:
+^I^Iassert(se != NULL);$
ERROR: code indent should never use tabs
#216: FILE: tools/virtiofsd/fuse_lowlevel.c:194:
+^I^I/* ENOENT means the operation was interrupted */$
ERROR: code indent should never use tabs
#217: FILE: tools/virtiofsd/fuse_lowlevel.c:195:
+^I^Iif (!fuse_session_exited(se) && err != ENOENT)$
ERROR: braces {} are necessary for all arms of this statement
#217: FILE: tools/virtiofsd/fuse_lowlevel.c:195:
+ if (!fuse_session_exited(se) && err != ENOENT)
[...]
ERROR: code indent should never use tabs
#218: FILE: tools/virtiofsd/fuse_lowlevel.c:196:
+^I^I^Iperror("fuse: writing device");$
ERROR: code indent should never use tabs
#219: FILE: tools/virtiofsd/fuse_lowlevel.c:197:
+^I^Ireturn -err;$
ERROR: code indent should never use tabs
#220: FILE: tools/virtiofsd/fuse_lowlevel.c:198:
+^I}$
ERROR: code indent should never use tabs
#222: FILE: tools/virtiofsd/fuse_lowlevel.c:200:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#227: FILE: tools/virtiofsd/fuse_lowlevel.c:205:
+^I^I^I int count)$
ERROR: code indent should never use tabs
#229: FILE: tools/virtiofsd/fuse_lowlevel.c:207:
+^Istruct fuse_out_header out;$
ERROR: code indent should never use tabs
#231: FILE: tools/virtiofsd/fuse_lowlevel.c:209:
+^Iif (error <= -1000 || error > 0) {$
ERROR: code indent should never use tabs
#232: FILE: tools/virtiofsd/fuse_lowlevel.c:210:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: bad error value: %i\n",^Ierror);$
ERROR: code indent should never use tabs
#233: FILE: tools/virtiofsd/fuse_lowlevel.c:211:
+^I^Ierror = -ERANGE;$
ERROR: code indent should never use tabs
#234: FILE: tools/virtiofsd/fuse_lowlevel.c:212:
+^I}$
ERROR: code indent should never use tabs
#236: FILE: tools/virtiofsd/fuse_lowlevel.c:214:
+^Iout.unique = req->unique;$
ERROR: code indent should never use tabs
#237: FILE: tools/virtiofsd/fuse_lowlevel.c:215:
+^Iout.error = error;$
ERROR: code indent should never use tabs
#239: FILE: tools/virtiofsd/fuse_lowlevel.c:217:
+^Iiov[0].iov_base = &out;$
ERROR: code indent should never use tabs
#240: FILE: tools/virtiofsd/fuse_lowlevel.c:218:
+^Iiov[0].iov_len = sizeof(struct fuse_out_header);$
ERROR: code indent should never use tabs
#242: FILE: tools/virtiofsd/fuse_lowlevel.c:220:
+^Ireturn fuse_send_msg(req->se, req->ch, iov, count);$
ERROR: code indent should never use tabs
#246: FILE: tools/virtiofsd/fuse_lowlevel.c:224:
+^I^I^I int count)$
ERROR: code indent should never use tabs
#248: FILE: tools/virtiofsd/fuse_lowlevel.c:226:
+^Iint res;$
ERROR: code indent should never use tabs
#250: FILE: tools/virtiofsd/fuse_lowlevel.c:228:
+^Ires = fuse_send_reply_iov_nofree(req, error, iov, count);$
ERROR: code indent should never use tabs
#251: FILE: tools/virtiofsd/fuse_lowlevel.c:229:
+^Ifuse_free_req(req);$
ERROR: code indent should never use tabs
#252: FILE: tools/virtiofsd/fuse_lowlevel.c:230:
+^Ireturn res;$
ERROR: code indent should never use tabs
#256: FILE: tools/virtiofsd/fuse_lowlevel.c:234:
+^I^I size_t argsize)$
ERROR: code indent should never use tabs
#258: FILE: tools/virtiofsd/fuse_lowlevel.c:236:
+^Istruct iovec iov[2];$
ERROR: code indent should never use tabs
#259: FILE: tools/virtiofsd/fuse_lowlevel.c:237:
+^Iint count = 1;$
ERROR: code indent should never use tabs
#260: FILE: tools/virtiofsd/fuse_lowlevel.c:238:
+^Iif (argsize) {$
ERROR: code indent should never use tabs
#261: FILE: tools/virtiofsd/fuse_lowlevel.c:239:
+^I^Iiov[1].iov_base = (void *) arg;$
ERROR: code indent should never use tabs
#262: FILE: tools/virtiofsd/fuse_lowlevel.c:240:
+^I^Iiov[1].iov_len = argsize;$
ERROR: code indent should never use tabs
#263: FILE: tools/virtiofsd/fuse_lowlevel.c:241:
+^I^Icount++;$
ERROR: code indent should never use tabs
#264: FILE: tools/virtiofsd/fuse_lowlevel.c:242:
+^I}$
ERROR: code indent should never use tabs
#265: FILE: tools/virtiofsd/fuse_lowlevel.c:243:
+^Ireturn send_reply_iov(req, error, iov, count);$
ERROR: code indent should never use tabs
#270: FILE: tools/virtiofsd/fuse_lowlevel.c:248:
+^Iint res;$
ERROR: code indent should never use tabs
#271: FILE: tools/virtiofsd/fuse_lowlevel.c:249:
+^Istruct iovec *padded_iov;$
ERROR: code indent should never use tabs
#273: FILE: tools/virtiofsd/fuse_lowlevel.c:251:
+^Ipadded_iov = malloc((count + 1) * sizeof(struct iovec));$
ERROR: code indent should never use tabs
#274: FILE: tools/virtiofsd/fuse_lowlevel.c:252:
+^Iif (padded_iov == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#274: FILE: tools/virtiofsd/fuse_lowlevel.c:252:
+ if (padded_iov == NULL)
[...]
ERROR: code indent should never use tabs
#275: FILE: tools/virtiofsd/fuse_lowlevel.c:253:
+^I^Ireturn fuse_reply_err(req, ENOMEM);$
ERROR: code indent should never use tabs
#277: FILE: tools/virtiofsd/fuse_lowlevel.c:255:
+^Imemcpy(padded_iov + 1, iov, count * sizeof(struct iovec));$
ERROR: code indent should never use tabs
#278: FILE: tools/virtiofsd/fuse_lowlevel.c:256:
+^Icount++;$
ERROR: code indent should never use tabs
#280: FILE: tools/virtiofsd/fuse_lowlevel.c:258:
+^Ires = send_reply_iov(req, 0, padded_iov, count);$
ERROR: code indent should never use tabs
#281: FILE: tools/virtiofsd/fuse_lowlevel.c:259:
+^Ifree(padded_iov);$
ERROR: code indent should never use tabs
#283: FILE: tools/virtiofsd/fuse_lowlevel.c:261:
+^Ireturn res;$
WARNING: Block comments use a leading /* on a separate line
#287: FILE: tools/virtiofsd/fuse_lowlevel.c:265:
+/* `buf` is allowed to be empty so that the proper size may be
WARNING: Block comments use * on subsequent lines
#288: FILE: tools/virtiofsd/fuse_lowlevel.c:266:
+/* `buf` is allowed to be empty so that the proper size may be
+ allocated by the caller */
WARNING: Block comments use a trailing */ on a separate line
#288: FILE: tools/virtiofsd/fuse_lowlevel.c:266:
+ allocated by the caller */
ERROR: code indent should never use tabs
#290: FILE: tools/virtiofsd/fuse_lowlevel.c:268:
+^I^I^I const char *name, const struct stat *stbuf, off_t off)$
ERROR: code indent should never use tabs
#292: FILE: tools/virtiofsd/fuse_lowlevel.c:270:
+^I(void)req;$
ERROR: code indent should never use tabs
#293: FILE: tools/virtiofsd/fuse_lowlevel.c:271:
+^Isize_t namelen;$
ERROR: code indent should never use tabs
#294: FILE: tools/virtiofsd/fuse_lowlevel.c:272:
+^Isize_t entlen;$
ERROR: code indent should never use tabs
#295: FILE: tools/virtiofsd/fuse_lowlevel.c:273:
+^Isize_t entlen_padded;$
ERROR: code indent should never use tabs
#296: FILE: tools/virtiofsd/fuse_lowlevel.c:274:
+^Istruct fuse_dirent *dirent;$
ERROR: code indent should never use tabs
#298: FILE: tools/virtiofsd/fuse_lowlevel.c:276:
+^Inamelen = strlen(name);$
ERROR: code indent should never use tabs
#299: FILE: tools/virtiofsd/fuse_lowlevel.c:277:
+^Ientlen = FUSE_NAME_OFFSET + namelen;$
ERROR: code indent should never use tabs
#300: FILE: tools/virtiofsd/fuse_lowlevel.c:278:
+^Ientlen_padded = FUSE_DIRENT_ALIGN(entlen);$
ERROR: code indent should never use tabs
#302: FILE: tools/virtiofsd/fuse_lowlevel.c:280:
+^Iif ((buf == NULL) || (entlen_padded > bufsize))$
ERROR: suspect code indent for conditional statements (8, 10)
#302: FILE: tools/virtiofsd/fuse_lowlevel.c:280:
+ if ((buf == NULL) || (entlen_padded > bufsize))
+ return entlen_padded;
ERROR: braces {} are necessary for all arms of this statement
#302: FILE: tools/virtiofsd/fuse_lowlevel.c:280:
+ if ((buf == NULL) || (entlen_padded > bufsize))
[...]
ERROR: code indent should never use tabs
#303: FILE: tools/virtiofsd/fuse_lowlevel.c:281:
+^I return entlen_padded;$
ERROR: code indent should never use tabs
#305: FILE: tools/virtiofsd/fuse_lowlevel.c:283:
+^Idirent = (struct fuse_dirent*) buf;$
ERROR: "(foo*)" should be "(foo *)"
#305: FILE: tools/virtiofsd/fuse_lowlevel.c:283:
+ dirent = (struct fuse_dirent*) buf;
ERROR: code indent should never use tabs
#306: FILE: tools/virtiofsd/fuse_lowlevel.c:284:
+^Idirent->ino = stbuf->st_ino;$
ERROR: code indent should never use tabs
#307: FILE: tools/virtiofsd/fuse_lowlevel.c:285:
+^Idirent->off = off;$
ERROR: code indent should never use tabs
#308: FILE: tools/virtiofsd/fuse_lowlevel.c:286:
+^Idirent->namelen = namelen;$
ERROR: code indent should never use tabs
#309: FILE: tools/virtiofsd/fuse_lowlevel.c:287:
+^Idirent->type = (stbuf->st_mode & S_IFMT) >> 12;$
ERROR: code indent should never use tabs
#310: FILE: tools/virtiofsd/fuse_lowlevel.c:288:
+^Imemcpy(dirent->name, name, namelen);$
ERROR: code indent should never use tabs
#311: FILE: tools/virtiofsd/fuse_lowlevel.c:289:
+^Imemset(dirent->name + namelen, 0, entlen_padded - entlen);$
ERROR: code indent should never use tabs
#313: FILE: tools/virtiofsd/fuse_lowlevel.c:291:
+^Ireturn entlen_padded;$
ERROR: code indent should never use tabs
#317: FILE: tools/virtiofsd/fuse_lowlevel.c:295:
+^I^I^I struct fuse_kstatfs *kstatfs)$
ERROR: code indent should never use tabs
#319: FILE: tools/virtiofsd/fuse_lowlevel.c:297:
+^Ikstatfs->bsize^I = stbuf->f_bsize;$
ERROR: code indent should never use tabs
#320: FILE: tools/virtiofsd/fuse_lowlevel.c:298:
+^Ikstatfs->frsize^I = stbuf->f_frsize;$
ERROR: code indent should never use tabs
#321: FILE: tools/virtiofsd/fuse_lowlevel.c:299:
+^Ikstatfs->blocks^I = stbuf->f_blocks;$
ERROR: code indent should never use tabs
#322: FILE: tools/virtiofsd/fuse_lowlevel.c:300:
+^Ikstatfs->bfree^I = stbuf->f_bfree;$
ERROR: code indent should never use tabs
#323: FILE: tools/virtiofsd/fuse_lowlevel.c:301:
+^Ikstatfs->bavail^I = stbuf->f_bavail;$
ERROR: code indent should never use tabs
#324: FILE: tools/virtiofsd/fuse_lowlevel.c:302:
+^Ikstatfs->files^I = stbuf->f_files;$
ERROR: code indent should never use tabs
#325: FILE: tools/virtiofsd/fuse_lowlevel.c:303:
+^Ikstatfs->ffree^I = stbuf->f_ffree;$
ERROR: code indent should never use tabs
#326: FILE: tools/virtiofsd/fuse_lowlevel.c:304:
+^Ikstatfs->namelen = stbuf->f_namemax;$
ERROR: code indent should never use tabs
#331: FILE: tools/virtiofsd/fuse_lowlevel.c:309:
+^Ireturn send_reply(req, 0, arg, argsize);$
ERROR: code indent should never use tabs
#336: FILE: tools/virtiofsd/fuse_lowlevel.c:314:
+^Ireturn send_reply(req, -err, NULL, 0);$
ERROR: code indent should never use tabs
#341: FILE: tools/virtiofsd/fuse_lowlevel.c:319:
+^Ifuse_free_req(req);$
ERROR: code indent should never use tabs
#346: FILE: tools/virtiofsd/fuse_lowlevel.c:324:
+^Iif (t > (double) ULONG_MAX)$
ERROR: braces {} are necessary for all arms of this statement
#346: FILE: tools/virtiofsd/fuse_lowlevel.c:324:
+ if (t > (double) ULONG_MAX)
[...]
+ else if (t < 0.0)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#347: FILE: tools/virtiofsd/fuse_lowlevel.c:325:
+^I^Ireturn ULONG_MAX;$
ERROR: code indent should never use tabs
#348: FILE: tools/virtiofsd/fuse_lowlevel.c:326:
+^Ielse if (t < 0.0)$
ERROR: braces {} are necessary for all arms of this statement
#348: FILE: tools/virtiofsd/fuse_lowlevel.c:326:
+ else if (t < 0.0)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#349: FILE: tools/virtiofsd/fuse_lowlevel.c:327:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#350: FILE: tools/virtiofsd/fuse_lowlevel.c:328:
+^Ielse$
ERROR: code indent should never use tabs
#351: FILE: tools/virtiofsd/fuse_lowlevel.c:329:
+^I^Ireturn (unsigned long) t;$
ERROR: code indent should never use tabs
#356: FILE: tools/virtiofsd/fuse_lowlevel.c:334:
+^Idouble f = t - (double) calc_timeout_sec(t);$
ERROR: code indent should never use tabs
#357: FILE: tools/virtiofsd/fuse_lowlevel.c:335:
+^Iif (f < 0.0)$
ERROR: braces {} are necessary for all arms of this statement
#357: FILE: tools/virtiofsd/fuse_lowlevel.c:335:
+ if (f < 0.0)
[...]
+ else if (f >= 0.999999999)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#358: FILE: tools/virtiofsd/fuse_lowlevel.c:336:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#359: FILE: tools/virtiofsd/fuse_lowlevel.c:337:
+^Ielse if (f >= 0.999999999)$
ERROR: braces {} are necessary for all arms of this statement
#359: FILE: tools/virtiofsd/fuse_lowlevel.c:337:
+ else if (f >= 0.999999999)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#360: FILE: tools/virtiofsd/fuse_lowlevel.c:338:
+^I^Ireturn 999999999;$
ERROR: code indent should never use tabs
#361: FILE: tools/virtiofsd/fuse_lowlevel.c:339:
+^Ielse$
ERROR: code indent should never use tabs
#362: FILE: tools/virtiofsd/fuse_lowlevel.c:340:
+^I^Ireturn (unsigned int) (f * 1.0e9);$
ERROR: code indent should never use tabs
#366: FILE: tools/virtiofsd/fuse_lowlevel.c:344:
+^I^I const struct fuse_entry_param *e)$
ERROR: code indent should never use tabs
#368: FILE: tools/virtiofsd/fuse_lowlevel.c:346:
+^Iarg->nodeid = e->ino;$
ERROR: code indent should never use tabs
#369: FILE: tools/virtiofsd/fuse_lowlevel.c:347:
+^Iarg->generation = e->generation;$
ERROR: code indent should never use tabs
#370: FILE: tools/virtiofsd/fuse_lowlevel.c:348:
+^Iarg->entry_valid = calc_timeout_sec(e->entry_timeout);$
ERROR: code indent should never use tabs
#371: FILE: tools/virtiofsd/fuse_lowlevel.c:349:
+^Iarg->entry_valid_nsec = calc_timeout_nsec(e->entry_timeout);$
ERROR: code indent should never use tabs
#372: FILE: tools/virtiofsd/fuse_lowlevel.c:350:
+^Iarg->attr_valid = calc_timeout_sec(e->attr_timeout);$
ERROR: code indent should never use tabs
#373: FILE: tools/virtiofsd/fuse_lowlevel.c:351:
+^Iarg->attr_valid_nsec = calc_timeout_nsec(e->attr_timeout);$
ERROR: code indent should never use tabs
#374: FILE: tools/virtiofsd/fuse_lowlevel.c:352:
+^Iconvert_stat(&e->attr, &arg->attr);$
WARNING: Block comments use a leading /* on a separate line
#377: FILE: tools/virtiofsd/fuse_lowlevel.c:355:
+/* `buf` is allowed to be empty so that the proper size may be
WARNING: Block comments use * on subsequent lines
#378: FILE: tools/virtiofsd/fuse_lowlevel.c:356:
+/* `buf` is allowed to be empty so that the proper size may be
+ allocated by the caller */
WARNING: Block comments use a trailing */ on a separate line
#378: FILE: tools/virtiofsd/fuse_lowlevel.c:356:
+ allocated by the caller */
ERROR: code indent should never use tabs
#380: FILE: tools/virtiofsd/fuse_lowlevel.c:358:
+^I^I^I const char *name,$
ERROR: code indent should never use tabs
#381: FILE: tools/virtiofsd/fuse_lowlevel.c:359:
+^I^I^I const struct fuse_entry_param *e, off_t off)$
ERROR: code indent should never use tabs
#383: FILE: tools/virtiofsd/fuse_lowlevel.c:361:
+^I(void)req;$
ERROR: code indent should never use tabs
#384: FILE: tools/virtiofsd/fuse_lowlevel.c:362:
+^Isize_t namelen;$
ERROR: code indent should never use tabs
#385: FILE: tools/virtiofsd/fuse_lowlevel.c:363:
+^Isize_t entlen;$
ERROR: code indent should never use tabs
#386: FILE: tools/virtiofsd/fuse_lowlevel.c:364:
+^Isize_t entlen_padded;$
ERROR: code indent should never use tabs
#388: FILE: tools/virtiofsd/fuse_lowlevel.c:366:
+^Inamelen = strlen(name);$
ERROR: code indent should never use tabs
#389: FILE: tools/virtiofsd/fuse_lowlevel.c:367:
+^Ientlen = FUSE_NAME_OFFSET_DIRENTPLUS + namelen;$
ERROR: code indent should never use tabs
#390: FILE: tools/virtiofsd/fuse_lowlevel.c:368:
+^Ientlen_padded = FUSE_DIRENT_ALIGN(entlen);$
ERROR: code indent should never use tabs
#391: FILE: tools/virtiofsd/fuse_lowlevel.c:369:
+^Iif ((buf == NULL) || (entlen_padded > bufsize))$
ERROR: suspect code indent for conditional statements (8, 10)
#391: FILE: tools/virtiofsd/fuse_lowlevel.c:369:
+ if ((buf == NULL) || (entlen_padded > bufsize))
+ return entlen_padded;
ERROR: braces {} are necessary for all arms of this statement
#391: FILE: tools/virtiofsd/fuse_lowlevel.c:369:
+ if ((buf == NULL) || (entlen_padded > bufsize))
[...]
ERROR: code indent should never use tabs
#392: FILE: tools/virtiofsd/fuse_lowlevel.c:370:
+^I return entlen_padded;$
ERROR: code indent should never use tabs
#394: FILE: tools/virtiofsd/fuse_lowlevel.c:372:
+^Istruct fuse_direntplus *dp = (struct fuse_direntplus *) buf;$
ERROR: code indent should never use tabs
#395: FILE: tools/virtiofsd/fuse_lowlevel.c:373:
+^Imemset(&dp->entry_out, 0, sizeof(dp->entry_out));$
ERROR: code indent should never use tabs
#396: FILE: tools/virtiofsd/fuse_lowlevel.c:374:
+^Ifill_entry(&dp->entry_out, e);$
ERROR: code indent should never use tabs
#398: FILE: tools/virtiofsd/fuse_lowlevel.c:376:
+^Istruct fuse_dirent *dirent = &dp->dirent;$
ERROR: code indent should never use tabs
#399: FILE: tools/virtiofsd/fuse_lowlevel.c:377:
+^Idirent->ino = e->attr.st_ino;$
ERROR: code indent should never use tabs
#400: FILE: tools/virtiofsd/fuse_lowlevel.c:378:
+^Idirent->off = off;$
ERROR: code indent should never use tabs
#401: FILE: tools/virtiofsd/fuse_lowlevel.c:379:
+^Idirent->namelen = namelen;$
ERROR: code indent should never use tabs
#402: FILE: tools/virtiofsd/fuse_lowlevel.c:380:
+^Idirent->type = (e->attr.st_mode & S_IFMT) >> 12;$
ERROR: code indent should never use tabs
#403: FILE: tools/virtiofsd/fuse_lowlevel.c:381:
+^Imemcpy(dirent->name, name, namelen);$
ERROR: code indent should never use tabs
#404: FILE: tools/virtiofsd/fuse_lowlevel.c:382:
+^Imemset(dirent->name + namelen, 0, entlen_padded - entlen);$
ERROR: code indent should never use tabs
#406: FILE: tools/virtiofsd/fuse_lowlevel.c:384:
+^Ireturn entlen_padded;$
ERROR: code indent should never use tabs
#410: FILE: tools/virtiofsd/fuse_lowlevel.c:388:
+^I^I const struct fuse_file_info *f)$
ERROR: code indent should never use tabs
#412: FILE: tools/virtiofsd/fuse_lowlevel.c:390:
+^Iarg->fh = f->fh;$
ERROR: code indent should never use tabs
#413: FILE: tools/virtiofsd/fuse_lowlevel.c:391:
+^Iif (f->direct_io)$
ERROR: braces {} are necessary for all arms of this statement
#413: FILE: tools/virtiofsd/fuse_lowlevel.c:391:
+ if (f->direct_io)
[...]
ERROR: code indent should never use tabs
#414: FILE: tools/virtiofsd/fuse_lowlevel.c:392:
+^I^Iarg->open_flags |= FOPEN_DIRECT_IO;$
ERROR: code indent should never use tabs
#415: FILE: tools/virtiofsd/fuse_lowlevel.c:393:
+^Iif (f->keep_cache)$
ERROR: braces {} are necessary for all arms of this statement
#415: FILE: tools/virtiofsd/fuse_lowlevel.c:393:
+ if (f->keep_cache)
[...]
ERROR: code indent should never use tabs
#416: FILE: tools/virtiofsd/fuse_lowlevel.c:394:
+^I^Iarg->open_flags |= FOPEN_KEEP_CACHE;$
ERROR: code indent should never use tabs
#417: FILE: tools/virtiofsd/fuse_lowlevel.c:395:
+^Iif (f->cache_readdir)$
ERROR: braces {} are necessary for all arms of this statement
#417: FILE: tools/virtiofsd/fuse_lowlevel.c:395:
+ if (f->cache_readdir)
[...]
ERROR: code indent should never use tabs
#418: FILE: tools/virtiofsd/fuse_lowlevel.c:396:
+^I^Iarg->open_flags |= FOPEN_CACHE_DIR;$
ERROR: code indent should never use tabs
#419: FILE: tools/virtiofsd/fuse_lowlevel.c:397:
+^Iif (f->nonseekable)$
ERROR: braces {} are necessary for all arms of this statement
#419: FILE: tools/virtiofsd/fuse_lowlevel.c:397:
+ if (f->nonseekable)
[...]
ERROR: code indent should never use tabs
#420: FILE: tools/virtiofsd/fuse_lowlevel.c:398:
+^I^Iarg->open_flags |= FOPEN_NONSEEKABLE;$
ERROR: code indent should never use tabs
#425: FILE: tools/virtiofsd/fuse_lowlevel.c:403:
+^Istruct fuse_entry_out arg;$
ERROR: code indent should never use tabs
#426: FILE: tools/virtiofsd/fuse_lowlevel.c:404:
+^Isize_t size = req->se->conn.proto_minor < 9 ?$
ERROR: code indent should never use tabs
#427: FILE: tools/virtiofsd/fuse_lowlevel.c:405:
+^I^IFUSE_COMPAT_ENTRY_OUT_SIZE : sizeof(arg);$
ERROR: code indent should never use tabs
#429: FILE: tools/virtiofsd/fuse_lowlevel.c:407:
+^I/* before ABI 7.4 e->ino == 0 was invalid, only ENOENT meant$
WARNING: Block comments use a leading /* on a separate line
#429: FILE: tools/virtiofsd/fuse_lowlevel.c:407:
+ /* before ABI 7.4 e->ino == 0 was invalid, only ENOENT meant
ERROR: code indent should never use tabs
#430: FILE: tools/virtiofsd/fuse_lowlevel.c:408:
+^I negative entry */$
WARNING: Block comments use * on subsequent lines
#430: FILE: tools/virtiofsd/fuse_lowlevel.c:408:
+ /* before ABI 7.4 e->ino == 0 was invalid, only ENOENT meant
+ negative entry */
WARNING: Block comments use a trailing */ on a separate line
#430: FILE: tools/virtiofsd/fuse_lowlevel.c:408:
+ negative entry */
ERROR: code indent should never use tabs
#431: FILE: tools/virtiofsd/fuse_lowlevel.c:409:
+^Iif (!e->ino && req->se->conn.proto_minor < 4)$
ERROR: braces {} are necessary for all arms of this statement
#431: FILE: tools/virtiofsd/fuse_lowlevel.c:409:
+ if (!e->ino && req->se->conn.proto_minor < 4)
[...]
ERROR: code indent should never use tabs
#432: FILE: tools/virtiofsd/fuse_lowlevel.c:410:
+^I^Ireturn fuse_reply_err(req, ENOENT);$
ERROR: code indent should never use tabs
#434: FILE: tools/virtiofsd/fuse_lowlevel.c:412:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#435: FILE: tools/virtiofsd/fuse_lowlevel.c:413:
+^Ifill_entry(&arg, e);$
ERROR: code indent should never use tabs
#436: FILE: tools/virtiofsd/fuse_lowlevel.c:414:
+^Ireturn send_reply_ok(req, &arg, size);$
ERROR: code indent should never use tabs
#440: FILE: tools/virtiofsd/fuse_lowlevel.c:418:
+^I^I const struct fuse_file_info *f)$
ERROR: code indent should never use tabs
#442: FILE: tools/virtiofsd/fuse_lowlevel.c:420:
+^Ichar buf[sizeof(struct fuse_entry_out) + sizeof(struct fuse_open_out)];$
ERROR: code indent should never use tabs
#443: FILE: tools/virtiofsd/fuse_lowlevel.c:421:
+^Isize_t entrysize = req->se->conn.proto_minor < 9 ?$
ERROR: code indent should never use tabs
#444: FILE: tools/virtiofsd/fuse_lowlevel.c:422:
+^I^IFUSE_COMPAT_ENTRY_OUT_SIZE : sizeof(struct fuse_entry_out);$
ERROR: code indent should never use tabs
#445: FILE: tools/virtiofsd/fuse_lowlevel.c:423:
+^Istruct fuse_entry_out *earg = (struct fuse_entry_out *) buf;$
ERROR: code indent should never use tabs
#446: FILE: tools/virtiofsd/fuse_lowlevel.c:424:
+^Istruct fuse_open_out *oarg = (struct fuse_open_out *) (buf + entrysize);$
ERROR: code indent should never use tabs
#448: FILE: tools/virtiofsd/fuse_lowlevel.c:426:
+^Imemset(buf, 0, sizeof(buf));$
ERROR: code indent should never use tabs
#449: FILE: tools/virtiofsd/fuse_lowlevel.c:427:
+^Ifill_entry(earg, e);$
ERROR: code indent should never use tabs
#450: FILE: tools/virtiofsd/fuse_lowlevel.c:428:
+^Ifill_open(oarg, f);$
ERROR: code indent should never use tabs
#451: FILE: tools/virtiofsd/fuse_lowlevel.c:429:
+^Ireturn send_reply_ok(req, buf,$
ERROR: code indent should never use tabs
#452: FILE: tools/virtiofsd/fuse_lowlevel.c:430:
+^I^I^I entrysize + sizeof(struct fuse_open_out));$
ERROR: code indent should never use tabs
#456: FILE: tools/virtiofsd/fuse_lowlevel.c:434:
+^I^I double attr_timeout)$
ERROR: code indent should never use tabs
#458: FILE: tools/virtiofsd/fuse_lowlevel.c:436:
+^Istruct fuse_attr_out arg;$
ERROR: code indent should never use tabs
#459: FILE: tools/virtiofsd/fuse_lowlevel.c:437:
+^Isize_t size = req->se->conn.proto_minor < 9 ?$
ERROR: code indent should never use tabs
#460: FILE: tools/virtiofsd/fuse_lowlevel.c:438:
+^I^IFUSE_COMPAT_ATTR_OUT_SIZE : sizeof(arg);$
ERROR: code indent should never use tabs
#462: FILE: tools/virtiofsd/fuse_lowlevel.c:440:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#463: FILE: tools/virtiofsd/fuse_lowlevel.c:441:
+^Iarg.attr_valid = calc_timeout_sec(attr_timeout);$
ERROR: code indent should never use tabs
#464: FILE: tools/virtiofsd/fuse_lowlevel.c:442:
+^Iarg.attr_valid_nsec = calc_timeout_nsec(attr_timeout);$
ERROR: code indent should never use tabs
#465: FILE: tools/virtiofsd/fuse_lowlevel.c:443:
+^Iconvert_stat(attr, &arg.attr);$
ERROR: code indent should never use tabs
#467: FILE: tools/virtiofsd/fuse_lowlevel.c:445:
+^Ireturn send_reply_ok(req, &arg, size);$
ERROR: code indent should never use tabs
#472: FILE: tools/virtiofsd/fuse_lowlevel.c:450:
+^Ireturn send_reply_ok(req, linkname, strlen(linkname));$
ERROR: code indent should never use tabs
#477: FILE: tools/virtiofsd/fuse_lowlevel.c:455:
+^Istruct fuse_open_out arg;$
ERROR: code indent should never use tabs
#479: FILE: tools/virtiofsd/fuse_lowlevel.c:457:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#480: FILE: tools/virtiofsd/fuse_lowlevel.c:458:
+^Ifill_open(&arg, f);$
ERROR: code indent should never use tabs
#481: FILE: tools/virtiofsd/fuse_lowlevel.c:459:
+^Ireturn send_reply_ok(req, &arg, sizeof(arg));$
ERROR: code indent should never use tabs
#486: FILE: tools/virtiofsd/fuse_lowlevel.c:464:
+^Istruct fuse_write_out arg;$
ERROR: code indent should never use tabs
#488: FILE: tools/virtiofsd/fuse_lowlevel.c:466:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#489: FILE: tools/virtiofsd/fuse_lowlevel.c:467:
+^Iarg.size = count;$
ERROR: code indent should never use tabs
#491: FILE: tools/virtiofsd/fuse_lowlevel.c:469:
+^Ireturn send_reply_ok(req, &arg, sizeof(arg));$
ERROR: code indent should never use tabs
#496: FILE: tools/virtiofsd/fuse_lowlevel.c:474:
+^Ireturn send_reply_ok(req, buf, size);$
ERROR: code indent should never use tabs
#500: FILE: tools/virtiofsd/fuse_lowlevel.c:478:
+^I^I^I^I struct fuse_chan *ch,$
ERROR: code indent should never use tabs
#501: FILE: tools/virtiofsd/fuse_lowlevel.c:479:
+^I^I^I^I struct iovec *iov, int iov_count,$
ERROR: code indent should never use tabs
#502: FILE: tools/virtiofsd/fuse_lowlevel.c:480:
+^I^I^I^I struct fuse_bufvec *buf,$
ERROR: code indent should never use tabs
#503: FILE: tools/virtiofsd/fuse_lowlevel.c:481:
+^I^I^I^I size_t len)$
ERROR: code indent should never use tabs
#505: FILE: tools/virtiofsd/fuse_lowlevel.c:483:
+^Istruct fuse_bufvec mem_buf = FUSE_BUFVEC_INIT(len);$
ERROR: code indent should never use tabs
#506: FILE: tools/virtiofsd/fuse_lowlevel.c:484:
+^Ivoid *mbuf;$
ERROR: code indent should never use tabs
#507: FILE: tools/virtiofsd/fuse_lowlevel.c:485:
+^Iint res;$
ERROR: code indent should never use tabs
#509: FILE: tools/virtiofsd/fuse_lowlevel.c:487:
+^I/* Optimize common case */$
ERROR: code indent should never use tabs
#510: FILE: tools/virtiofsd/fuse_lowlevel.c:488:
+^Iif (buf->count == 1 && buf->idx == 0 && buf->off == 0 &&$
ERROR: code indent should never use tabs
#511: FILE: tools/virtiofsd/fuse_lowlevel.c:489:
+^I !(buf->buf[0].flags & FUSE_BUF_IS_FD)) {$
ERROR: code indent should never use tabs
#512: FILE: tools/virtiofsd/fuse_lowlevel.c:490:
+^I^I/* FIXME: also avoid memory copy if there are multiple buffers$
WARNING: Block comments use a leading /* on a separate line
#512: FILE: tools/virtiofsd/fuse_lowlevel.c:490:
+ /* FIXME: also avoid memory copy if there are multiple buffers
ERROR: code indent should never use tabs
#513: FILE: tools/virtiofsd/fuse_lowlevel.c:491:
+^I^I but none of them contain an fd */$
WARNING: Block comments use * on subsequent lines
#513: FILE: tools/virtiofsd/fuse_lowlevel.c:491:
+ /* FIXME: also avoid memory copy if there are multiple buffers
+ but none of them contain an fd */
WARNING: Block comments use a trailing */ on a separate line
#513: FILE: tools/virtiofsd/fuse_lowlevel.c:491:
+ but none of them contain an fd */
ERROR: code indent should never use tabs
#515: FILE: tools/virtiofsd/fuse_lowlevel.c:493:
+^I^Iiov[iov_count].iov_base = buf->buf[0].mem;$
ERROR: code indent should never use tabs
#516: FILE: tools/virtiofsd/fuse_lowlevel.c:494:
+^I^Iiov[iov_count].iov_len = len;$
ERROR: code indent should never use tabs
#517: FILE: tools/virtiofsd/fuse_lowlevel.c:495:
+^I^Iiov_count++;$
ERROR: code indent should never use tabs
#518: FILE: tools/virtiofsd/fuse_lowlevel.c:496:
+^I^Ireturn fuse_send_msg(se, ch, iov, iov_count);$
ERROR: code indent should never use tabs
#519: FILE: tools/virtiofsd/fuse_lowlevel.c:497:
+^I}$
ERROR: code indent should never use tabs
#521: FILE: tools/virtiofsd/fuse_lowlevel.c:499:
+^Ires = posix_memalign(&mbuf, pagesize, len);$
ERROR: code indent should never use tabs
#522: FILE: tools/virtiofsd/fuse_lowlevel.c:500:
+^Iif (res != 0)$
ERROR: braces {} are necessary for all arms of this statement
#522: FILE: tools/virtiofsd/fuse_lowlevel.c:500:
+ if (res != 0)
[...]
ERROR: code indent should never use tabs
#523: FILE: tools/virtiofsd/fuse_lowlevel.c:501:
+^I^Ireturn res;$
ERROR: code indent should never use tabs
#525: FILE: tools/virtiofsd/fuse_lowlevel.c:503:
+^Imem_buf.buf[0].mem = mbuf;$
ERROR: code indent should never use tabs
#526: FILE: tools/virtiofsd/fuse_lowlevel.c:504:
+^Ires = fuse_buf_copy(&mem_buf, buf, 0);$
ERROR: code indent should never use tabs
#527: FILE: tools/virtiofsd/fuse_lowlevel.c:505:
+^Iif (res < 0) {$
ERROR: code indent should never use tabs
#528: FILE: tools/virtiofsd/fuse_lowlevel.c:506:
+^I^Ifree(mbuf);$
ERROR: code indent should never use tabs
#529: FILE: tools/virtiofsd/fuse_lowlevel.c:507:
+^I^Ireturn -res;$
ERROR: code indent should never use tabs
#530: FILE: tools/virtiofsd/fuse_lowlevel.c:508:
+^I}$
ERROR: code indent should never use tabs
#531: FILE: tools/virtiofsd/fuse_lowlevel.c:509:
+^Ilen = res;$
ERROR: code indent should never use tabs
#533: FILE: tools/virtiofsd/fuse_lowlevel.c:511:
+^Iiov[iov_count].iov_base = mbuf;$
ERROR: code indent should never use tabs
#534: FILE: tools/virtiofsd/fuse_lowlevel.c:512:
+^Iiov[iov_count].iov_len = len;$
ERROR: code indent should never use tabs
#535: FILE: tools/virtiofsd/fuse_lowlevel.c:513:
+^Iiov_count++;$
ERROR: code indent should never use tabs
#536: FILE: tools/virtiofsd/fuse_lowlevel.c:514:
+^Ires = fuse_send_msg(se, ch, iov, iov_count);$
ERROR: code indent should never use tabs
#537: FILE: tools/virtiofsd/fuse_lowlevel.c:515:
+^Ifree(mbuf);$
ERROR: code indent should never use tabs
#539: FILE: tools/virtiofsd/fuse_lowlevel.c:517:
+^Ireturn res;$
ERROR: code indent should never use tabs
#543: FILE: tools/virtiofsd/fuse_lowlevel.c:521:
+^Isize_t size;$
ERROR: code indent should never use tabs
#544: FILE: tools/virtiofsd/fuse_lowlevel.c:522:
+^Iint can_grow;$
ERROR: code indent should never use tabs
#545: FILE: tools/virtiofsd/fuse_lowlevel.c:523:
+^Iint pipe[2];$
ERROR: code indent should never use tabs
#550: FILE: tools/virtiofsd/fuse_lowlevel.c:528:
+^Iclose(llp->pipe[0]);$
ERROR: code indent should never use tabs
#551: FILE: tools/virtiofsd/fuse_lowlevel.c:529:
+^Iclose(llp->pipe[1]);$
ERROR: code indent should never use tabs
#552: FILE: tools/virtiofsd/fuse_lowlevel.c:530:
+^Ifree(llp);$
ERROR: code indent should never use tabs
#559: FILE: tools/virtiofsd/fuse_lowlevel.c:537:
+^Iint rv = pipe(fds);$
ERROR: code indent should never use tabs
#561: FILE: tools/virtiofsd/fuse_lowlevel.c:539:
+^Iif (rv == -1)$
ERROR: braces {} are necessary for all arms of this statement
#561: FILE: tools/virtiofsd/fuse_lowlevel.c:539:
+ if (rv == -1)
[...]
ERROR: code indent should never use tabs
#562: FILE: tools/virtiofsd/fuse_lowlevel.c:540:
+^I^Ireturn rv;$
ERROR: code indent should never use tabs
#564: FILE: tools/virtiofsd/fuse_lowlevel.c:542:
+^Iif (fcntl(fds[0], F_SETFL, O_NONBLOCK) == -1 ||$
ERROR: code indent should never use tabs
#565: FILE: tools/virtiofsd/fuse_lowlevel.c:543:
+^I fcntl(fds[1], F_SETFL, O_NONBLOCK) == -1 ||$
ERROR: code indent should never use tabs
#566: FILE: tools/virtiofsd/fuse_lowlevel.c:544:
+^I fcntl(fds[0], F_SETFD, FD_CLOEXEC) == -1 ||$
ERROR: code indent should never use tabs
#567: FILE: tools/virtiofsd/fuse_lowlevel.c:545:
+^I fcntl(fds[1], F_SETFD, FD_CLOEXEC) == -1) {$
ERROR: code indent should never use tabs
#568: FILE: tools/virtiofsd/fuse_lowlevel.c:546:
+^I^Iclose(fds[0]);$
ERROR: code indent should never use tabs
#569: FILE: tools/virtiofsd/fuse_lowlevel.c:547:
+^I^Iclose(fds[1]);$
ERROR: code indent should never use tabs
#570: FILE: tools/virtiofsd/fuse_lowlevel.c:548:
+^I^Irv = -1;$
ERROR: code indent should never use tabs
#571: FILE: tools/virtiofsd/fuse_lowlevel.c:549:
+^I}$
ERROR: code indent should never use tabs
#572: FILE: tools/virtiofsd/fuse_lowlevel.c:550:
+^Ireturn rv;$
ERROR: code indent should never use tabs
#577: FILE: tools/virtiofsd/fuse_lowlevel.c:555:
+^Ireturn pipe2(fds, O_CLOEXEC | O_NONBLOCK);$
ERROR: code indent should never use tabs
#583: FILE: tools/virtiofsd/fuse_lowlevel.c:561:
+^Istruct fuse_ll_pipe *llp = pthread_getspecific(se->pipe_key);$
ERROR: code indent should never use tabs
#584: FILE: tools/virtiofsd/fuse_lowlevel.c:562:
+^Iif (llp == NULL) {$
ERROR: code indent should never use tabs
#585: FILE: tools/virtiofsd/fuse_lowlevel.c:563:
+^I^Iint res;$
ERROR: code indent should never use tabs
#587: FILE: tools/virtiofsd/fuse_lowlevel.c:565:
+^I^Illp = malloc(sizeof(struct fuse_ll_pipe));$
ERROR: code indent should never use tabs
#588: FILE: tools/virtiofsd/fuse_lowlevel.c:566:
+^I^Iif (llp == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#588: FILE: tools/virtiofsd/fuse_lowlevel.c:566:
+ if (llp == NULL)
[...]
ERROR: code indent should never use tabs
#589: FILE: tools/virtiofsd/fuse_lowlevel.c:567:
+^I^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#591: FILE: tools/virtiofsd/fuse_lowlevel.c:569:
+^I^Ires = fuse_pipe(llp->pipe);$
ERROR: code indent should never use tabs
#592: FILE: tools/virtiofsd/fuse_lowlevel.c:570:
+^I^Iif (res == -1) {$
ERROR: code indent should never use tabs
#593: FILE: tools/virtiofsd/fuse_lowlevel.c:571:
+^I^I^Ifree(llp);$
ERROR: code indent should never use tabs
#594: FILE: tools/virtiofsd/fuse_lowlevel.c:572:
+^I^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#595: FILE: tools/virtiofsd/fuse_lowlevel.c:573:
+^I^I}$
ERROR: code indent should never use tabs
#597: FILE: tools/virtiofsd/fuse_lowlevel.c:575:
+^I^I/*$
ERROR: code indent should never use tabs
#598: FILE: tools/virtiofsd/fuse_lowlevel.c:576:
+^I^I *the default size is 16 pages on linux$
ERROR: code indent should never use tabs
#599: FILE: tools/virtiofsd/fuse_lowlevel.c:577:
+^I^I */$
ERROR: code indent should never use tabs
#600: FILE: tools/virtiofsd/fuse_lowlevel.c:578:
+^I^Illp->size = pagesize * 16;$
ERROR: code indent should never use tabs
#601: FILE: tools/virtiofsd/fuse_lowlevel.c:579:
+^I^Illp->can_grow = 1;$
ERROR: code indent should never use tabs
#603: FILE: tools/virtiofsd/fuse_lowlevel.c:581:
+^I^Ipthread_setspecific(se->pipe_key, llp);$
ERROR: code indent should never use tabs
#604: FILE: tools/virtiofsd/fuse_lowlevel.c:582:
+^I}$
ERROR: code indent should never use tabs
#606: FILE: tools/virtiofsd/fuse_lowlevel.c:584:
+^Ireturn llp;$
ERROR: code indent should never use tabs
#612: FILE: tools/virtiofsd/fuse_lowlevel.c:590:
+^Istruct fuse_ll_pipe *llp = pthread_getspecific(se->pipe_key);$
ERROR: code indent should never use tabs
#613: FILE: tools/virtiofsd/fuse_lowlevel.c:591:
+^Iif (llp) {$
ERROR: code indent should never use tabs
#614: FILE: tools/virtiofsd/fuse_lowlevel.c:592:
+^I^Ipthread_setspecific(se->pipe_key, NULL);$
ERROR: code indent should never use tabs
#615: FILE: tools/virtiofsd/fuse_lowlevel.c:593:
+^I^Ifuse_ll_pipe_free(llp);$
ERROR: code indent should never use tabs
#616: FILE: tools/virtiofsd/fuse_lowlevel.c:594:
+^I}$
ERROR: code indent should never use tabs
#622: FILE: tools/virtiofsd/fuse_lowlevel.c:600:
+^Iint res;$
ERROR: code indent should never use tabs
#624: FILE: tools/virtiofsd/fuse_lowlevel.c:602:
+^Ires = read(fd, buf, len);$
ERROR: code indent should never use tabs
#625: FILE: tools/virtiofsd/fuse_lowlevel.c:603:
+^Iif (res == -1) {$
ERROR: line over 90 characters
#626: FILE: tools/virtiofsd/fuse_lowlevel.c:604:
+ fuse_log(FUSE_LOG_ERR, "fuse: internal error: failed to read back from pipe: %s\n", strerror(errno));
ERROR: code indent should never use tabs
#626: FILE: tools/virtiofsd/fuse_lowlevel.c:604:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: internal error: failed to read back from pipe: %s\n", strerror(errno));$
ERROR: code indent should never use tabs
#627: FILE: tools/virtiofsd/fuse_lowlevel.c:605:
+^I^Ireturn -EIO;$
ERROR: code indent should never use tabs
#628: FILE: tools/virtiofsd/fuse_lowlevel.c:606:
+^I}$
ERROR: code indent should never use tabs
#629: FILE: tools/virtiofsd/fuse_lowlevel.c:607:
+^Iif (res != len) {$
ERROR: line over 90 characters
#630: FILE: tools/virtiofsd/fuse_lowlevel.c:608:
+ fuse_log(FUSE_LOG_ERR, "fuse: internal error: short read back from pipe: %i from %zi\n", res, len);
ERROR: code indent should never use tabs
#630: FILE: tools/virtiofsd/fuse_lowlevel.c:608:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: internal error: short read back from pipe: %i from %zi\n", res, len);$
ERROR: code indent should never use tabs
#631: FILE: tools/virtiofsd/fuse_lowlevel.c:609:
+^I^Ireturn -EIO;$
ERROR: code indent should never use tabs
#632: FILE: tools/virtiofsd/fuse_lowlevel.c:610:
+^I}$
ERROR: code indent should never use tabs
#633: FILE: tools/virtiofsd/fuse_lowlevel.c:611:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#638: FILE: tools/virtiofsd/fuse_lowlevel.c:616:
+^Iint max;$
ERROR: code indent should never use tabs
#639: FILE: tools/virtiofsd/fuse_lowlevel.c:617:
+^Iint res;$
ERROR: code indent should never use tabs
#640: FILE: tools/virtiofsd/fuse_lowlevel.c:618:
+^Iint maxfd;$
ERROR: code indent should never use tabs
#641: FILE: tools/virtiofsd/fuse_lowlevel.c:619:
+^Ichar buf[32];$
ERROR: code indent should never use tabs
#643: FILE: tools/virtiofsd/fuse_lowlevel.c:621:
+^Imaxfd = open("/proc/sys/fs/pipe-max-size", O_RDONLY);$
ERROR: code indent should never use tabs
#644: FILE: tools/virtiofsd/fuse_lowlevel.c:622:
+^Iif (maxfd < 0)$
ERROR: braces {} are necessary for all arms of this statement
#644: FILE: tools/virtiofsd/fuse_lowlevel.c:622:
+ if (maxfd < 0)
[...]
ERROR: code indent should never use tabs
#645: FILE: tools/virtiofsd/fuse_lowlevel.c:623:
+^I^Ireturn -errno;$
ERROR: code indent should never use tabs
#647: FILE: tools/virtiofsd/fuse_lowlevel.c:625:
+^Ires = read(maxfd, buf, sizeof(buf) - 1);$
ERROR: code indent should never use tabs
#648: FILE: tools/virtiofsd/fuse_lowlevel.c:626:
+^Iif (res < 0) {$
ERROR: code indent should never use tabs
#649: FILE: tools/virtiofsd/fuse_lowlevel.c:627:
+^I^Iint saved_errno;$
ERROR: code indent should never use tabs
#651: FILE: tools/virtiofsd/fuse_lowlevel.c:629:
+^I^Isaved_errno = errno;$
ERROR: code indent should never use tabs
#652: FILE: tools/virtiofsd/fuse_lowlevel.c:630:
+^I^Iclose(maxfd);$
ERROR: code indent should never use tabs
#653: FILE: tools/virtiofsd/fuse_lowlevel.c:631:
+^I^Ireturn -saved_errno;$
ERROR: code indent should never use tabs
#654: FILE: tools/virtiofsd/fuse_lowlevel.c:632:
+^I}$
ERROR: code indent should never use tabs
#655: FILE: tools/virtiofsd/fuse_lowlevel.c:633:
+^Iclose(maxfd);$
ERROR: code indent should never use tabs
#656: FILE: tools/virtiofsd/fuse_lowlevel.c:634:
+^Ibuf[res] = '\0';$
ERROR: code indent should never use tabs
#658: FILE: tools/virtiofsd/fuse_lowlevel.c:636:
+^Imax = atoi(buf);$
ERROR: code indent should never use tabs
#659: FILE: tools/virtiofsd/fuse_lowlevel.c:637:
+^Ires = fcntl(pipefd, F_SETPIPE_SZ, max);$
ERROR: code indent should never use tabs
#660: FILE: tools/virtiofsd/fuse_lowlevel.c:638:
+^Iif (res < 0)$
ERROR: braces {} are necessary for all arms of this statement
#660: FILE: tools/virtiofsd/fuse_lowlevel.c:638:
+ if (res < 0)
[...]
ERROR: code indent should never use tabs
#661: FILE: tools/virtiofsd/fuse_lowlevel.c:639:
+^I^Ireturn -errno;$
ERROR: code indent should never use tabs
#662: FILE: tools/virtiofsd/fuse_lowlevel.c:640:
+^Ireturn max;$
ERROR: code indent should never use tabs
#666: FILE: tools/virtiofsd/fuse_lowlevel.c:644:
+^I^I^I struct iovec *iov, int iov_count,$
ERROR: code indent should never use tabs
#667: FILE: tools/virtiofsd/fuse_lowlevel.c:645:
+^I^I^I struct fuse_bufvec *buf, unsigned int flags)$
ERROR: code indent should never use tabs
#669: FILE: tools/virtiofsd/fuse_lowlevel.c:647:
+^Iint res;$
ERROR: code indent should never use tabs
#670: FILE: tools/virtiofsd/fuse_lowlevel.c:648:
+^Isize_t len = fuse_buf_size(buf);$
ERROR: code indent should never use tabs
#671: FILE: tools/virtiofsd/fuse_lowlevel.c:649:
+^Istruct fuse_out_header *out = iov[0].iov_base;$
ERROR: code indent should never use tabs
#672: FILE: tools/virtiofsd/fuse_lowlevel.c:650:
+^Istruct fuse_ll_pipe *llp;$
ERROR: code indent should never use tabs
#673: FILE: tools/virtiofsd/fuse_lowlevel.c:651:
+^Iint splice_flags;$
ERROR: code indent should never use tabs
#674: FILE: tools/virtiofsd/fuse_lowlevel.c:652:
+^Isize_t pipesize;$
ERROR: code indent should never use tabs
#675: FILE: tools/virtiofsd/fuse_lowlevel.c:653:
+^Isize_t total_fd_size;$
ERROR: code indent should never use tabs
#676: FILE: tools/virtiofsd/fuse_lowlevel.c:654:
+^Isize_t idx;$
ERROR: code indent should never use tabs
#677: FILE: tools/virtiofsd/fuse_lowlevel.c:655:
+^Isize_t headerlen;$
ERROR: code indent should never use tabs
#678: FILE: tools/virtiofsd/fuse_lowlevel.c:656:
+^Istruct fuse_bufvec pipe_buf = FUSE_BUFVEC_INIT(len);$
ERROR: code indent should never use tabs
#680: FILE: tools/virtiofsd/fuse_lowlevel.c:658:
+^Iif (se->broken_splice_nonblock)$
ERROR: braces {} are necessary for all arms of this statement
#680: FILE: tools/virtiofsd/fuse_lowlevel.c:658:
+ if (se->broken_splice_nonblock)
[...]
ERROR: code indent should never use tabs
#681: FILE: tools/virtiofsd/fuse_lowlevel.c:659:
+^I^Igoto fallback;$
ERROR: code indent should never use tabs
#683: FILE: tools/virtiofsd/fuse_lowlevel.c:661:
+^Iif (flags & FUSE_BUF_NO_SPLICE)$
ERROR: braces {} are necessary for all arms of this statement
#683: FILE: tools/virtiofsd/fuse_lowlevel.c:661:
+ if (flags & FUSE_BUF_NO_SPLICE)
[...]
ERROR: code indent should never use tabs
#684: FILE: tools/virtiofsd/fuse_lowlevel.c:662:
+^I^Igoto fallback;$
ERROR: code indent should never use tabs
#686: FILE: tools/virtiofsd/fuse_lowlevel.c:664:
+^Itotal_fd_size = 0;$
ERROR: code indent should never use tabs
#687: FILE: tools/virtiofsd/fuse_lowlevel.c:665:
+^Ifor (idx = buf->idx; idx < buf->count; idx++) {$
ERROR: code indent should never use tabs
#688: FILE: tools/virtiofsd/fuse_lowlevel.c:666:
+^I^Iif (buf->buf[idx].flags & FUSE_BUF_IS_FD) {$
ERROR: code indent should never use tabs
#689: FILE: tools/virtiofsd/fuse_lowlevel.c:667:
+^I^I^Itotal_fd_size = buf->buf[idx].size;$
ERROR: code indent should never use tabs
#690: FILE: tools/virtiofsd/fuse_lowlevel.c:668:
+^I^I^Iif (idx == buf->idx)$
ERROR: braces {} are necessary for all arms of this statement
#690: FILE: tools/virtiofsd/fuse_lowlevel.c:668:
+ if (idx == buf->idx)
[...]
ERROR: code indent should never use tabs
#691: FILE: tools/virtiofsd/fuse_lowlevel.c:669:
+^I^I^I^Itotal_fd_size -= buf->off;$
ERROR: code indent should never use tabs
#692: FILE: tools/virtiofsd/fuse_lowlevel.c:670:
+^I^I}$
ERROR: code indent should never use tabs
#693: FILE: tools/virtiofsd/fuse_lowlevel.c:671:
+^I}$
ERROR: code indent should never use tabs
#694: FILE: tools/virtiofsd/fuse_lowlevel.c:672:
+^Iif (total_fd_size < 2 * pagesize)$
ERROR: braces {} are necessary for all arms of this statement
#694: FILE: tools/virtiofsd/fuse_lowlevel.c:672:
+ if (total_fd_size < 2 * pagesize)
[...]
ERROR: code indent should never use tabs
#695: FILE: tools/virtiofsd/fuse_lowlevel.c:673:
+^I^Igoto fallback;$
ERROR: code indent should never use tabs
#697: FILE: tools/virtiofsd/fuse_lowlevel.c:675:
+^Iif (se->conn.proto_minor < 14 ||$
ERROR: code indent should never use tabs
#698: FILE: tools/virtiofsd/fuse_lowlevel.c:676:
+^I !(se->conn.want & FUSE_CAP_SPLICE_WRITE))$
ERROR: code indent should never use tabs
#699: FILE: tools/virtiofsd/fuse_lowlevel.c:677:
+^I^Igoto fallback;$
ERROR: code indent should never use tabs
#701: FILE: tools/virtiofsd/fuse_lowlevel.c:679:
+^Illp = fuse_ll_get_pipe(se);$
ERROR: code indent should never use tabs
#702: FILE: tools/virtiofsd/fuse_lowlevel.c:680:
+^Iif (llp == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#702: FILE: tools/virtiofsd/fuse_lowlevel.c:680:
+ if (llp == NULL)
[...]
ERROR: code indent should never use tabs
#703: FILE: tools/virtiofsd/fuse_lowlevel.c:681:
+^I^Igoto fallback;$
ERROR: code indent should never use tabs
#706: FILE: tools/virtiofsd/fuse_lowlevel.c:684:
+^Iheaderlen = iov_length(iov, iov_count);$
ERROR: code indent should never use tabs
#708: FILE: tools/virtiofsd/fuse_lowlevel.c:686:
+^Iout->len = headerlen + len;$
ERROR: code indent should never use tabs
#710: FILE: tools/virtiofsd/fuse_lowlevel.c:688:
+^I/*$
ERROR: code indent should never use tabs
#711: FILE: tools/virtiofsd/fuse_lowlevel.c:689:
+^I * Heuristic for the required pipe size, does not work if the$
ERROR: code indent should never use tabs
#712: FILE: tools/virtiofsd/fuse_lowlevel.c:690:
+^I * source contains less than page size fragments$
ERROR: code indent should never use tabs
#713: FILE: tools/virtiofsd/fuse_lowlevel.c:691:
+^I */$
ERROR: code indent should never use tabs
#714: FILE: tools/virtiofsd/fuse_lowlevel.c:692:
+^Ipipesize = pagesize * (iov_count + buf->count + 1) + out->len;$
ERROR: code indent should never use tabs
#716: FILE: tools/virtiofsd/fuse_lowlevel.c:694:
+^Iif (llp->size < pipesize) {$
ERROR: code indent should never use tabs
#717: FILE: tools/virtiofsd/fuse_lowlevel.c:695:
+^I^Iif (llp->can_grow) {$
ERROR: code indent should never use tabs
#718: FILE: tools/virtiofsd/fuse_lowlevel.c:696:
+^I^I^Ires = fcntl(llp->pipe[0], F_SETPIPE_SZ, pipesize);$
ERROR: code indent should never use tabs
#719: FILE: tools/virtiofsd/fuse_lowlevel.c:697:
+^I^I^Iif (res == -1) {$
ERROR: code indent should never use tabs
#720: FILE: tools/virtiofsd/fuse_lowlevel.c:698:
+^I^I^I^Ires = grow_pipe_to_max(llp->pipe[0]);$
ERROR: code indent should never use tabs
#721: FILE: tools/virtiofsd/fuse_lowlevel.c:699:
+^I^I^I^Iif (res > 0)$
ERROR: braces {} are necessary for all arms of this statement
#721: FILE: tools/virtiofsd/fuse_lowlevel.c:699:
+ if (res > 0)
[...]
ERROR: code indent should never use tabs
#722: FILE: tools/virtiofsd/fuse_lowlevel.c:700:
+^I^I^I^I^Illp->size = res;$
ERROR: code indent should never use tabs
#723: FILE: tools/virtiofsd/fuse_lowlevel.c:701:
+^I^I^I^Illp->can_grow = 0;$
ERROR: code indent should never use tabs
#724: FILE: tools/virtiofsd/fuse_lowlevel.c:702:
+^I^I^I^Igoto fallback;$
ERROR: code indent should never use tabs
#725: FILE: tools/virtiofsd/fuse_lowlevel.c:703:
+^I^I^I}$
ERROR: code indent should never use tabs
#726: FILE: tools/virtiofsd/fuse_lowlevel.c:704:
+^I^I^Illp->size = res;$
ERROR: code indent should never use tabs
#727: FILE: tools/virtiofsd/fuse_lowlevel.c:705:
+^I^I}$
ERROR: code indent should never use tabs
#728: FILE: tools/virtiofsd/fuse_lowlevel.c:706:
+^I^Iif (llp->size < pipesize)$
ERROR: braces {} are necessary for all arms of this statement
#728: FILE: tools/virtiofsd/fuse_lowlevel.c:706:
+ if (llp->size < pipesize)
[...]
ERROR: code indent should never use tabs
#729: FILE: tools/virtiofsd/fuse_lowlevel.c:707:
+^I^I^Igoto fallback;$
ERROR: code indent should never use tabs
#730: FILE: tools/virtiofsd/fuse_lowlevel.c:708:
+^I}$
ERROR: code indent should never use tabs
#733: FILE: tools/virtiofsd/fuse_lowlevel.c:711:
+^Ires = vmsplice(llp->pipe[1], iov, iov_count, SPLICE_F_NONBLOCK);$
ERROR: code indent should never use tabs
#734: FILE: tools/virtiofsd/fuse_lowlevel.c:712:
+^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#734: FILE: tools/virtiofsd/fuse_lowlevel.c:712:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#735: FILE: tools/virtiofsd/fuse_lowlevel.c:713:
+^I^Igoto fallback;$
ERROR: code indent should never use tabs
#737: FILE: tools/virtiofsd/fuse_lowlevel.c:715:
+^Iif (res != headerlen) {$
ERROR: code indent should never use tabs
#738: FILE: tools/virtiofsd/fuse_lowlevel.c:716:
+^I^Ires = -EIO;$
WARNING: line over 80 characters
#739: FILE: tools/virtiofsd/fuse_lowlevel.c:717:
+ fuse_log(FUSE_LOG_ERR, "fuse: short vmsplice to pipe: %u/%zu\n", res,
ERROR: code indent should never use tabs
#739: FILE: tools/virtiofsd/fuse_lowlevel.c:717:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: short vmsplice to pipe: %u/%zu\n", res,$
ERROR: code indent should never use tabs
#740: FILE: tools/virtiofsd/fuse_lowlevel.c:718:
+^I^I^Iheaderlen);$
ERROR: code indent should never use tabs
#741: FILE: tools/virtiofsd/fuse_lowlevel.c:719:
+^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#742: FILE: tools/virtiofsd/fuse_lowlevel.c:720:
+^I}$
ERROR: code indent should never use tabs
#744: FILE: tools/virtiofsd/fuse_lowlevel.c:722:
+^Ipipe_buf.buf[0].flags = FUSE_BUF_IS_FD;$
ERROR: code indent should never use tabs
#745: FILE: tools/virtiofsd/fuse_lowlevel.c:723:
+^Ipipe_buf.buf[0].fd = llp->pipe[1];$
ERROR: code indent should never use tabs
#747: FILE: tools/virtiofsd/fuse_lowlevel.c:725:
+^Ires = fuse_buf_copy(&pipe_buf, buf,$
ERROR: code indent should never use tabs
#748: FILE: tools/virtiofsd/fuse_lowlevel.c:726:
+^I^I^I FUSE_BUF_FORCE_SPLICE | FUSE_BUF_SPLICE_NONBLOCK);$
ERROR: code indent should never use tabs
#749: FILE: tools/virtiofsd/fuse_lowlevel.c:727:
+^Iif (res < 0) {$
ERROR: code indent should never use tabs
#750: FILE: tools/virtiofsd/fuse_lowlevel.c:728:
+^I^Iif (res == -EAGAIN || res == -EINVAL) {$
ERROR: code indent should never use tabs
#751: FILE: tools/virtiofsd/fuse_lowlevel.c:729:
+^I^I^I/*$
ERROR: code indent should never use tabs
#752: FILE: tools/virtiofsd/fuse_lowlevel.c:730:
+^I^I^I * Should only get EAGAIN on kernels with$
ERROR: code indent should never use tabs
#753: FILE: tools/virtiofsd/fuse_lowlevel.c:731:
+^I^I^I * broken SPLICE_F_NONBLOCK support (<=$
ERROR: code indent should never use tabs
#754: FILE: tools/virtiofsd/fuse_lowlevel.c:732:
+^I^I^I * 2.6.35) where this error or a short read is$
ERROR: code indent should never use tabs
#755: FILE: tools/virtiofsd/fuse_lowlevel.c:733:
+^I^I^I * returned even if the pipe itself is not$
ERROR: code indent should never use tabs
#756: FILE: tools/virtiofsd/fuse_lowlevel.c:734:
+^I^I^I * full$
ERROR: code indent should never use tabs
#757: FILE: tools/virtiofsd/fuse_lowlevel.c:735:
+^I^I^I *$
ERROR: code indent should never use tabs
#758: FILE: tools/virtiofsd/fuse_lowlevel.c:736:
+^I^I^I * EINVAL might mean that splice can't handle$
ERROR: code indent should never use tabs
#759: FILE: tools/virtiofsd/fuse_lowlevel.c:737:
+^I^I^I * this combination of input and output.$
ERROR: code indent should never use tabs
#760: FILE: tools/virtiofsd/fuse_lowlevel.c:738:
+^I^I^I */$
ERROR: code indent should never use tabs
#761: FILE: tools/virtiofsd/fuse_lowlevel.c:739:
+^I^I^Iif (res == -EAGAIN)$
ERROR: braces {} are necessary for all arms of this statement
#761: FILE: tools/virtiofsd/fuse_lowlevel.c:739:
+ if (res == -EAGAIN)
[...]
ERROR: code indent should never use tabs
#762: FILE: tools/virtiofsd/fuse_lowlevel.c:740:
+^I^I^I^Ise->broken_splice_nonblock = 1;$
ERROR: code indent should never use tabs
#764: FILE: tools/virtiofsd/fuse_lowlevel.c:742:
+^I^I^Ipthread_setspecific(se->pipe_key, NULL);$
ERROR: code indent should never use tabs
#765: FILE: tools/virtiofsd/fuse_lowlevel.c:743:
+^I^I^Ifuse_ll_pipe_free(llp);$
ERROR: code indent should never use tabs
#766: FILE: tools/virtiofsd/fuse_lowlevel.c:744:
+^I^I^Igoto fallback;$
ERROR: code indent should never use tabs
#767: FILE: tools/virtiofsd/fuse_lowlevel.c:745:
+^I^I}$
ERROR: code indent should never use tabs
#768: FILE: tools/virtiofsd/fuse_lowlevel.c:746:
+^I^Ires = -res;$
ERROR: code indent should never use tabs
#769: FILE: tools/virtiofsd/fuse_lowlevel.c:747:
+^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#770: FILE: tools/virtiofsd/fuse_lowlevel.c:748:
+^I}$
ERROR: code indent should never use tabs
#772: FILE: tools/virtiofsd/fuse_lowlevel.c:750:
+^Iif (res != 0 && res < len) {$
ERROR: code indent should never use tabs
#773: FILE: tools/virtiofsd/fuse_lowlevel.c:751:
+^I^Istruct fuse_bufvec mem_buf = FUSE_BUFVEC_INIT(len);$
ERROR: code indent should never use tabs
#774: FILE: tools/virtiofsd/fuse_lowlevel.c:752:
+^I^Ivoid *mbuf;$
ERROR: code indent should never use tabs
#775: FILE: tools/virtiofsd/fuse_lowlevel.c:753:
+^I^Isize_t now_len = res;$
ERROR: code indent should never use tabs
#776: FILE: tools/virtiofsd/fuse_lowlevel.c:754:
+^I^I/*$
ERROR: code indent should never use tabs
#777: FILE: tools/virtiofsd/fuse_lowlevel.c:755:
+^I^I * For regular files a short count is either$
ERROR: code indent should never use tabs
#778: FILE: tools/virtiofsd/fuse_lowlevel.c:756:
+^I^I * 1) due to EOF, or$
ERROR: code indent should never use tabs
#779: FILE: tools/virtiofsd/fuse_lowlevel.c:757:
+^I^I * 2) because of broken SPLICE_F_NONBLOCK (see above)$
ERROR: code indent should never use tabs
#780: FILE: tools/virtiofsd/fuse_lowlevel.c:758:
+^I^I *$
ERROR: code indent should never use tabs
#781: FILE: tools/virtiofsd/fuse_lowlevel.c:759:
+^I^I * For other inputs it's possible that we overflowed$
ERROR: code indent should never use tabs
#782: FILE: tools/virtiofsd/fuse_lowlevel.c:760:
+^I^I * the pipe because of small buffer fragments.$
ERROR: code indent should never use tabs
#783: FILE: tools/virtiofsd/fuse_lowlevel.c:761:
+^I^I */$
ERROR: code indent should never use tabs
#785: FILE: tools/virtiofsd/fuse_lowlevel.c:763:
+^I^Ires = posix_memalign(&mbuf, pagesize, len);$
ERROR: code indent should never use tabs
#786: FILE: tools/virtiofsd/fuse_lowlevel.c:764:
+^I^Iif (res != 0)$
ERROR: braces {} are necessary for all arms of this statement
#786: FILE: tools/virtiofsd/fuse_lowlevel.c:764:
+ if (res != 0)
[...]
ERROR: code indent should never use tabs
#787: FILE: tools/virtiofsd/fuse_lowlevel.c:765:
+^I^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#789: FILE: tools/virtiofsd/fuse_lowlevel.c:767:
+^I^Imem_buf.buf[0].mem = mbuf;$
ERROR: code indent should never use tabs
#790: FILE: tools/virtiofsd/fuse_lowlevel.c:768:
+^I^Imem_buf.off = now_len;$
ERROR: code indent should never use tabs
#791: FILE: tools/virtiofsd/fuse_lowlevel.c:769:
+^I^Ires = fuse_buf_copy(&mem_buf, buf, 0);$
ERROR: code indent should never use tabs
#792: FILE: tools/virtiofsd/fuse_lowlevel.c:770:
+^I^Iif (res > 0) {$
ERROR: code indent should never use tabs
#793: FILE: tools/virtiofsd/fuse_lowlevel.c:771:
+^I^I^Ichar *tmpbuf;$
ERROR: code indent should never use tabs
#794: FILE: tools/virtiofsd/fuse_lowlevel.c:772:
+^I^I^Isize_t extra_len = res;$
ERROR: code indent should never use tabs
#795: FILE: tools/virtiofsd/fuse_lowlevel.c:773:
+^I^I^I/*$
ERROR: code indent should never use tabs
#796: FILE: tools/virtiofsd/fuse_lowlevel.c:774:
+^I^I^I * Trickiest case: got more data. Need to get$
ERROR: code indent should never use tabs
#797: FILE: tools/virtiofsd/fuse_lowlevel.c:775:
+^I^I^I * back the data from the pipe and then fall$
ERROR: code indent should never use tabs
#798: FILE: tools/virtiofsd/fuse_lowlevel.c:776:
+^I^I^I * back to regular write.$
ERROR: code indent should never use tabs
#799: FILE: tools/virtiofsd/fuse_lowlevel.c:777:
+^I^I^I */$
ERROR: code indent should never use tabs
#800: FILE: tools/virtiofsd/fuse_lowlevel.c:778:
+^I^I^Itmpbuf = malloc(headerlen);$
ERROR: code indent should never use tabs
#801: FILE: tools/virtiofsd/fuse_lowlevel.c:779:
+^I^I^Iif (tmpbuf == NULL) {$
ERROR: code indent should never use tabs
#802: FILE: tools/virtiofsd/fuse_lowlevel.c:780:
+^I^I^I^Ifree(mbuf);$
ERROR: code indent should never use tabs
#803: FILE: tools/virtiofsd/fuse_lowlevel.c:781:
+^I^I^I^Ires = ENOMEM;$
ERROR: code indent should never use tabs
#804: FILE: tools/virtiofsd/fuse_lowlevel.c:782:
+^I^I^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#805: FILE: tools/virtiofsd/fuse_lowlevel.c:783:
+^I^I^I}$
ERROR: code indent should never use tabs
#806: FILE: tools/virtiofsd/fuse_lowlevel.c:784:
+^I^I^Ires = read_back(llp->pipe[0], tmpbuf, headerlen);$
ERROR: code indent should never use tabs
#807: FILE: tools/virtiofsd/fuse_lowlevel.c:785:
+^I^I^Ifree(tmpbuf);$
ERROR: code indent should never use tabs
#808: FILE: tools/virtiofsd/fuse_lowlevel.c:786:
+^I^I^Iif (res != 0) {$
ERROR: code indent should never use tabs
#809: FILE: tools/virtiofsd/fuse_lowlevel.c:787:
+^I^I^I^Ifree(mbuf);$
ERROR: code indent should never use tabs
#810: FILE: tools/virtiofsd/fuse_lowlevel.c:788:
+^I^I^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#811: FILE: tools/virtiofsd/fuse_lowlevel.c:789:
+^I^I^I}$
ERROR: code indent should never use tabs
#812: FILE: tools/virtiofsd/fuse_lowlevel.c:790:
+^I^I^Ires = read_back(llp->pipe[0], mbuf, now_len);$
ERROR: code indent should never use tabs
#813: FILE: tools/virtiofsd/fuse_lowlevel.c:791:
+^I^I^Iif (res != 0) {$
ERROR: code indent should never use tabs
#814: FILE: tools/virtiofsd/fuse_lowlevel.c:792:
+^I^I^I^Ifree(mbuf);$
ERROR: code indent should never use tabs
#815: FILE: tools/virtiofsd/fuse_lowlevel.c:793:
+^I^I^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#816: FILE: tools/virtiofsd/fuse_lowlevel.c:794:
+^I^I^I}$
ERROR: code indent should never use tabs
#817: FILE: tools/virtiofsd/fuse_lowlevel.c:795:
+^I^I^Ilen = now_len + extra_len;$
ERROR: code indent should never use tabs
#818: FILE: tools/virtiofsd/fuse_lowlevel.c:796:
+^I^I^Iiov[iov_count].iov_base = mbuf;$
ERROR: code indent should never use tabs
#819: FILE: tools/virtiofsd/fuse_lowlevel.c:797:
+^I^I^Iiov[iov_count].iov_len = len;$
ERROR: code indent should never use tabs
#820: FILE: tools/virtiofsd/fuse_lowlevel.c:798:
+^I^I^Iiov_count++;$
ERROR: code indent should never use tabs
#821: FILE: tools/virtiofsd/fuse_lowlevel.c:799:
+^I^I^Ires = fuse_send_msg(se, ch, iov, iov_count);$
ERROR: code indent should never use tabs
#822: FILE: tools/virtiofsd/fuse_lowlevel.c:800:
+^I^I^Ifree(mbuf);$
ERROR: code indent should never use tabs
#823: FILE: tools/virtiofsd/fuse_lowlevel.c:801:
+^I^I^Ireturn res;$
ERROR: code indent should never use tabs
#824: FILE: tools/virtiofsd/fuse_lowlevel.c:802:
+^I^I}$
ERROR: code indent should never use tabs
#825: FILE: tools/virtiofsd/fuse_lowlevel.c:803:
+^I^Ifree(mbuf);$
ERROR: code indent should never use tabs
#826: FILE: tools/virtiofsd/fuse_lowlevel.c:804:
+^I^Ires = now_len;$
ERROR: code indent should never use tabs
#827: FILE: tools/virtiofsd/fuse_lowlevel.c:805:
+^I}$
ERROR: code indent should never use tabs
#828: FILE: tools/virtiofsd/fuse_lowlevel.c:806:
+^Ilen = res;$
ERROR: code indent should never use tabs
#829: FILE: tools/virtiofsd/fuse_lowlevel.c:807:
+^Iout->len = headerlen + len;$
ERROR: code indent should never use tabs
#831: FILE: tools/virtiofsd/fuse_lowlevel.c:809:
+^Iif (se->debug) {$
ERROR: code indent should never use tabs
#832: FILE: tools/virtiofsd/fuse_lowlevel.c:810:
+^I^Ifuse_log(FUSE_LOG_DEBUG,$
ERROR: code indent should never use tabs
#833: FILE: tools/virtiofsd/fuse_lowlevel.c:811:
+^I^I^I" unique: %llu, success, outsize: %i (splice)\n",$
ERROR: code indent should never use tabs
#834: FILE: tools/virtiofsd/fuse_lowlevel.c:812:
+^I^I^I(unsigned long long) out->unique, out->len);$
ERROR: code indent should never use tabs
#835: FILE: tools/virtiofsd/fuse_lowlevel.c:813:
+^I}$
ERROR: code indent should never use tabs
#837: FILE: tools/virtiofsd/fuse_lowlevel.c:815:
+^Isplice_flags = 0;$
ERROR: code indent should never use tabs
#838: FILE: tools/virtiofsd/fuse_lowlevel.c:816:
+^Iif ((flags & FUSE_BUF_SPLICE_MOVE) &&$
ERROR: code indent should never use tabs
#839: FILE: tools/virtiofsd/fuse_lowlevel.c:817:
+^I (se->conn.want & FUSE_CAP_SPLICE_MOVE))$
ERROR: code indent should never use tabs
#840: FILE: tools/virtiofsd/fuse_lowlevel.c:818:
+^I^Isplice_flags |= SPLICE_F_MOVE;$
ERROR: code indent should never use tabs
#842: FILE: tools/virtiofsd/fuse_lowlevel.c:820:
+^Ires = splice(llp->pipe[0], NULL, ch ? ch->fd : se->fd,$
ERROR: code indent should never use tabs
#843: FILE: tools/virtiofsd/fuse_lowlevel.c:821:
+^I^I NULL, out->len, splice_flags);$
ERROR: code indent should never use tabs
#844: FILE: tools/virtiofsd/fuse_lowlevel.c:822:
+^Iif (res == -1) {$
ERROR: code indent should never use tabs
#845: FILE: tools/virtiofsd/fuse_lowlevel.c:823:
+^I^Ires = -errno;$
ERROR: code indent should never use tabs
#846: FILE: tools/virtiofsd/fuse_lowlevel.c:824:
+^I^Iperror("fuse: splice from pipe");$
ERROR: code indent should never use tabs
#847: FILE: tools/virtiofsd/fuse_lowlevel.c:825:
+^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#848: FILE: tools/virtiofsd/fuse_lowlevel.c:826:
+^I}$
ERROR: code indent should never use tabs
#849: FILE: tools/virtiofsd/fuse_lowlevel.c:827:
+^Iif (res != out->len) {$
ERROR: code indent should never use tabs
#850: FILE: tools/virtiofsd/fuse_lowlevel.c:828:
+^I^Ires = -EIO;$
ERROR: code indent should never use tabs
#851: FILE: tools/virtiofsd/fuse_lowlevel.c:829:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: short splice from pipe: %u/%u\n",$
ERROR: code indent should never use tabs
#852: FILE: tools/virtiofsd/fuse_lowlevel.c:830:
+^I^I^Ires, out->len);$
ERROR: code indent should never use tabs
#853: FILE: tools/virtiofsd/fuse_lowlevel.c:831:
+^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#854: FILE: tools/virtiofsd/fuse_lowlevel.c:832:
+^I}$
ERROR: code indent should never use tabs
#855: FILE: tools/virtiofsd/fuse_lowlevel.c:833:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#858: FILE: tools/virtiofsd/fuse_lowlevel.c:836:
+^Ifuse_ll_clear_pipe(se);$
ERROR: code indent should never use tabs
#859: FILE: tools/virtiofsd/fuse_lowlevel.c:837:
+^Ireturn res;$
ERROR: code indent should never use tabs
#862: FILE: tools/virtiofsd/fuse_lowlevel.c:840:
+^Ireturn fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);$
ERROR: code indent should never use tabs
#866: FILE: tools/virtiofsd/fuse_lowlevel.c:844:
+^I^I^I struct iovec *iov, int iov_count,$
ERROR: code indent should never use tabs
#867: FILE: tools/virtiofsd/fuse_lowlevel.c:845:
+^I^I^I struct fuse_bufvec *buf, unsigned int flags)$
ERROR: code indent should never use tabs
#869: FILE: tools/virtiofsd/fuse_lowlevel.c:847:
+^Isize_t len = fuse_buf_size(buf);$
ERROR: code indent should never use tabs
#870: FILE: tools/virtiofsd/fuse_lowlevel.c:848:
+^I(void) flags;$
ERROR: code indent should never use tabs
#872: FILE: tools/virtiofsd/fuse_lowlevel.c:850:
+^Ireturn fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);$
ERROR: code indent should never use tabs
#877: FILE: tools/virtiofsd/fuse_lowlevel.c:855:
+^I^I enum fuse_buf_copy_flags flags)$
ERROR: code indent should never use tabs
#879: FILE: tools/virtiofsd/fuse_lowlevel.c:857:
+^Istruct iovec iov[2];$
ERROR: code indent should never use tabs
#880: FILE: tools/virtiofsd/fuse_lowlevel.c:858:
+^Istruct fuse_out_header out;$
ERROR: code indent should never use tabs
#881: FILE: tools/virtiofsd/fuse_lowlevel.c:859:
+^Iint res;$
ERROR: code indent should never use tabs
#883: FILE: tools/virtiofsd/fuse_lowlevel.c:861:
+^Iiov[0].iov_base = &out;$
ERROR: code indent should never use tabs
#884: FILE: tools/virtiofsd/fuse_lowlevel.c:862:
+^Iiov[0].iov_len = sizeof(struct fuse_out_header);$
ERROR: code indent should never use tabs
#886: FILE: tools/virtiofsd/fuse_lowlevel.c:864:
+^Iout.unique = req->unique;$
ERROR: code indent should never use tabs
#887: FILE: tools/virtiofsd/fuse_lowlevel.c:865:
+^Iout.error = 0;$
ERROR: code indent should never use tabs
#889: FILE: tools/virtiofsd/fuse_lowlevel.c:867:
+^Ires = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv, flags);$
ERROR: code indent should never use tabs
#890: FILE: tools/virtiofsd/fuse_lowlevel.c:868:
+^Iif (res <= 0) {$
ERROR: code indent should never use tabs
#891: FILE: tools/virtiofsd/fuse_lowlevel.c:869:
+^I^Ifuse_free_req(req);$
ERROR: code indent should never use tabs
#892: FILE: tools/virtiofsd/fuse_lowlevel.c:870:
+^I^Ireturn res;$
ERROR: code indent should never use tabs
#893: FILE: tools/virtiofsd/fuse_lowlevel.c:871:
+^I} else {$
ERROR: code indent should never use tabs
#894: FILE: tools/virtiofsd/fuse_lowlevel.c:872:
+^I^Ireturn fuse_reply_err(req, res);$
ERROR: code indent should never use tabs
#895: FILE: tools/virtiofsd/fuse_lowlevel.c:873:
+^I}$
ERROR: code indent should never use tabs
#900: FILE: tools/virtiofsd/fuse_lowlevel.c:878:
+^Istruct fuse_statfs_out arg;$
ERROR: code indent should never use tabs
#901: FILE: tools/virtiofsd/fuse_lowlevel.c:879:
+^Isize_t size = req->se->conn.proto_minor < 4 ?$
ERROR: code indent should never use tabs
#902: FILE: tools/virtiofsd/fuse_lowlevel.c:880:
+^I^IFUSE_COMPAT_STATFS_SIZE : sizeof(arg);$
ERROR: code indent should never use tabs
#904: FILE: tools/virtiofsd/fuse_lowlevel.c:882:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#905: FILE: tools/virtiofsd/fuse_lowlevel.c:883:
+^Iconvert_statfs(stbuf, &arg.st);$
ERROR: code indent should never use tabs
#907: FILE: tools/virtiofsd/fuse_lowlevel.c:885:
+^Ireturn send_reply_ok(req, &arg, size);$
ERROR: code indent should never use tabs
#912: FILE: tools/virtiofsd/fuse_lowlevel.c:890:
+^Istruct fuse_getxattr_out arg;$
ERROR: code indent should never use tabs
#914: FILE: tools/virtiofsd/fuse_lowlevel.c:892:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#915: FILE: tools/virtiofsd/fuse_lowlevel.c:893:
+^Iarg.size = count;$
ERROR: code indent should never use tabs
#917: FILE: tools/virtiofsd/fuse_lowlevel.c:895:
+^Ireturn send_reply_ok(req, &arg, sizeof(arg));$
ERROR: code indent should never use tabs
#922: FILE: tools/virtiofsd/fuse_lowlevel.c:900:
+^Istruct fuse_lk_out arg;$
ERROR: code indent should never use tabs
#924: FILE: tools/virtiofsd/fuse_lowlevel.c:902:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#925: FILE: tools/virtiofsd/fuse_lowlevel.c:903:
+^Iarg.lk.type = lock->l_type;$
ERROR: code indent should never use tabs
#926: FILE: tools/virtiofsd/fuse_lowlevel.c:904:
+^Iif (lock->l_type != F_UNLCK) {$
ERROR: code indent should never use tabs
#927: FILE: tools/virtiofsd/fuse_lowlevel.c:905:
+^I^Iarg.lk.start = lock->l_start;$
ERROR: code indent should never use tabs
#928: FILE: tools/virtiofsd/fuse_lowlevel.c:906:
+^I^Iif (lock->l_len == 0)$
ERROR: braces {} are necessary for all arms of this statement
#928: FILE: tools/virtiofsd/fuse_lowlevel.c:906:
+ if (lock->l_len == 0)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#929: FILE: tools/virtiofsd/fuse_lowlevel.c:907:
+^I^I^Iarg.lk.end = OFFSET_MAX;$
ERROR: code indent should never use tabs
#930: FILE: tools/virtiofsd/fuse_lowlevel.c:908:
+^I^Ielse$
ERROR: code indent should never use tabs
#931: FILE: tools/virtiofsd/fuse_lowlevel.c:909:
+^I^I^Iarg.lk.end = lock->l_start + lock->l_len - 1;$
ERROR: code indent should never use tabs
#932: FILE: tools/virtiofsd/fuse_lowlevel.c:910:
+^I}$
ERROR: code indent should never use tabs
#933: FILE: tools/virtiofsd/fuse_lowlevel.c:911:
+^Iarg.lk.pid = lock->l_pid;$
ERROR: code indent should never use tabs
#934: FILE: tools/virtiofsd/fuse_lowlevel.c:912:
+^Ireturn send_reply_ok(req, &arg, sizeof(arg));$
ERROR: code indent should never use tabs
#939: FILE: tools/virtiofsd/fuse_lowlevel.c:917:
+^Istruct fuse_bmap_out arg;$
ERROR: code indent should never use tabs
#941: FILE: tools/virtiofsd/fuse_lowlevel.c:919:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#942: FILE: tools/virtiofsd/fuse_lowlevel.c:920:
+^Iarg.block = idx;$
ERROR: code indent should never use tabs
#944: FILE: tools/virtiofsd/fuse_lowlevel.c:922:
+^Ireturn send_reply_ok(req, &arg, sizeof(arg));$
ERROR: code indent should never use tabs
#948: FILE: tools/virtiofsd/fuse_lowlevel.c:926:
+^I^I^I^I^I^I size_t count)$
ERROR: code indent should never use tabs
#950: FILE: tools/virtiofsd/fuse_lowlevel.c:928:
+^Istruct fuse_ioctl_iovec *fiov;$
ERROR: code indent should never use tabs
#951: FILE: tools/virtiofsd/fuse_lowlevel.c:929:
+^Isize_t i;$
ERROR: code indent should never use tabs
#953: FILE: tools/virtiofsd/fuse_lowlevel.c:931:
+^Ifiov = malloc(sizeof(fiov[0]) * count);$
ERROR: code indent should never use tabs
#954: FILE: tools/virtiofsd/fuse_lowlevel.c:932:
+^Iif (!fiov)$
ERROR: braces {} are necessary for all arms of this statement
#954: FILE: tools/virtiofsd/fuse_lowlevel.c:932:
+ if (!fiov)
[...]
ERROR: code indent should never use tabs
#955: FILE: tools/virtiofsd/fuse_lowlevel.c:933:
+^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#957: FILE: tools/virtiofsd/fuse_lowlevel.c:935:
+^Ifor (i = 0; i < count; i++) {$
ERROR: code indent should never use tabs
#958: FILE: tools/virtiofsd/fuse_lowlevel.c:936:
+^I^Ifiov[i].base = (uintptr_t) iov[i].iov_base;$
ERROR: code indent should never use tabs
#959: FILE: tools/virtiofsd/fuse_lowlevel.c:937:
+^I^Ifiov[i].len = iov[i].iov_len;$
ERROR: code indent should never use tabs
#960: FILE: tools/virtiofsd/fuse_lowlevel.c:938:
+^I}$
ERROR: code indent should never use tabs
#962: FILE: tools/virtiofsd/fuse_lowlevel.c:940:
+^Ireturn fiov;$
ERROR: code indent should never use tabs
#966: FILE: tools/virtiofsd/fuse_lowlevel.c:944:
+^I^I^I const struct iovec *in_iov, size_t in_count,$
ERROR: code indent should never use tabs
#967: FILE: tools/virtiofsd/fuse_lowlevel.c:945:
+^I^I^I const struct iovec *out_iov, size_t out_count)$
ERROR: code indent should never use tabs
#969: FILE: tools/virtiofsd/fuse_lowlevel.c:947:
+^Istruct fuse_ioctl_out arg;$
ERROR: code indent should never use tabs
#970: FILE: tools/virtiofsd/fuse_lowlevel.c:948:
+^Istruct fuse_ioctl_iovec *in_fiov = NULL;$
ERROR: code indent should never use tabs
#971: FILE: tools/virtiofsd/fuse_lowlevel.c:949:
+^Istruct fuse_ioctl_iovec *out_fiov = NULL;$
ERROR: code indent should never use tabs
#972: FILE: tools/virtiofsd/fuse_lowlevel.c:950:
+^Istruct iovec iov[4];$
ERROR: code indent should never use tabs
#973: FILE: tools/virtiofsd/fuse_lowlevel.c:951:
+^Isize_t count = 1;$
ERROR: code indent should never use tabs
#974: FILE: tools/virtiofsd/fuse_lowlevel.c:952:
+^Iint res;$
ERROR: code indent should never use tabs
#976: FILE: tools/virtiofsd/fuse_lowlevel.c:954:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#977: FILE: tools/virtiofsd/fuse_lowlevel.c:955:
+^Iarg.flags |= FUSE_IOCTL_RETRY;$
ERROR: code indent should never use tabs
#978: FILE: tools/virtiofsd/fuse_lowlevel.c:956:
+^Iarg.in_iovs = in_count;$
ERROR: code indent should never use tabs
#979: FILE: tools/virtiofsd/fuse_lowlevel.c:957:
+^Iarg.out_iovs = out_count;$
ERROR: code indent should never use tabs
#980: FILE: tools/virtiofsd/fuse_lowlevel.c:958:
+^Iiov[count].iov_base = &arg;$
ERROR: code indent should never use tabs
#981: FILE: tools/virtiofsd/fuse_lowlevel.c:959:
+^Iiov[count].iov_len = sizeof(arg);$
ERROR: code indent should never use tabs
#982: FILE: tools/virtiofsd/fuse_lowlevel.c:960:
+^Icount++;$
ERROR: code indent should never use tabs
#984: FILE: tools/virtiofsd/fuse_lowlevel.c:962:
+^Iif (req->se->conn.proto_minor < 16) {$
ERROR: code indent should never use tabs
#985: FILE: tools/virtiofsd/fuse_lowlevel.c:963:
+^I^Iif (in_count) {$
ERROR: code indent should never use tabs
#986: FILE: tools/virtiofsd/fuse_lowlevel.c:964:
+^I^I^Iiov[count].iov_base = (void *)in_iov;$
ERROR: code indent should never use tabs
#987: FILE: tools/virtiofsd/fuse_lowlevel.c:965:
+^I^I^Iiov[count].iov_len = sizeof(in_iov[0]) * in_count;$
ERROR: code indent should never use tabs
#988: FILE: tools/virtiofsd/fuse_lowlevel.c:966:
+^I^I^Icount++;$
ERROR: code indent should never use tabs
#989: FILE: tools/virtiofsd/fuse_lowlevel.c:967:
+^I^I}$
ERROR: code indent should never use tabs
#991: FILE: tools/virtiofsd/fuse_lowlevel.c:969:
+^I^Iif (out_count) {$
ERROR: code indent should never use tabs
#992: FILE: tools/virtiofsd/fuse_lowlevel.c:970:
+^I^I^Iiov[count].iov_base = (void *)out_iov;$
ERROR: code indent should never use tabs
#993: FILE: tools/virtiofsd/fuse_lowlevel.c:971:
+^I^I^Iiov[count].iov_len = sizeof(out_iov[0]) * out_count;$
ERROR: code indent should never use tabs
#994: FILE: tools/virtiofsd/fuse_lowlevel.c:972:
+^I^I^Icount++;$
ERROR: code indent should never use tabs
#995: FILE: tools/virtiofsd/fuse_lowlevel.c:973:
+^I^I}$
ERROR: code indent should never use tabs
#996: FILE: tools/virtiofsd/fuse_lowlevel.c:974:
+^I} else {$
ERROR: code indent should never use tabs
#997: FILE: tools/virtiofsd/fuse_lowlevel.c:975:
+^I^I/* Can't handle non-compat 64bit ioctls on 32bit */$
ERROR: code indent should never use tabs
#998: FILE: tools/virtiofsd/fuse_lowlevel.c:976:
+^I^Iif (sizeof(void *) == 4 && req->ioctl_64bit) {$
ERROR: code indent should never use tabs
#999: FILE: tools/virtiofsd/fuse_lowlevel.c:977:
+^I^I^Ires = fuse_reply_err(req, EINVAL);$
ERROR: code indent should never use tabs
#1000: FILE: tools/virtiofsd/fuse_lowlevel.c:978:
+^I^I^Igoto out;$
ERROR: code indent should never use tabs
#1001: FILE: tools/virtiofsd/fuse_lowlevel.c:979:
+^I^I}$
ERROR: code indent should never use tabs
#1003: FILE: tools/virtiofsd/fuse_lowlevel.c:981:
+^I^Iif (in_count) {$
ERROR: code indent should never use tabs
#1004: FILE: tools/virtiofsd/fuse_lowlevel.c:982:
+^I^I^Iin_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);$
ERROR: code indent should never use tabs
#1005: FILE: tools/virtiofsd/fuse_lowlevel.c:983:
+^I^I^Iif (!in_fiov)$
ERROR: braces {} are necessary for all arms of this statement
#1005: FILE: tools/virtiofsd/fuse_lowlevel.c:983:
+ if (!in_fiov)
[...]
ERROR: code indent should never use tabs
#1006: FILE: tools/virtiofsd/fuse_lowlevel.c:984:
+^I^I^I^Igoto enomem;$
ERROR: code indent should never use tabs
#1008: FILE: tools/virtiofsd/fuse_lowlevel.c:986:
+^I^I^Iiov[count].iov_base = (void *)in_fiov;$
ERROR: code indent should never use tabs
#1009: FILE: tools/virtiofsd/fuse_lowlevel.c:987:
+^I^I^Iiov[count].iov_len = sizeof(in_fiov[0]) * in_count;$
ERROR: code indent should never use tabs
#1010: FILE: tools/virtiofsd/fuse_lowlevel.c:988:
+^I^I^Icount++;$
ERROR: code indent should never use tabs
#1011: FILE: tools/virtiofsd/fuse_lowlevel.c:989:
+^I^I}$
ERROR: code indent should never use tabs
#1012: FILE: tools/virtiofsd/fuse_lowlevel.c:990:
+^I^Iif (out_count) {$
ERROR: code indent should never use tabs
#1013: FILE: tools/virtiofsd/fuse_lowlevel.c:991:
+^I^I^Iout_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);$
ERROR: code indent should never use tabs
#1014: FILE: tools/virtiofsd/fuse_lowlevel.c:992:
+^I^I^Iif (!out_fiov)$
ERROR: braces {} are necessary for all arms of this statement
#1014: FILE: tools/virtiofsd/fuse_lowlevel.c:992:
+ if (!out_fiov)
[...]
ERROR: code indent should never use tabs
#1015: FILE: tools/virtiofsd/fuse_lowlevel.c:993:
+^I^I^I^Igoto enomem;$
ERROR: code indent should never use tabs
#1017: FILE: tools/virtiofsd/fuse_lowlevel.c:995:
+^I^I^Iiov[count].iov_base = (void *)out_fiov;$
ERROR: code indent should never use tabs
#1018: FILE: tools/virtiofsd/fuse_lowlevel.c:996:
+^I^I^Iiov[count].iov_len = sizeof(out_fiov[0]) * out_count;$
ERROR: code indent should never use tabs
#1019: FILE: tools/virtiofsd/fuse_lowlevel.c:997:
+^I^I^Icount++;$
ERROR: code indent should never use tabs
#1020: FILE: tools/virtiofsd/fuse_lowlevel.c:998:
+^I^I}$
ERROR: code indent should never use tabs
#1021: FILE: tools/virtiofsd/fuse_lowlevel.c:999:
+^I}$
ERROR: code indent should never use tabs
#1023: FILE: tools/virtiofsd/fuse_lowlevel.c:1001:
+^Ires = send_reply_iov(req, 0, iov, count);$
ERROR: code indent should never use tabs
#1025: FILE: tools/virtiofsd/fuse_lowlevel.c:1003:
+^Ifree(in_fiov);$
ERROR: code indent should never use tabs
#1026: FILE: tools/virtiofsd/fuse_lowlevel.c:1004:
+^Ifree(out_fiov);$
ERROR: code indent should never use tabs
#1028: FILE: tools/virtiofsd/fuse_lowlevel.c:1006:
+^Ireturn res;$
ERROR: code indent should never use tabs
#1031: FILE: tools/virtiofsd/fuse_lowlevel.c:1009:
+^Ires = fuse_reply_err(req, ENOMEM);$
ERROR: code indent should never use tabs
#1032: FILE: tools/virtiofsd/fuse_lowlevel.c:1010:
+^Igoto out;$
ERROR: code indent should never use tabs
#1037: FILE: tools/virtiofsd/fuse_lowlevel.c:1015:
+^Istruct fuse_ioctl_out arg;$
ERROR: code indent should never use tabs
#1038: FILE: tools/virtiofsd/fuse_lowlevel.c:1016:
+^Istruct iovec iov[3];$
ERROR: code indent should never use tabs
#1039: FILE: tools/virtiofsd/fuse_lowlevel.c:1017:
+^Isize_t count = 1;$
ERROR: code indent should never use tabs
#1041: FILE: tools/virtiofsd/fuse_lowlevel.c:1019:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#1042: FILE: tools/virtiofsd/fuse_lowlevel.c:1020:
+^Iarg.result = result;$
ERROR: code indent should never use tabs
#1043: FILE: tools/virtiofsd/fuse_lowlevel.c:1021:
+^Iiov[count].iov_base = &arg;$
ERROR: code indent should never use tabs
#1044: FILE: tools/virtiofsd/fuse_lowlevel.c:1022:
+^Iiov[count].iov_len = sizeof(arg);$
ERROR: code indent should never use tabs
#1045: FILE: tools/virtiofsd/fuse_lowlevel.c:1023:
+^Icount++;$
ERROR: code indent should never use tabs
#1047: FILE: tools/virtiofsd/fuse_lowlevel.c:1025:
+^Iif (size) {$
ERROR: code indent should never use tabs
#1048: FILE: tools/virtiofsd/fuse_lowlevel.c:1026:
+^I^Iiov[count].iov_base = (char *) buf;$
ERROR: code indent should never use tabs
#1049: FILE: tools/virtiofsd/fuse_lowlevel.c:1027:
+^I^Iiov[count].iov_len = size;$
ERROR: code indent should never use tabs
#1050: FILE: tools/virtiofsd/fuse_lowlevel.c:1028:
+^I^Icount++;$
ERROR: code indent should never use tabs
#1051: FILE: tools/virtiofsd/fuse_lowlevel.c:1029:
+^I}$
ERROR: code indent should never use tabs
#1053: FILE: tools/virtiofsd/fuse_lowlevel.c:1031:
+^Ireturn send_reply_iov(req, 0, iov, count);$
ERROR: code indent should never use tabs
#1057: FILE: tools/virtiofsd/fuse_lowlevel.c:1035:
+^I^I^I int count)$
ERROR: code indent should never use tabs
#1059: FILE: tools/virtiofsd/fuse_lowlevel.c:1037:
+^Istruct iovec *padded_iov;$
ERROR: code indent should never use tabs
#1060: FILE: tools/virtiofsd/fuse_lowlevel.c:1038:
+^Istruct fuse_ioctl_out arg;$
ERROR: code indent should never use tabs
#1061: FILE: tools/virtiofsd/fuse_lowlevel.c:1039:
+^Iint res;$
ERROR: code indent should never use tabs
#1063: FILE: tools/virtiofsd/fuse_lowlevel.c:1041:
+^Ipadded_iov = malloc((count + 2) * sizeof(struct iovec));$
ERROR: code indent should never use tabs
#1064: FILE: tools/virtiofsd/fuse_lowlevel.c:1042:
+^Iif (padded_iov == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#1064: FILE: tools/virtiofsd/fuse_lowlevel.c:1042:
+ if (padded_iov == NULL)
[...]
ERROR: code indent should never use tabs
#1065: FILE: tools/virtiofsd/fuse_lowlevel.c:1043:
+^I^Ireturn fuse_reply_err(req, ENOMEM);$
ERROR: code indent should never use tabs
#1067: FILE: tools/virtiofsd/fuse_lowlevel.c:1045:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#1068: FILE: tools/virtiofsd/fuse_lowlevel.c:1046:
+^Iarg.result = result;$
ERROR: code indent should never use tabs
#1069: FILE: tools/virtiofsd/fuse_lowlevel.c:1047:
+^Ipadded_iov[1].iov_base = &arg;$
ERROR: code indent should never use tabs
#1070: FILE: tools/virtiofsd/fuse_lowlevel.c:1048:
+^Ipadded_iov[1].iov_len = sizeof(arg);$
ERROR: code indent should never use tabs
#1072: FILE: tools/virtiofsd/fuse_lowlevel.c:1050:
+^Imemcpy(&padded_iov[2], iov, count * sizeof(struct iovec));$
ERROR: code indent should never use tabs
#1074: FILE: tools/virtiofsd/fuse_lowlevel.c:1052:
+^Ires = send_reply_iov(req, 0, padded_iov, count + 2);$
ERROR: code indent should never use tabs
#1075: FILE: tools/virtiofsd/fuse_lowlevel.c:1053:
+^Ifree(padded_iov);$
ERROR: code indent should never use tabs
#1077: FILE: tools/virtiofsd/fuse_lowlevel.c:1055:
+^Ireturn res;$
ERROR: code indent should never use tabs
#1082: FILE: tools/virtiofsd/fuse_lowlevel.c:1060:
+^Istruct fuse_poll_out arg;$
ERROR: code indent should never use tabs
#1084: FILE: tools/virtiofsd/fuse_lowlevel.c:1062:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#1085: FILE: tools/virtiofsd/fuse_lowlevel.c:1063:
+^Iarg.revents = revents;$
ERROR: code indent should never use tabs
#1087: FILE: tools/virtiofsd/fuse_lowlevel.c:1065:
+^Ireturn send_reply_ok(req, &arg, sizeof(arg));$
ERROR: code indent should never use tabs
#1092: FILE: tools/virtiofsd/fuse_lowlevel.c:1070:
+^Istruct fuse_lseek_out arg;$
ERROR: code indent should never use tabs
#1094: FILE: tools/virtiofsd/fuse_lowlevel.c:1072:
+^Imemset(&arg, 0, sizeof(arg));$
ERROR: code indent should never use tabs
#1095: FILE: tools/virtiofsd/fuse_lowlevel.c:1073:
+^Iarg.offset = off;$
ERROR: code indent should never use tabs
#1097: FILE: tools/virtiofsd/fuse_lowlevel.c:1075:
+^Ireturn send_reply_ok(req, &arg, sizeof(arg));$
ERROR: code indent should never use tabs
#1102: FILE: tools/virtiofsd/fuse_lowlevel.c:1080:
+^Ichar *name = (char *) inarg;$
ERROR: code indent should never use tabs
#1104: FILE: tools/virtiofsd/fuse_lowlevel.c:1082:
+^Iif (req->se->op.lookup)$
ERROR: braces {} are necessary for all arms of this statement
#1104: FILE: tools/virtiofsd/fuse_lowlevel.c:1082:
+ if (req->se->op.lookup)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1105: FILE: tools/virtiofsd/fuse_lowlevel.c:1083:
+^I^Ireq->se->op.lookup(req, nodeid, name);$
ERROR: code indent should never use tabs
#1106: FILE: tools/virtiofsd/fuse_lowlevel.c:1084:
+^Ielse$
ERROR: code indent should never use tabs
#1107: FILE: tools/virtiofsd/fuse_lowlevel.c:1085:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1112: FILE: tools/virtiofsd/fuse_lowlevel.c:1090:
+^Istruct fuse_forget_in *arg = (struct fuse_forget_in *) inarg;$
ERROR: code indent should never use tabs
#1114: FILE: tools/virtiofsd/fuse_lowlevel.c:1092:
+^Iif (req->se->op.forget)$
ERROR: braces {} are necessary for all arms of this statement
#1114: FILE: tools/virtiofsd/fuse_lowlevel.c:1092:
+ if (req->se->op.forget)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1115: FILE: tools/virtiofsd/fuse_lowlevel.c:1093:
+^I^Ireq->se->op.forget(req, nodeid, arg->nlookup);$
ERROR: code indent should never use tabs
#1116: FILE: tools/virtiofsd/fuse_lowlevel.c:1094:
+^Ielse$
ERROR: code indent should never use tabs
#1117: FILE: tools/virtiofsd/fuse_lowlevel.c:1095:
+^I^Ifuse_reply_none(req);$
ERROR: code indent should never use tabs
#1121: FILE: tools/virtiofsd/fuse_lowlevel.c:1099:
+^I^I^I const void *inarg)$
ERROR: code indent should never use tabs
#1123: FILE: tools/virtiofsd/fuse_lowlevel.c:1101:
+^Istruct fuse_batch_forget_in *arg = (void *) inarg;$
ERROR: code indent should never use tabs
#1124: FILE: tools/virtiofsd/fuse_lowlevel.c:1102:
+^Istruct fuse_forget_one *param = (void *) PARAM(arg);$
ERROR: code indent should never use tabs
#1125: FILE: tools/virtiofsd/fuse_lowlevel.c:1103:
+^Iunsigned int i;$
ERROR: code indent should never use tabs
#1127: FILE: tools/virtiofsd/fuse_lowlevel.c:1105:
+^I(void) nodeid;$
ERROR: code indent should never use tabs
#1129: FILE: tools/virtiofsd/fuse_lowlevel.c:1107:
+^Iif (req->se->op.forget_multi) {$
ERROR: code indent should never use tabs
#1130: FILE: tools/virtiofsd/fuse_lowlevel.c:1108:
+^I^Ireq->se->op.forget_multi(req, arg->count,$
ERROR: code indent should never use tabs
#1131: FILE: tools/virtiofsd/fuse_lowlevel.c:1109:
+^I^I^I^I (struct fuse_forget_data *) param);$
ERROR: code indent should never use tabs
#1132: FILE: tools/virtiofsd/fuse_lowlevel.c:1110:
+^I} else if (req->se->op.forget) {$
ERROR: code indent should never use tabs
#1133: FILE: tools/virtiofsd/fuse_lowlevel.c:1111:
+^I^Ifor (i = 0; i < arg->count; i++) {$
ERROR: code indent should never use tabs
#1134: FILE: tools/virtiofsd/fuse_lowlevel.c:1112:
+^I^I^Istruct fuse_forget_one *forget = ¶m[i];$
ERROR: code indent should never use tabs
#1135: FILE: tools/virtiofsd/fuse_lowlevel.c:1113:
+^I^I^Istruct fuse_req *dummy_req;$
ERROR: code indent should never use tabs
#1137: FILE: tools/virtiofsd/fuse_lowlevel.c:1115:
+^I^I^Idummy_req = fuse_ll_alloc_req(req->se);$
ERROR: code indent should never use tabs
#1138: FILE: tools/virtiofsd/fuse_lowlevel.c:1116:
+^I^I^Iif (dummy_req == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#1138: FILE: tools/virtiofsd/fuse_lowlevel.c:1116:
+ if (dummy_req == NULL)
[...]
ERROR: code indent should never use tabs
#1139: FILE: tools/virtiofsd/fuse_lowlevel.c:1117:
+^I^I^I^Ibreak;$
ERROR: code indent should never use tabs
#1141: FILE: tools/virtiofsd/fuse_lowlevel.c:1119:
+^I^I^Idummy_req->unique = req->unique;$
ERROR: code indent should never use tabs
#1142: FILE: tools/virtiofsd/fuse_lowlevel.c:1120:
+^I^I^Idummy_req->ctx = req->ctx;$
ERROR: code indent should never use tabs
#1143: FILE: tools/virtiofsd/fuse_lowlevel.c:1121:
+^I^I^Idummy_req->ch = NULL;$
ERROR: code indent should never use tabs
#1145: FILE: tools/virtiofsd/fuse_lowlevel.c:1123:
+^I^I^Ireq->se->op.forget(dummy_req, forget->nodeid,$
ERROR: code indent should never use tabs
#1146: FILE: tools/virtiofsd/fuse_lowlevel.c:1124:
+^I^I^I^I^I forget->nlookup);$
ERROR: code indent should never use tabs
#1147: FILE: tools/virtiofsd/fuse_lowlevel.c:1125:
+^I^I}$
ERROR: code indent should never use tabs
#1148: FILE: tools/virtiofsd/fuse_lowlevel.c:1126:
+^I^Ifuse_reply_none(req);$
ERROR: code indent should never use tabs
#1149: FILE: tools/virtiofsd/fuse_lowlevel.c:1127:
+^I} else {$
ERROR: code indent should never use tabs
#1150: FILE: tools/virtiofsd/fuse_lowlevel.c:1128:
+^I^Ifuse_reply_none(req);$
ERROR: code indent should never use tabs
#1151: FILE: tools/virtiofsd/fuse_lowlevel.c:1129:
+^I}$
ERROR: code indent should never use tabs
#1156: FILE: tools/virtiofsd/fuse_lowlevel.c:1134:
+^Istruct fuse_file_info *fip = NULL;$
ERROR: code indent should never use tabs
#1157: FILE: tools/virtiofsd/fuse_lowlevel.c:1135:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1159: FILE: tools/virtiofsd/fuse_lowlevel.c:1137:
+^Iif (req->se->conn.proto_minor >= 9) {$
ERROR: code indent should never use tabs
#1160: FILE: tools/virtiofsd/fuse_lowlevel.c:1138:
+^I^Istruct fuse_getattr_in *arg = (struct fuse_getattr_in *) inarg;$
ERROR: code indent should never use tabs
#1162: FILE: tools/virtiofsd/fuse_lowlevel.c:1140:
+^I^Iif (arg->getattr_flags & FUSE_GETATTR_FH) {$
ERROR: code indent should never use tabs
#1163: FILE: tools/virtiofsd/fuse_lowlevel.c:1141:
+^I^I^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1164: FILE: tools/virtiofsd/fuse_lowlevel.c:1142:
+^I^I^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1165: FILE: tools/virtiofsd/fuse_lowlevel.c:1143:
+^I^I^Ifip = &fi;$
ERROR: code indent should never use tabs
#1166: FILE: tools/virtiofsd/fuse_lowlevel.c:1144:
+^I^I}$
ERROR: code indent should never use tabs
#1167: FILE: tools/virtiofsd/fuse_lowlevel.c:1145:
+^I}$
ERROR: code indent should never use tabs
#1169: FILE: tools/virtiofsd/fuse_lowlevel.c:1147:
+^Iif (req->se->op.getattr)$
ERROR: braces {} are necessary for all arms of this statement
#1169: FILE: tools/virtiofsd/fuse_lowlevel.c:1147:
+ if (req->se->op.getattr)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1170: FILE: tools/virtiofsd/fuse_lowlevel.c:1148:
+^I^Ireq->se->op.getattr(req, nodeid, fip);$
ERROR: code indent should never use tabs
#1171: FILE: tools/virtiofsd/fuse_lowlevel.c:1149:
+^Ielse$
ERROR: code indent should never use tabs
#1172: FILE: tools/virtiofsd/fuse_lowlevel.c:1150:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1177: FILE: tools/virtiofsd/fuse_lowlevel.c:1155:
+^Istruct fuse_setattr_in *arg = (struct fuse_setattr_in *) inarg;$
ERROR: code indent should never use tabs
#1179: FILE: tools/virtiofsd/fuse_lowlevel.c:1157:
+^Iif (req->se->op.setattr) {$
ERROR: code indent should never use tabs
#1180: FILE: tools/virtiofsd/fuse_lowlevel.c:1158:
+^I^Istruct fuse_file_info *fi = NULL;$
ERROR: code indent should never use tabs
#1181: FILE: tools/virtiofsd/fuse_lowlevel.c:1159:
+^I^Istruct fuse_file_info fi_store;$
ERROR: code indent should never use tabs
#1182: FILE: tools/virtiofsd/fuse_lowlevel.c:1160:
+^I^Istruct stat stbuf;$
ERROR: code indent should never use tabs
#1183: FILE: tools/virtiofsd/fuse_lowlevel.c:1161:
+^I^Imemset(&stbuf, 0, sizeof(stbuf));$
ERROR: code indent should never use tabs
#1184: FILE: tools/virtiofsd/fuse_lowlevel.c:1162:
+^I^Iconvert_attr(arg, &stbuf);$
ERROR: code indent should never use tabs
#1185: FILE: tools/virtiofsd/fuse_lowlevel.c:1163:
+^I^Iif (arg->valid & FATTR_FH) {$
ERROR: code indent should never use tabs
#1186: FILE: tools/virtiofsd/fuse_lowlevel.c:1164:
+^I^I^Iarg->valid &= ~FATTR_FH;$
ERROR: code indent should never use tabs
#1187: FILE: tools/virtiofsd/fuse_lowlevel.c:1165:
+^I^I^Imemset(&fi_store, 0, sizeof(fi_store));$
ERROR: code indent should never use tabs
#1188: FILE: tools/virtiofsd/fuse_lowlevel.c:1166:
+^I^I^Ifi = &fi_store;$
ERROR: code indent should never use tabs
#1189: FILE: tools/virtiofsd/fuse_lowlevel.c:1167:
+^I^I^Ifi->fh = arg->fh;$
ERROR: code indent should never use tabs
#1190: FILE: tools/virtiofsd/fuse_lowlevel.c:1168:
+^I^I}$
ERROR: code indent should never use tabs
#1191: FILE: tools/virtiofsd/fuse_lowlevel.c:1169:
+^I^Iarg->valid &=$
ERROR: code indent should never use tabs
#1192: FILE: tools/virtiofsd/fuse_lowlevel.c:1170:
+^I^I^IFUSE_SET_ATTR_MODE^I|$
ERROR: code indent should never use tabs
#1193: FILE: tools/virtiofsd/fuse_lowlevel.c:1171:
+^I^I^IFUSE_SET_ATTR_UID^I|$
ERROR: code indent should never use tabs
#1194: FILE: tools/virtiofsd/fuse_lowlevel.c:1172:
+^I^I^IFUSE_SET_ATTR_GID^I|$
ERROR: code indent should never use tabs
#1195: FILE: tools/virtiofsd/fuse_lowlevel.c:1173:
+^I^I^IFUSE_SET_ATTR_SIZE^I|$
ERROR: code indent should never use tabs
#1196: FILE: tools/virtiofsd/fuse_lowlevel.c:1174:
+^I^I^IFUSE_SET_ATTR_ATIME^I|$
ERROR: code indent should never use tabs
#1197: FILE: tools/virtiofsd/fuse_lowlevel.c:1175:
+^I^I^IFUSE_SET_ATTR_MTIME^I|$
ERROR: code indent should never use tabs
#1198: FILE: tools/virtiofsd/fuse_lowlevel.c:1176:
+^I^I^IFUSE_SET_ATTR_ATIME_NOW^I|$
ERROR: code indent should never use tabs
#1199: FILE: tools/virtiofsd/fuse_lowlevel.c:1177:
+^I^I^IFUSE_SET_ATTR_MTIME_NOW |$
ERROR: code indent should never use tabs
#1200: FILE: tools/virtiofsd/fuse_lowlevel.c:1178:
+^I^I^IFUSE_SET_ATTR_CTIME;$
ERROR: code indent should never use tabs
#1202: FILE: tools/virtiofsd/fuse_lowlevel.c:1180:
+^I^Ireq->se->op.setattr(req, nodeid, &stbuf, arg->valid, fi);$
ERROR: code indent should never use tabs
#1203: FILE: tools/virtiofsd/fuse_lowlevel.c:1181:
+^I} else$
ERROR: code indent should never use tabs
#1204: FILE: tools/virtiofsd/fuse_lowlevel.c:1182:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1209: FILE: tools/virtiofsd/fuse_lowlevel.c:1187:
+^Istruct fuse_access_in *arg = (struct fuse_access_in *) inarg;$
ERROR: code indent should never use tabs
#1211: FILE: tools/virtiofsd/fuse_lowlevel.c:1189:
+^Iif (req->se->op.access)$
ERROR: braces {} are necessary for all arms of this statement
#1211: FILE: tools/virtiofsd/fuse_lowlevel.c:1189:
+ if (req->se->op.access)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1212: FILE: tools/virtiofsd/fuse_lowlevel.c:1190:
+^I^Ireq->se->op.access(req, nodeid, arg->mask);$
ERROR: code indent should never use tabs
#1213: FILE: tools/virtiofsd/fuse_lowlevel.c:1191:
+^Ielse$
ERROR: code indent should never use tabs
#1214: FILE: tools/virtiofsd/fuse_lowlevel.c:1192:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1219: FILE: tools/virtiofsd/fuse_lowlevel.c:1197:
+^I(void) inarg;$
ERROR: code indent should never use tabs
#1221: FILE: tools/virtiofsd/fuse_lowlevel.c:1199:
+^Iif (req->se->op.readlink)$
ERROR: braces {} are necessary for all arms of this statement
#1221: FILE: tools/virtiofsd/fuse_lowlevel.c:1199:
+ if (req->se->op.readlink)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1222: FILE: tools/virtiofsd/fuse_lowlevel.c:1200:
+^I^Ireq->se->op.readlink(req, nodeid);$
ERROR: code indent should never use tabs
#1223: FILE: tools/virtiofsd/fuse_lowlevel.c:1201:
+^Ielse$
ERROR: code indent should never use tabs
#1224: FILE: tools/virtiofsd/fuse_lowlevel.c:1202:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1229: FILE: tools/virtiofsd/fuse_lowlevel.c:1207:
+^Istruct fuse_mknod_in *arg = (struct fuse_mknod_in *) inarg;$
ERROR: code indent should never use tabs
#1230: FILE: tools/virtiofsd/fuse_lowlevel.c:1208:
+^Ichar *name = PARAM(arg);$
ERROR: code indent should never use tabs
#1232: FILE: tools/virtiofsd/fuse_lowlevel.c:1210:
+^Iif (req->se->conn.proto_minor >= 12)$
ERROR: braces {} are necessary for all arms of this statement
#1232: FILE: tools/virtiofsd/fuse_lowlevel.c:1210:
+ if (req->se->conn.proto_minor >= 12)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1233: FILE: tools/virtiofsd/fuse_lowlevel.c:1211:
+^I^Ireq->ctx.umask = arg->umask;$
ERROR: code indent should never use tabs
#1234: FILE: tools/virtiofsd/fuse_lowlevel.c:1212:
+^Ielse$
ERROR: code indent should never use tabs
#1235: FILE: tools/virtiofsd/fuse_lowlevel.c:1213:
+^I^Iname = (char *) inarg + FUSE_COMPAT_MKNOD_IN_SIZE;$
ERROR: code indent should never use tabs
#1237: FILE: tools/virtiofsd/fuse_lowlevel.c:1215:
+^Iif (req->se->op.mknod)$
ERROR: braces {} are necessary for all arms of this statement
#1237: FILE: tools/virtiofsd/fuse_lowlevel.c:1215:
+ if (req->se->op.mknod)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1238: FILE: tools/virtiofsd/fuse_lowlevel.c:1216:
+^I^Ireq->se->op.mknod(req, nodeid, name, arg->mode, arg->rdev);$
ERROR: code indent should never use tabs
#1239: FILE: tools/virtiofsd/fuse_lowlevel.c:1217:
+^Ielse$
ERROR: code indent should never use tabs
#1240: FILE: tools/virtiofsd/fuse_lowlevel.c:1218:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1245: FILE: tools/virtiofsd/fuse_lowlevel.c:1223:
+^Istruct fuse_mkdir_in *arg = (struct fuse_mkdir_in *) inarg;$
ERROR: code indent should never use tabs
#1247: FILE: tools/virtiofsd/fuse_lowlevel.c:1225:
+^Iif (req->se->conn.proto_minor >= 12)$
ERROR: braces {} are necessary for all arms of this statement
#1247: FILE: tools/virtiofsd/fuse_lowlevel.c:1225:
+ if (req->se->conn.proto_minor >= 12)
[...]
ERROR: code indent should never use tabs
#1248: FILE: tools/virtiofsd/fuse_lowlevel.c:1226:
+^I^Ireq->ctx.umask = arg->umask;$
ERROR: code indent should never use tabs
#1250: FILE: tools/virtiofsd/fuse_lowlevel.c:1228:
+^Iif (req->se->op.mkdir)$
ERROR: braces {} are necessary for all arms of this statement
#1250: FILE: tools/virtiofsd/fuse_lowlevel.c:1228:
+ if (req->se->op.mkdir)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1251: FILE: tools/virtiofsd/fuse_lowlevel.c:1229:
+^I^Ireq->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);$
ERROR: code indent should never use tabs
#1252: FILE: tools/virtiofsd/fuse_lowlevel.c:1230:
+^Ielse$
ERROR: code indent should never use tabs
#1253: FILE: tools/virtiofsd/fuse_lowlevel.c:1231:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1258: FILE: tools/virtiofsd/fuse_lowlevel.c:1236:
+^Ichar *name = (char *) inarg;$
ERROR: code indent should never use tabs
#1260: FILE: tools/virtiofsd/fuse_lowlevel.c:1238:
+^Iif (req->se->op.unlink)$
ERROR: braces {} are necessary for all arms of this statement
#1260: FILE: tools/virtiofsd/fuse_lowlevel.c:1238:
+ if (req->se->op.unlink)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1261: FILE: tools/virtiofsd/fuse_lowlevel.c:1239:
+^I^Ireq->se->op.unlink(req, nodeid, name);$
ERROR: code indent should never use tabs
#1262: FILE: tools/virtiofsd/fuse_lowlevel.c:1240:
+^Ielse$
ERROR: code indent should never use tabs
#1263: FILE: tools/virtiofsd/fuse_lowlevel.c:1241:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1268: FILE: tools/virtiofsd/fuse_lowlevel.c:1246:
+^Ichar *name = (char *) inarg;$
ERROR: code indent should never use tabs
#1270: FILE: tools/virtiofsd/fuse_lowlevel.c:1248:
+^Iif (req->se->op.rmdir)$
ERROR: braces {} are necessary for all arms of this statement
#1270: FILE: tools/virtiofsd/fuse_lowlevel.c:1248:
+ if (req->se->op.rmdir)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1271: FILE: tools/virtiofsd/fuse_lowlevel.c:1249:
+^I^Ireq->se->op.rmdir(req, nodeid, name);$
ERROR: code indent should never use tabs
#1272: FILE: tools/virtiofsd/fuse_lowlevel.c:1250:
+^Ielse$
ERROR: code indent should never use tabs
#1273: FILE: tools/virtiofsd/fuse_lowlevel.c:1251:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1278: FILE: tools/virtiofsd/fuse_lowlevel.c:1256:
+^Ichar *name = (char *) inarg;$
ERROR: code indent should never use tabs
#1279: FILE: tools/virtiofsd/fuse_lowlevel.c:1257:
+^Ichar *linkname = ((char *) inarg) + strlen((char *) inarg) + 1;$
ERROR: code indent should never use tabs
#1281: FILE: tools/virtiofsd/fuse_lowlevel.c:1259:
+^Iif (req->se->op.symlink)$
ERROR: braces {} are necessary for all arms of this statement
#1281: FILE: tools/virtiofsd/fuse_lowlevel.c:1259:
+ if (req->se->op.symlink)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1282: FILE: tools/virtiofsd/fuse_lowlevel.c:1260:
+^I^Ireq->se->op.symlink(req, linkname, nodeid, name);$
ERROR: code indent should never use tabs
#1283: FILE: tools/virtiofsd/fuse_lowlevel.c:1261:
+^Ielse$
ERROR: code indent should never use tabs
#1284: FILE: tools/virtiofsd/fuse_lowlevel.c:1262:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1289: FILE: tools/virtiofsd/fuse_lowlevel.c:1267:
+^Istruct fuse_rename_in *arg = (struct fuse_rename_in *) inarg;$
ERROR: code indent should never use tabs
#1290: FILE: tools/virtiofsd/fuse_lowlevel.c:1268:
+^Ichar *oldname = PARAM(arg);$
ERROR: code indent should never use tabs
#1291: FILE: tools/virtiofsd/fuse_lowlevel.c:1269:
+^Ichar *newname = oldname + strlen(oldname) + 1;$
ERROR: code indent should never use tabs
#1293: FILE: tools/virtiofsd/fuse_lowlevel.c:1271:
+^Iif (req->se->op.rename)$
ERROR: code indent should never use tabs
#1294: FILE: tools/virtiofsd/fuse_lowlevel.c:1272:
+^I^Ireq->se->op.rename(req, nodeid, oldname, arg->newdir, newname,$
ERROR: code indent should never use tabs
#1295: FILE: tools/virtiofsd/fuse_lowlevel.c:1273:
+^I^I^I^I 0);$
ERROR: code indent should never use tabs
#1296: FILE: tools/virtiofsd/fuse_lowlevel.c:1274:
+^Ielse$
ERROR: code indent should never use tabs
#1297: FILE: tools/virtiofsd/fuse_lowlevel.c:1275:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1302: FILE: tools/virtiofsd/fuse_lowlevel.c:1280:
+^Istruct fuse_rename2_in *arg = (struct fuse_rename2_in *) inarg;$
ERROR: code indent should never use tabs
#1303: FILE: tools/virtiofsd/fuse_lowlevel.c:1281:
+^Ichar *oldname = PARAM(arg);$
ERROR: code indent should never use tabs
#1304: FILE: tools/virtiofsd/fuse_lowlevel.c:1282:
+^Ichar *newname = oldname + strlen(oldname) + 1;$
ERROR: code indent should never use tabs
#1306: FILE: tools/virtiofsd/fuse_lowlevel.c:1284:
+^Iif (req->se->op.rename)$
ERROR: code indent should never use tabs
#1307: FILE: tools/virtiofsd/fuse_lowlevel.c:1285:
+^I^Ireq->se->op.rename(req, nodeid, oldname, arg->newdir, newname,$
ERROR: code indent should never use tabs
#1308: FILE: tools/virtiofsd/fuse_lowlevel.c:1286:
+^I^I^I^I arg->flags);$
ERROR: code indent should never use tabs
#1309: FILE: tools/virtiofsd/fuse_lowlevel.c:1287:
+^Ielse$
ERROR: code indent should never use tabs
#1310: FILE: tools/virtiofsd/fuse_lowlevel.c:1288:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1315: FILE: tools/virtiofsd/fuse_lowlevel.c:1293:
+^Istruct fuse_link_in *arg = (struct fuse_link_in *) inarg;$
ERROR: code indent should never use tabs
#1317: FILE: tools/virtiofsd/fuse_lowlevel.c:1295:
+^Iif (req->se->op.link)$
ERROR: braces {} are necessary for all arms of this statement
#1317: FILE: tools/virtiofsd/fuse_lowlevel.c:1295:
+ if (req->se->op.link)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1318: FILE: tools/virtiofsd/fuse_lowlevel.c:1296:
+^I^Ireq->se->op.link(req, arg->oldnodeid, nodeid, PARAM(arg));$
ERROR: code indent should never use tabs
#1319: FILE: tools/virtiofsd/fuse_lowlevel.c:1297:
+^Ielse$
ERROR: code indent should never use tabs
#1320: FILE: tools/virtiofsd/fuse_lowlevel.c:1298:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1325: FILE: tools/virtiofsd/fuse_lowlevel.c:1303:
+^Istruct fuse_create_in *arg = (struct fuse_create_in *) inarg;$
ERROR: code indent should never use tabs
#1327: FILE: tools/virtiofsd/fuse_lowlevel.c:1305:
+^Iif (req->se->op.create) {$
ERROR: code indent should never use tabs
#1328: FILE: tools/virtiofsd/fuse_lowlevel.c:1306:
+^I^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1329: FILE: tools/virtiofsd/fuse_lowlevel.c:1307:
+^I^Ichar *name = PARAM(arg);$
ERROR: code indent should never use tabs
#1331: FILE: tools/virtiofsd/fuse_lowlevel.c:1309:
+^I^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1332: FILE: tools/virtiofsd/fuse_lowlevel.c:1310:
+^I^Ifi.flags = arg->flags;$
ERROR: code indent should never use tabs
#1334: FILE: tools/virtiofsd/fuse_lowlevel.c:1312:
+^I^Iif (req->se->conn.proto_minor >= 12)$
ERROR: braces {} are necessary for all arms of this statement
#1334: FILE: tools/virtiofsd/fuse_lowlevel.c:1312:
+ if (req->se->conn.proto_minor >= 12)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1335: FILE: tools/virtiofsd/fuse_lowlevel.c:1313:
+^I^I^Ireq->ctx.umask = arg->umask;$
ERROR: code indent should never use tabs
#1336: FILE: tools/virtiofsd/fuse_lowlevel.c:1314:
+^I^Ielse$
ERROR: code indent should never use tabs
#1337: FILE: tools/virtiofsd/fuse_lowlevel.c:1315:
+^I^I^Iname = (char *) inarg + sizeof(struct fuse_open_in);$
ERROR: code indent should never use tabs
#1339: FILE: tools/virtiofsd/fuse_lowlevel.c:1317:
+^I^Ireq->se->op.create(req, nodeid, name, arg->mode, &fi);$
ERROR: code indent should never use tabs
#1340: FILE: tools/virtiofsd/fuse_lowlevel.c:1318:
+^I} else$
ERROR: code indent should never use tabs
#1341: FILE: tools/virtiofsd/fuse_lowlevel.c:1319:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1346: FILE: tools/virtiofsd/fuse_lowlevel.c:1324:
+^Istruct fuse_open_in *arg = (struct fuse_open_in *) inarg;$
ERROR: code indent should never use tabs
#1347: FILE: tools/virtiofsd/fuse_lowlevel.c:1325:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1349: FILE: tools/virtiofsd/fuse_lowlevel.c:1327:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1350: FILE: tools/virtiofsd/fuse_lowlevel.c:1328:
+^Ifi.flags = arg->flags;$
ERROR: code indent should never use tabs
#1352: FILE: tools/virtiofsd/fuse_lowlevel.c:1330:
+^Iif (req->se->op.open)$
ERROR: braces {} are necessary for all arms of this statement
#1352: FILE: tools/virtiofsd/fuse_lowlevel.c:1330:
+ if (req->se->op.open)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1353: FILE: tools/virtiofsd/fuse_lowlevel.c:1331:
+^I^Ireq->se->op.open(req, nodeid, &fi);$
ERROR: code indent should never use tabs
#1354: FILE: tools/virtiofsd/fuse_lowlevel.c:1332:
+^Ielse$
ERROR: code indent should never use tabs
#1355: FILE: tools/virtiofsd/fuse_lowlevel.c:1333:
+^I^Ifuse_reply_open(req, &fi);$
ERROR: code indent should never use tabs
#1360: FILE: tools/virtiofsd/fuse_lowlevel.c:1338:
+^Istruct fuse_read_in *arg = (struct fuse_read_in *) inarg;$
ERROR: code indent should never use tabs
#1362: FILE: tools/virtiofsd/fuse_lowlevel.c:1340:
+^Iif (req->se->op.read) {$
ERROR: code indent should never use tabs
#1363: FILE: tools/virtiofsd/fuse_lowlevel.c:1341:
+^I^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1365: FILE: tools/virtiofsd/fuse_lowlevel.c:1343:
+^I^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1366: FILE: tools/virtiofsd/fuse_lowlevel.c:1344:
+^I^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1367: FILE: tools/virtiofsd/fuse_lowlevel.c:1345:
+^I^Iif (req->se->conn.proto_minor >= 9) {$
ERROR: code indent should never use tabs
#1368: FILE: tools/virtiofsd/fuse_lowlevel.c:1346:
+^I^I^Ifi.lock_owner = arg->lock_owner;$
ERROR: code indent should never use tabs
#1369: FILE: tools/virtiofsd/fuse_lowlevel.c:1347:
+^I^I^Ifi.flags = arg->flags;$
ERROR: code indent should never use tabs
#1370: FILE: tools/virtiofsd/fuse_lowlevel.c:1348:
+^I^I}$
ERROR: code indent should never use tabs
#1371: FILE: tools/virtiofsd/fuse_lowlevel.c:1349:
+^I^Ireq->se->op.read(req, nodeid, arg->size, arg->offset, &fi);$
ERROR: code indent should never use tabs
#1372: FILE: tools/virtiofsd/fuse_lowlevel.c:1350:
+^I} else$
ERROR: code indent should never use tabs
#1373: FILE: tools/virtiofsd/fuse_lowlevel.c:1351:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1378: FILE: tools/virtiofsd/fuse_lowlevel.c:1356:
+^Istruct fuse_write_in *arg = (struct fuse_write_in *) inarg;$
ERROR: code indent should never use tabs
#1379: FILE: tools/virtiofsd/fuse_lowlevel.c:1357:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1380: FILE: tools/virtiofsd/fuse_lowlevel.c:1358:
+^Ichar *param;$
ERROR: code indent should never use tabs
#1382: FILE: tools/virtiofsd/fuse_lowlevel.c:1360:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1383: FILE: tools/virtiofsd/fuse_lowlevel.c:1361:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1384: FILE: tools/virtiofsd/fuse_lowlevel.c:1362:
+^Ifi.writepage = (arg->write_flags & FUSE_WRITE_CACHE) != 0;$
ERROR: code indent should never use tabs
#1386: FILE: tools/virtiofsd/fuse_lowlevel.c:1364:
+^Iif (req->se->conn.proto_minor < 9) {$
ERROR: code indent should never use tabs
#1387: FILE: tools/virtiofsd/fuse_lowlevel.c:1365:
+^I^Iparam = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;$
ERROR: code indent should never use tabs
#1388: FILE: tools/virtiofsd/fuse_lowlevel.c:1366:
+^I} else {$
ERROR: code indent should never use tabs
#1389: FILE: tools/virtiofsd/fuse_lowlevel.c:1367:
+^I^Ifi.lock_owner = arg->lock_owner;$
ERROR: code indent should never use tabs
#1390: FILE: tools/virtiofsd/fuse_lowlevel.c:1368:
+^I^Ifi.flags = arg->flags;$
ERROR: code indent should never use tabs
#1391: FILE: tools/virtiofsd/fuse_lowlevel.c:1369:
+^I^Iparam = PARAM(arg);$
ERROR: code indent should never use tabs
#1392: FILE: tools/virtiofsd/fuse_lowlevel.c:1370:
+^I}$
ERROR: code indent should never use tabs
#1394: FILE: tools/virtiofsd/fuse_lowlevel.c:1372:
+^Iif (req->se->op.write)$
ERROR: code indent should never use tabs
#1395: FILE: tools/virtiofsd/fuse_lowlevel.c:1373:
+^I^Ireq->se->op.write(req, nodeid, param, arg->size,$
ERROR: code indent should never use tabs
#1396: FILE: tools/virtiofsd/fuse_lowlevel.c:1374:
+^I^I^I^I arg->offset, &fi);$
ERROR: code indent should never use tabs
#1397: FILE: tools/virtiofsd/fuse_lowlevel.c:1375:
+^Ielse$
ERROR: code indent should never use tabs
#1398: FILE: tools/virtiofsd/fuse_lowlevel.c:1376:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1402: FILE: tools/virtiofsd/fuse_lowlevel.c:1380:
+^I^I^I const struct fuse_buf *ibuf)$
ERROR: code indent should never use tabs
#1404: FILE: tools/virtiofsd/fuse_lowlevel.c:1382:
+^Istruct fuse_session *se = req->se;$
ERROR: code indent should never use tabs
#1405: FILE: tools/virtiofsd/fuse_lowlevel.c:1383:
+^Istruct fuse_bufvec bufv = {$
ERROR: code indent should never use tabs
#1406: FILE: tools/virtiofsd/fuse_lowlevel.c:1384:
+^I^I.buf[0] = *ibuf,$
ERROR: code indent should never use tabs
#1407: FILE: tools/virtiofsd/fuse_lowlevel.c:1385:
+^I^I.count = 1,$
ERROR: code indent should never use tabs
#1408: FILE: tools/virtiofsd/fuse_lowlevel.c:1386:
+^I};$
ERROR: code indent should never use tabs
#1409: FILE: tools/virtiofsd/fuse_lowlevel.c:1387:
+^Istruct fuse_write_in *arg = (struct fuse_write_in *) inarg;$
ERROR: code indent should never use tabs
#1410: FILE: tools/virtiofsd/fuse_lowlevel.c:1388:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1412: FILE: tools/virtiofsd/fuse_lowlevel.c:1390:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1413: FILE: tools/virtiofsd/fuse_lowlevel.c:1391:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1414: FILE: tools/virtiofsd/fuse_lowlevel.c:1392:
+^Ifi.writepage = arg->write_flags & FUSE_WRITE_CACHE;$
ERROR: code indent should never use tabs
#1416: FILE: tools/virtiofsd/fuse_lowlevel.c:1394:
+^Iif (se->conn.proto_minor < 9) {$
ERROR: code indent should never use tabs
#1417: FILE: tools/virtiofsd/fuse_lowlevel.c:1395:
+^I^Ibufv.buf[0].mem = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;$
ERROR: code indent should never use tabs
#1418: FILE: tools/virtiofsd/fuse_lowlevel.c:1396:
+^I^Ibufv.buf[0].size -= sizeof(struct fuse_in_header) +$
ERROR: code indent should never use tabs
#1419: FILE: tools/virtiofsd/fuse_lowlevel.c:1397:
+^I^I^IFUSE_COMPAT_WRITE_IN_SIZE;$
ERROR: code indent should never use tabs
#1420: FILE: tools/virtiofsd/fuse_lowlevel.c:1398:
+^I^Iassert(!(bufv.buf[0].flags & FUSE_BUF_IS_FD));$
ERROR: code indent should never use tabs
#1421: FILE: tools/virtiofsd/fuse_lowlevel.c:1399:
+^I} else {$
ERROR: code indent should never use tabs
#1422: FILE: tools/virtiofsd/fuse_lowlevel.c:1400:
+^I^Ifi.lock_owner = arg->lock_owner;$
ERROR: code indent should never use tabs
#1423: FILE: tools/virtiofsd/fuse_lowlevel.c:1401:
+^I^Ifi.flags = arg->flags;$
ERROR: code indent should never use tabs
#1424: FILE: tools/virtiofsd/fuse_lowlevel.c:1402:
+^I^Iif (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))$
ERROR: braces {} are necessary for all arms of this statement
#1424: FILE: tools/virtiofsd/fuse_lowlevel.c:1402:
+ if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
[...]
ERROR: code indent should never use tabs
#1425: FILE: tools/virtiofsd/fuse_lowlevel.c:1403:
+^I^I^Ibufv.buf[0].mem = PARAM(arg);$
ERROR: code indent should never use tabs
#1427: FILE: tools/virtiofsd/fuse_lowlevel.c:1405:
+^I^Ibufv.buf[0].size -= sizeof(struct fuse_in_header) +$
ERROR: code indent should never use tabs
#1428: FILE: tools/virtiofsd/fuse_lowlevel.c:1406:
+^I^I^Isizeof(struct fuse_write_in);$
ERROR: code indent should never use tabs
#1429: FILE: tools/virtiofsd/fuse_lowlevel.c:1407:
+^I}$
ERROR: code indent should never use tabs
#1430: FILE: tools/virtiofsd/fuse_lowlevel.c:1408:
+^Iif (bufv.buf[0].size < arg->size) {$
WARNING: line over 80 characters
#1431: FILE: tools/virtiofsd/fuse_lowlevel.c:1409:
+ fuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");
ERROR: code indent should never use tabs
#1431: FILE: tools/virtiofsd/fuse_lowlevel.c:1409:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");$
ERROR: code indent should never use tabs
#1432: FILE: tools/virtiofsd/fuse_lowlevel.c:1410:
+^I^Ifuse_reply_err(req, EIO);$
ERROR: code indent should never use tabs
#1433: FILE: tools/virtiofsd/fuse_lowlevel.c:1411:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1434: FILE: tools/virtiofsd/fuse_lowlevel.c:1412:
+^I}$
ERROR: code indent should never use tabs
#1435: FILE: tools/virtiofsd/fuse_lowlevel.c:1413:
+^Ibufv.buf[0].size = arg->size;$
ERROR: code indent should never use tabs
#1437: FILE: tools/virtiofsd/fuse_lowlevel.c:1415:
+^Ise->op.write_buf(req, nodeid, &bufv, arg->offset, &fi);$
ERROR: code indent should never use tabs
#1440: FILE: tools/virtiofsd/fuse_lowlevel.c:1418:
+^I/* Need to reset the pipe if ->write_buf() didn't consume all data */$
ERROR: code indent should never use tabs
#1441: FILE: tools/virtiofsd/fuse_lowlevel.c:1419:
+^Iif ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)$
ERROR: braces {} are necessary for all arms of this statement
#1441: FILE: tools/virtiofsd/fuse_lowlevel.c:1419:
+ if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
[...]
ERROR: code indent should never use tabs
#1442: FILE: tools/virtiofsd/fuse_lowlevel.c:1420:
+^I^Ifuse_ll_clear_pipe(se);$
ERROR: code indent should never use tabs
#1447: FILE: tools/virtiofsd/fuse_lowlevel.c:1425:
+^Istruct fuse_flush_in *arg = (struct fuse_flush_in *) inarg;$
ERROR: code indent should never use tabs
#1448: FILE: tools/virtiofsd/fuse_lowlevel.c:1426:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1450: FILE: tools/virtiofsd/fuse_lowlevel.c:1428:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1451: FILE: tools/virtiofsd/fuse_lowlevel.c:1429:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1452: FILE: tools/virtiofsd/fuse_lowlevel.c:1430:
+^Ifi.flush = 1;$
ERROR: code indent should never use tabs
#1453: FILE: tools/virtiofsd/fuse_lowlevel.c:1431:
+^Iif (req->se->conn.proto_minor >= 7)$
ERROR: braces {} are necessary for all arms of this statement
#1453: FILE: tools/virtiofsd/fuse_lowlevel.c:1431:
+ if (req->se->conn.proto_minor >= 7)
[...]
ERROR: code indent should never use tabs
#1454: FILE: tools/virtiofsd/fuse_lowlevel.c:1432:
+^I^Ifi.lock_owner = arg->lock_owner;$
ERROR: code indent should never use tabs
#1456: FILE: tools/virtiofsd/fuse_lowlevel.c:1434:
+^Iif (req->se->op.flush)$
ERROR: braces {} are necessary for all arms of this statement
#1456: FILE: tools/virtiofsd/fuse_lowlevel.c:1434:
+ if (req->se->op.flush)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1457: FILE: tools/virtiofsd/fuse_lowlevel.c:1435:
+^I^Ireq->se->op.flush(req, nodeid, &fi);$
ERROR: code indent should never use tabs
#1458: FILE: tools/virtiofsd/fuse_lowlevel.c:1436:
+^Ielse$
ERROR: code indent should never use tabs
#1459: FILE: tools/virtiofsd/fuse_lowlevel.c:1437:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1464: FILE: tools/virtiofsd/fuse_lowlevel.c:1442:
+^Istruct fuse_release_in *arg = (struct fuse_release_in *) inarg;$
ERROR: code indent should never use tabs
#1465: FILE: tools/virtiofsd/fuse_lowlevel.c:1443:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1467: FILE: tools/virtiofsd/fuse_lowlevel.c:1445:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1468: FILE: tools/virtiofsd/fuse_lowlevel.c:1446:
+^Ifi.flags = arg->flags;$
ERROR: code indent should never use tabs
#1469: FILE: tools/virtiofsd/fuse_lowlevel.c:1447:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1470: FILE: tools/virtiofsd/fuse_lowlevel.c:1448:
+^Iif (req->se->conn.proto_minor >= 8) {$
ERROR: code indent should never use tabs
#1471: FILE: tools/virtiofsd/fuse_lowlevel.c:1449:
+^I^Ifi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;$
ERROR: code indent should never use tabs
#1472: FILE: tools/virtiofsd/fuse_lowlevel.c:1450:
+^I^Ifi.lock_owner = arg->lock_owner;$
ERROR: code indent should never use tabs
#1473: FILE: tools/virtiofsd/fuse_lowlevel.c:1451:
+^I}$
ERROR: code indent should never use tabs
#1474: FILE: tools/virtiofsd/fuse_lowlevel.c:1452:
+^Iif (arg->release_flags & FUSE_RELEASE_FLOCK_UNLOCK) {$
ERROR: code indent should never use tabs
#1475: FILE: tools/virtiofsd/fuse_lowlevel.c:1453:
+^I^Ifi.flock_release = 1;$
ERROR: code indent should never use tabs
#1476: FILE: tools/virtiofsd/fuse_lowlevel.c:1454:
+^I^Ifi.lock_owner = arg->lock_owner;$
ERROR: code indent should never use tabs
#1477: FILE: tools/virtiofsd/fuse_lowlevel.c:1455:
+^I}$
ERROR: code indent should never use tabs
#1479: FILE: tools/virtiofsd/fuse_lowlevel.c:1457:
+^Iif (req->se->op.release)$
ERROR: braces {} are necessary for all arms of this statement
#1479: FILE: tools/virtiofsd/fuse_lowlevel.c:1457:
+ if (req->se->op.release)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1480: FILE: tools/virtiofsd/fuse_lowlevel.c:1458:
+^I^Ireq->se->op.release(req, nodeid, &fi);$
ERROR: code indent should never use tabs
#1481: FILE: tools/virtiofsd/fuse_lowlevel.c:1459:
+^Ielse$
ERROR: code indent should never use tabs
#1482: FILE: tools/virtiofsd/fuse_lowlevel.c:1460:
+^I^Ifuse_reply_err(req, 0);$
ERROR: code indent should never use tabs
#1487: FILE: tools/virtiofsd/fuse_lowlevel.c:1465:
+^Istruct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;$
ERROR: code indent should never use tabs
#1488: FILE: tools/virtiofsd/fuse_lowlevel.c:1466:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1489: FILE: tools/virtiofsd/fuse_lowlevel.c:1467:
+^Iint datasync = arg->fsync_flags & 1;$
ERROR: code indent should never use tabs
#1491: FILE: tools/virtiofsd/fuse_lowlevel.c:1469:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1492: FILE: tools/virtiofsd/fuse_lowlevel.c:1470:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1494: FILE: tools/virtiofsd/fuse_lowlevel.c:1472:
+^Iif (req->se->op.fsync)$
ERROR: braces {} are necessary for all arms of this statement
#1494: FILE: tools/virtiofsd/fuse_lowlevel.c:1472:
+ if (req->se->op.fsync)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1495: FILE: tools/virtiofsd/fuse_lowlevel.c:1473:
+^I^Ireq->se->op.fsync(req, nodeid, datasync, &fi);$
ERROR: code indent should never use tabs
#1496: FILE: tools/virtiofsd/fuse_lowlevel.c:1474:
+^Ielse$
ERROR: code indent should never use tabs
#1497: FILE: tools/virtiofsd/fuse_lowlevel.c:1475:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1502: FILE: tools/virtiofsd/fuse_lowlevel.c:1480:
+^Istruct fuse_open_in *arg = (struct fuse_open_in *) inarg;$
ERROR: code indent should never use tabs
#1503: FILE: tools/virtiofsd/fuse_lowlevel.c:1481:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1505: FILE: tools/virtiofsd/fuse_lowlevel.c:1483:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1506: FILE: tools/virtiofsd/fuse_lowlevel.c:1484:
+^Ifi.flags = arg->flags;$
ERROR: code indent should never use tabs
#1508: FILE: tools/virtiofsd/fuse_lowlevel.c:1486:
+^Iif (req->se->op.opendir)$
ERROR: braces {} are necessary for all arms of this statement
#1508: FILE: tools/virtiofsd/fuse_lowlevel.c:1486:
+ if (req->se->op.opendir)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1509: FILE: tools/virtiofsd/fuse_lowlevel.c:1487:
+^I^Ireq->se->op.opendir(req, nodeid, &fi);$
ERROR: code indent should never use tabs
#1510: FILE: tools/virtiofsd/fuse_lowlevel.c:1488:
+^Ielse$
ERROR: code indent should never use tabs
#1511: FILE: tools/virtiofsd/fuse_lowlevel.c:1489:
+^I^Ifuse_reply_open(req, &fi);$
ERROR: code indent should never use tabs
#1516: FILE: tools/virtiofsd/fuse_lowlevel.c:1494:
+^Istruct fuse_read_in *arg = (struct fuse_read_in *) inarg;$
ERROR: code indent should never use tabs
#1517: FILE: tools/virtiofsd/fuse_lowlevel.c:1495:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1519: FILE: tools/virtiofsd/fuse_lowlevel.c:1497:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1520: FILE: tools/virtiofsd/fuse_lowlevel.c:1498:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1522: FILE: tools/virtiofsd/fuse_lowlevel.c:1500:
+^Iif (req->se->op.readdir)$
ERROR: braces {} are necessary for all arms of this statement
#1522: FILE: tools/virtiofsd/fuse_lowlevel.c:1500:
+ if (req->se->op.readdir)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1523: FILE: tools/virtiofsd/fuse_lowlevel.c:1501:
+^I^Ireq->se->op.readdir(req, nodeid, arg->size, arg->offset, &fi);$
ERROR: code indent should never use tabs
#1524: FILE: tools/virtiofsd/fuse_lowlevel.c:1502:
+^Ielse$
ERROR: code indent should never use tabs
#1525: FILE: tools/virtiofsd/fuse_lowlevel.c:1503:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1530: FILE: tools/virtiofsd/fuse_lowlevel.c:1508:
+^Istruct fuse_read_in *arg = (struct fuse_read_in *) inarg;$
ERROR: code indent should never use tabs
#1531: FILE: tools/virtiofsd/fuse_lowlevel.c:1509:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1533: FILE: tools/virtiofsd/fuse_lowlevel.c:1511:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1534: FILE: tools/virtiofsd/fuse_lowlevel.c:1512:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1536: FILE: tools/virtiofsd/fuse_lowlevel.c:1514:
+^Iif (req->se->op.readdirplus)$
ERROR: braces {} are necessary for all arms of this statement
#1536: FILE: tools/virtiofsd/fuse_lowlevel.c:1514:
+ if (req->se->op.readdirplus)
[...]
+ else
[...]
WARNING: line over 80 characters
#1537: FILE: tools/virtiofsd/fuse_lowlevel.c:1515:
+ req->se->op.readdirplus(req, nodeid, arg->size, arg->offset, &fi);
ERROR: code indent should never use tabs
#1537: FILE: tools/virtiofsd/fuse_lowlevel.c:1515:
+^I^Ireq->se->op.readdirplus(req, nodeid, arg->size, arg->offset, &fi);$
ERROR: code indent should never use tabs
#1538: FILE: tools/virtiofsd/fuse_lowlevel.c:1516:
+^Ielse$
ERROR: code indent should never use tabs
#1539: FILE: tools/virtiofsd/fuse_lowlevel.c:1517:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1544: FILE: tools/virtiofsd/fuse_lowlevel.c:1522:
+^Istruct fuse_release_in *arg = (struct fuse_release_in *) inarg;$
ERROR: code indent should never use tabs
#1545: FILE: tools/virtiofsd/fuse_lowlevel.c:1523:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1547: FILE: tools/virtiofsd/fuse_lowlevel.c:1525:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1548: FILE: tools/virtiofsd/fuse_lowlevel.c:1526:
+^Ifi.flags = arg->flags;$
ERROR: code indent should never use tabs
#1549: FILE: tools/virtiofsd/fuse_lowlevel.c:1527:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1551: FILE: tools/virtiofsd/fuse_lowlevel.c:1529:
+^Iif (req->se->op.releasedir)$
ERROR: braces {} are necessary for all arms of this statement
#1551: FILE: tools/virtiofsd/fuse_lowlevel.c:1529:
+ if (req->se->op.releasedir)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1552: FILE: tools/virtiofsd/fuse_lowlevel.c:1530:
+^I^Ireq->se->op.releasedir(req, nodeid, &fi);$
ERROR: code indent should never use tabs
#1553: FILE: tools/virtiofsd/fuse_lowlevel.c:1531:
+^Ielse$
ERROR: code indent should never use tabs
#1554: FILE: tools/virtiofsd/fuse_lowlevel.c:1532:
+^I^Ifuse_reply_err(req, 0);$
ERROR: code indent should never use tabs
#1559: FILE: tools/virtiofsd/fuse_lowlevel.c:1537:
+^Istruct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;$
ERROR: code indent should never use tabs
#1560: FILE: tools/virtiofsd/fuse_lowlevel.c:1538:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1561: FILE: tools/virtiofsd/fuse_lowlevel.c:1539:
+^Iint datasync = arg->fsync_flags & 1;$
ERROR: code indent should never use tabs
#1563: FILE: tools/virtiofsd/fuse_lowlevel.c:1541:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1564: FILE: tools/virtiofsd/fuse_lowlevel.c:1542:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1566: FILE: tools/virtiofsd/fuse_lowlevel.c:1544:
+^Iif (req->se->op.fsyncdir)$
ERROR: braces {} are necessary for all arms of this statement
#1566: FILE: tools/virtiofsd/fuse_lowlevel.c:1544:
+ if (req->se->op.fsyncdir)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1567: FILE: tools/virtiofsd/fuse_lowlevel.c:1545:
+^I^Ireq->se->op.fsyncdir(req, nodeid, datasync, &fi);$
ERROR: code indent should never use tabs
#1568: FILE: tools/virtiofsd/fuse_lowlevel.c:1546:
+^Ielse$
ERROR: code indent should never use tabs
#1569: FILE: tools/virtiofsd/fuse_lowlevel.c:1547:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1574: FILE: tools/virtiofsd/fuse_lowlevel.c:1552:
+^I(void) nodeid;$
ERROR: code indent should never use tabs
#1575: FILE: tools/virtiofsd/fuse_lowlevel.c:1553:
+^I(void) inarg;$
ERROR: code indent should never use tabs
#1577: FILE: tools/virtiofsd/fuse_lowlevel.c:1555:
+^Iif (req->se->op.statfs)$
ERROR: code indent should never use tabs
#1578: FILE: tools/virtiofsd/fuse_lowlevel.c:1556:
+^I^Ireq->se->op.statfs(req, nodeid);$
ERROR: code indent should never use tabs
#1579: FILE: tools/virtiofsd/fuse_lowlevel.c:1557:
+^Ielse {$
ERROR: code indent should never use tabs
#1580: FILE: tools/virtiofsd/fuse_lowlevel.c:1558:
+^I^Istruct statvfs buf = {$
ERROR: code indent should never use tabs
#1581: FILE: tools/virtiofsd/fuse_lowlevel.c:1559:
+^I^I^I.f_namemax = 255,$
ERROR: code indent should never use tabs
#1582: FILE: tools/virtiofsd/fuse_lowlevel.c:1560:
+^I^I^I.f_bsize = 512,$
ERROR: code indent should never use tabs
#1583: FILE: tools/virtiofsd/fuse_lowlevel.c:1561:
+^I^I};$
ERROR: code indent should never use tabs
#1584: FILE: tools/virtiofsd/fuse_lowlevel.c:1562:
+^I^Ifuse_reply_statfs(req, &buf);$
ERROR: code indent should never use tabs
#1585: FILE: tools/virtiofsd/fuse_lowlevel.c:1563:
+^I}$
ERROR: code indent should never use tabs
#1590: FILE: tools/virtiofsd/fuse_lowlevel.c:1568:
+^Istruct fuse_setxattr_in *arg = (struct fuse_setxattr_in *) inarg;$
ERROR: code indent should never use tabs
#1591: FILE: tools/virtiofsd/fuse_lowlevel.c:1569:
+^Ichar *name = PARAM(arg);$
ERROR: code indent should never use tabs
#1592: FILE: tools/virtiofsd/fuse_lowlevel.c:1570:
+^Ichar *value = name + strlen(name) + 1;$
ERROR: code indent should never use tabs
#1594: FILE: tools/virtiofsd/fuse_lowlevel.c:1572:
+^Iif (req->se->op.setxattr)$
ERROR: code indent should never use tabs
#1595: FILE: tools/virtiofsd/fuse_lowlevel.c:1573:
+^I^Ireq->se->op.setxattr(req, nodeid, name, value, arg->size,$
ERROR: code indent should never use tabs
#1596: FILE: tools/virtiofsd/fuse_lowlevel.c:1574:
+^I^I^I^I arg->flags);$
ERROR: code indent should never use tabs
#1597: FILE: tools/virtiofsd/fuse_lowlevel.c:1575:
+^Ielse$
ERROR: code indent should never use tabs
#1598: FILE: tools/virtiofsd/fuse_lowlevel.c:1576:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1603: FILE: tools/virtiofsd/fuse_lowlevel.c:1581:
+^Istruct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;$
ERROR: code indent should never use tabs
#1605: FILE: tools/virtiofsd/fuse_lowlevel.c:1583:
+^Iif (req->se->op.getxattr)$
ERROR: braces {} are necessary for all arms of this statement
#1605: FILE: tools/virtiofsd/fuse_lowlevel.c:1583:
+ if (req->se->op.getxattr)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1606: FILE: tools/virtiofsd/fuse_lowlevel.c:1584:
+^I^Ireq->se->op.getxattr(req, nodeid, PARAM(arg), arg->size);$
ERROR: code indent should never use tabs
#1607: FILE: tools/virtiofsd/fuse_lowlevel.c:1585:
+^Ielse$
ERROR: code indent should never use tabs
#1608: FILE: tools/virtiofsd/fuse_lowlevel.c:1586:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1613: FILE: tools/virtiofsd/fuse_lowlevel.c:1591:
+^Istruct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;$
ERROR: code indent should never use tabs
#1615: FILE: tools/virtiofsd/fuse_lowlevel.c:1593:
+^Iif (req->se->op.listxattr)$
ERROR: braces {} are necessary for all arms of this statement
#1615: FILE: tools/virtiofsd/fuse_lowlevel.c:1593:
+ if (req->se->op.listxattr)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1616: FILE: tools/virtiofsd/fuse_lowlevel.c:1594:
+^I^Ireq->se->op.listxattr(req, nodeid, arg->size);$
ERROR: code indent should never use tabs
#1617: FILE: tools/virtiofsd/fuse_lowlevel.c:1595:
+^Ielse$
ERROR: code indent should never use tabs
#1618: FILE: tools/virtiofsd/fuse_lowlevel.c:1596:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1623: FILE: tools/virtiofsd/fuse_lowlevel.c:1601:
+^Ichar *name = (char *) inarg;$
ERROR: code indent should never use tabs
#1625: FILE: tools/virtiofsd/fuse_lowlevel.c:1603:
+^Iif (req->se->op.removexattr)$
ERROR: braces {} are necessary for all arms of this statement
#1625: FILE: tools/virtiofsd/fuse_lowlevel.c:1603:
+ if (req->se->op.removexattr)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1626: FILE: tools/virtiofsd/fuse_lowlevel.c:1604:
+^I^Ireq->se->op.removexattr(req, nodeid, name);$
ERROR: code indent should never use tabs
#1627: FILE: tools/virtiofsd/fuse_lowlevel.c:1605:
+^Ielse$
ERROR: code indent should never use tabs
#1628: FILE: tools/virtiofsd/fuse_lowlevel.c:1606:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1632: FILE: tools/virtiofsd/fuse_lowlevel.c:1610:
+^I^I^I^I struct flock *flock)$
ERROR: code indent should never use tabs
#1634: FILE: tools/virtiofsd/fuse_lowlevel.c:1612:
+^Imemset(flock, 0, sizeof(struct flock));$
ERROR: code indent should never use tabs
#1635: FILE: tools/virtiofsd/fuse_lowlevel.c:1613:
+^Iflock->l_type = fl->type;$
ERROR: code indent should never use tabs
#1636: FILE: tools/virtiofsd/fuse_lowlevel.c:1614:
+^Iflock->l_whence = SEEK_SET;$
ERROR: code indent should never use tabs
#1637: FILE: tools/virtiofsd/fuse_lowlevel.c:1615:
+^Iflock->l_start = fl->start;$
ERROR: code indent should never use tabs
#1638: FILE: tools/virtiofsd/fuse_lowlevel.c:1616:
+^Iif (fl->end == OFFSET_MAX)$
ERROR: braces {} are necessary for all arms of this statement
#1638: FILE: tools/virtiofsd/fuse_lowlevel.c:1616:
+ if (fl->end == OFFSET_MAX)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1639: FILE: tools/virtiofsd/fuse_lowlevel.c:1617:
+^I^Iflock->l_len = 0;$
ERROR: code indent should never use tabs
#1640: FILE: tools/virtiofsd/fuse_lowlevel.c:1618:
+^Ielse$
ERROR: code indent should never use tabs
#1641: FILE: tools/virtiofsd/fuse_lowlevel.c:1619:
+^I^Iflock->l_len = fl->end - fl->start + 1;$
ERROR: code indent should never use tabs
#1642: FILE: tools/virtiofsd/fuse_lowlevel.c:1620:
+^Iflock->l_pid = fl->pid;$
ERROR: code indent should never use tabs
#1647: FILE: tools/virtiofsd/fuse_lowlevel.c:1625:
+^Istruct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;$
ERROR: code indent should never use tabs
#1648: FILE: tools/virtiofsd/fuse_lowlevel.c:1626:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1649: FILE: tools/virtiofsd/fuse_lowlevel.c:1627:
+^Istruct flock flock;$
ERROR: code indent should never use tabs
#1651: FILE: tools/virtiofsd/fuse_lowlevel.c:1629:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1652: FILE: tools/virtiofsd/fuse_lowlevel.c:1630:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1653: FILE: tools/virtiofsd/fuse_lowlevel.c:1631:
+^Ifi.lock_owner = arg->owner;$
ERROR: code indent should never use tabs
#1655: FILE: tools/virtiofsd/fuse_lowlevel.c:1633:
+^Iconvert_fuse_file_lock(&arg->lk, &flock);$
ERROR: code indent should never use tabs
#1656: FILE: tools/virtiofsd/fuse_lowlevel.c:1634:
+^Iif (req->se->op.getlk)$
ERROR: braces {} are necessary for all arms of this statement
#1656: FILE: tools/virtiofsd/fuse_lowlevel.c:1634:
+ if (req->se->op.getlk)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1657: FILE: tools/virtiofsd/fuse_lowlevel.c:1635:
+^I^Ireq->se->op.getlk(req, nodeid, &fi, &flock);$
ERROR: code indent should never use tabs
#1658: FILE: tools/virtiofsd/fuse_lowlevel.c:1636:
+^Ielse$
ERROR: code indent should never use tabs
#1659: FILE: tools/virtiofsd/fuse_lowlevel.c:1637:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1663: FILE: tools/virtiofsd/fuse_lowlevel.c:1641:
+^I^I^I const void *inarg, int sleep)$
ERROR: code indent should never use tabs
#1665: FILE: tools/virtiofsd/fuse_lowlevel.c:1643:
+^Istruct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;$
ERROR: code indent should never use tabs
#1666: FILE: tools/virtiofsd/fuse_lowlevel.c:1644:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1667: FILE: tools/virtiofsd/fuse_lowlevel.c:1645:
+^Istruct flock flock;$
ERROR: code indent should never use tabs
#1669: FILE: tools/virtiofsd/fuse_lowlevel.c:1647:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1670: FILE: tools/virtiofsd/fuse_lowlevel.c:1648:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1671: FILE: tools/virtiofsd/fuse_lowlevel.c:1649:
+^Ifi.lock_owner = arg->owner;$
ERROR: code indent should never use tabs
#1673: FILE: tools/virtiofsd/fuse_lowlevel.c:1651:
+^Iif (arg->lk_flags & FUSE_LK_FLOCK) {$
ERROR: code indent should never use tabs
#1674: FILE: tools/virtiofsd/fuse_lowlevel.c:1652:
+^I^Iint op = 0;$
ERROR: code indent should never use tabs
#1676: FILE: tools/virtiofsd/fuse_lowlevel.c:1654:
+^I^Iswitch (arg->lk.type) {$
ERROR: code indent should never use tabs
#1677: FILE: tools/virtiofsd/fuse_lowlevel.c:1655:
+^I^Icase F_RDLCK:$
ERROR: code indent should never use tabs
#1678: FILE: tools/virtiofsd/fuse_lowlevel.c:1656:
+^I^I^Iop = LOCK_SH;$
ERROR: code indent should never use tabs
#1679: FILE: tools/virtiofsd/fuse_lowlevel.c:1657:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#1680: FILE: tools/virtiofsd/fuse_lowlevel.c:1658:
+^I^Icase F_WRLCK:$
ERROR: code indent should never use tabs
#1681: FILE: tools/virtiofsd/fuse_lowlevel.c:1659:
+^I^I^Iop = LOCK_EX;$
ERROR: code indent should never use tabs
#1682: FILE: tools/virtiofsd/fuse_lowlevel.c:1660:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#1683: FILE: tools/virtiofsd/fuse_lowlevel.c:1661:
+^I^Icase F_UNLCK:$
ERROR: code indent should never use tabs
#1684: FILE: tools/virtiofsd/fuse_lowlevel.c:1662:
+^I^I^Iop = LOCK_UN;$
ERROR: code indent should never use tabs
#1685: FILE: tools/virtiofsd/fuse_lowlevel.c:1663:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#1686: FILE: tools/virtiofsd/fuse_lowlevel.c:1664:
+^I^I}$
ERROR: code indent should never use tabs
#1687: FILE: tools/virtiofsd/fuse_lowlevel.c:1665:
+^I^Iif (!sleep)$
ERROR: braces {} are necessary for all arms of this statement
#1687: FILE: tools/virtiofsd/fuse_lowlevel.c:1665:
+ if (!sleep)
[...]
ERROR: code indent should never use tabs
#1688: FILE: tools/virtiofsd/fuse_lowlevel.c:1666:
+^I^I^Iop |= LOCK_NB;$
ERROR: code indent should never use tabs
#1690: FILE: tools/virtiofsd/fuse_lowlevel.c:1668:
+^I^Iif (req->se->op.flock)$
ERROR: braces {} are necessary for all arms of this statement
#1690: FILE: tools/virtiofsd/fuse_lowlevel.c:1668:
+ if (req->se->op.flock)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1691: FILE: tools/virtiofsd/fuse_lowlevel.c:1669:
+^I^I^Ireq->se->op.flock(req, nodeid, &fi, op);$
ERROR: code indent should never use tabs
#1692: FILE: tools/virtiofsd/fuse_lowlevel.c:1670:
+^I^Ielse$
ERROR: code indent should never use tabs
#1693: FILE: tools/virtiofsd/fuse_lowlevel.c:1671:
+^I^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1694: FILE: tools/virtiofsd/fuse_lowlevel.c:1672:
+^I} else {$
ERROR: code indent should never use tabs
#1695: FILE: tools/virtiofsd/fuse_lowlevel.c:1673:
+^I^Iconvert_fuse_file_lock(&arg->lk, &flock);$
ERROR: code indent should never use tabs
#1696: FILE: tools/virtiofsd/fuse_lowlevel.c:1674:
+^I^Iif (req->se->op.setlk)$
ERROR: braces {} are necessary for all arms of this statement
#1696: FILE: tools/virtiofsd/fuse_lowlevel.c:1674:
+ if (req->se->op.setlk)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1697: FILE: tools/virtiofsd/fuse_lowlevel.c:1675:
+^I^I^Ireq->se->op.setlk(req, nodeid, &fi, &flock, sleep);$
ERROR: code indent should never use tabs
#1698: FILE: tools/virtiofsd/fuse_lowlevel.c:1676:
+^I^Ielse$
ERROR: code indent should never use tabs
#1699: FILE: tools/virtiofsd/fuse_lowlevel.c:1677:
+^I^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1700: FILE: tools/virtiofsd/fuse_lowlevel.c:1678:
+^I}$
ERROR: code indent should never use tabs
#1705: FILE: tools/virtiofsd/fuse_lowlevel.c:1683:
+^Ido_setlk_common(req, nodeid, inarg, 0);$
ERROR: code indent should never use tabs
#1710: FILE: tools/virtiofsd/fuse_lowlevel.c:1688:
+^Ido_setlk_common(req, nodeid, inarg, 1);$
ERROR: code indent should never use tabs
#1715: FILE: tools/virtiofsd/fuse_lowlevel.c:1693:
+^Istruct fuse_req *curr;$
ERROR: code indent should never use tabs
#1717: FILE: tools/virtiofsd/fuse_lowlevel.c:1695:
+^Ifor (curr = se->list.next; curr != &se->list; curr = curr->next) {$
ERROR: code indent should never use tabs
#1718: FILE: tools/virtiofsd/fuse_lowlevel.c:1696:
+^I^Iif (curr->unique == req->u.i.unique) {$
ERROR: code indent should never use tabs
#1719: FILE: tools/virtiofsd/fuse_lowlevel.c:1697:
+^I^I^Ifuse_interrupt_func_t func;$
ERROR: code indent should never use tabs
#1720: FILE: tools/virtiofsd/fuse_lowlevel.c:1698:
+^I^I^Ivoid *data;$
ERROR: code indent should never use tabs
#1722: FILE: tools/virtiofsd/fuse_lowlevel.c:1700:
+^I^I^Icurr->ctr++;$
ERROR: code indent should never use tabs
#1723: FILE: tools/virtiofsd/fuse_lowlevel.c:1701:
+^I^I^Ipthread_mutex_unlock(&se->lock);$
ERROR: code indent should never use tabs
#1725: FILE: tools/virtiofsd/fuse_lowlevel.c:1703:
+^I^I^I/* Ugh, ugly locking */$
ERROR: code indent should never use tabs
#1726: FILE: tools/virtiofsd/fuse_lowlevel.c:1704:
+^I^I^Ipthread_mutex_lock(&curr->lock);$
ERROR: code indent should never use tabs
#1727: FILE: tools/virtiofsd/fuse_lowlevel.c:1705:
+^I^I^Ipthread_mutex_lock(&se->lock);$
ERROR: code indent should never use tabs
#1728: FILE: tools/virtiofsd/fuse_lowlevel.c:1706:
+^I^I^Icurr->interrupted = 1;$
ERROR: code indent should never use tabs
#1729: FILE: tools/virtiofsd/fuse_lowlevel.c:1707:
+^I^I^Ifunc = curr->u.ni.func;$
ERROR: code indent should never use tabs
#1730: FILE: tools/virtiofsd/fuse_lowlevel.c:1708:
+^I^I^Idata = curr->u.ni.data;$
ERROR: code indent should never use tabs
#1731: FILE: tools/virtiofsd/fuse_lowlevel.c:1709:
+^I^I^Ipthread_mutex_unlock(&se->lock);$
ERROR: code indent should never use tabs
#1732: FILE: tools/virtiofsd/fuse_lowlevel.c:1710:
+^I^I^Iif (func)$
ERROR: braces {} are necessary for all arms of this statement
#1732: FILE: tools/virtiofsd/fuse_lowlevel.c:1710:
+ if (func)
[...]
ERROR: code indent should never use tabs
#1733: FILE: tools/virtiofsd/fuse_lowlevel.c:1711:
+^I^I^I^Ifunc(curr, data);$
ERROR: code indent should never use tabs
#1734: FILE: tools/virtiofsd/fuse_lowlevel.c:1712:
+^I^I^Ipthread_mutex_unlock(&curr->lock);$
ERROR: code indent should never use tabs
#1736: FILE: tools/virtiofsd/fuse_lowlevel.c:1714:
+^I^I^Ipthread_mutex_lock(&se->lock);$
ERROR: code indent should never use tabs
#1737: FILE: tools/virtiofsd/fuse_lowlevel.c:1715:
+^I^I^Icurr->ctr--;$
ERROR: code indent should never use tabs
#1738: FILE: tools/virtiofsd/fuse_lowlevel.c:1716:
+^I^I^Iif (!curr->ctr)$
ERROR: braces {} are necessary for all arms of this statement
#1738: FILE: tools/virtiofsd/fuse_lowlevel.c:1716:
+ if (!curr->ctr)
[...]
ERROR: code indent should never use tabs
#1739: FILE: tools/virtiofsd/fuse_lowlevel.c:1717:
+^I^I^I^Idestroy_req(curr);$
ERROR: code indent should never use tabs
#1741: FILE: tools/virtiofsd/fuse_lowlevel.c:1719:
+^I^I^Ireturn 1;$
ERROR: code indent should never use tabs
#1742: FILE: tools/virtiofsd/fuse_lowlevel.c:1720:
+^I^I}$
ERROR: code indent should never use tabs
#1743: FILE: tools/virtiofsd/fuse_lowlevel.c:1721:
+^I}$
ERROR: code indent should never use tabs
#1744: FILE: tools/virtiofsd/fuse_lowlevel.c:1722:
+^Ifor (curr = se->interrupts.next; curr != &se->interrupts;$
ERROR: code indent should never use tabs
#1745: FILE: tools/virtiofsd/fuse_lowlevel.c:1723:
+^I curr = curr->next) {$
ERROR: code indent should never use tabs
#1746: FILE: tools/virtiofsd/fuse_lowlevel.c:1724:
+^I^Iif (curr->u.i.unique == req->u.i.unique)$
ERROR: braces {} are necessary for all arms of this statement
#1746: FILE: tools/virtiofsd/fuse_lowlevel.c:1724:
+ if (curr->u.i.unique == req->u.i.unique)
[...]
ERROR: code indent should never use tabs
#1747: FILE: tools/virtiofsd/fuse_lowlevel.c:1725:
+^I^I^Ireturn 1;$
ERROR: code indent should never use tabs
#1748: FILE: tools/virtiofsd/fuse_lowlevel.c:1726:
+^I}$
ERROR: code indent should never use tabs
#1749: FILE: tools/virtiofsd/fuse_lowlevel.c:1727:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#1754: FILE: tools/virtiofsd/fuse_lowlevel.c:1732:
+^Istruct fuse_interrupt_in *arg = (struct fuse_interrupt_in *) inarg;$
ERROR: code indent should never use tabs
#1755: FILE: tools/virtiofsd/fuse_lowlevel.c:1733:
+^Istruct fuse_session *se = req->se;$
ERROR: code indent should never use tabs
#1757: FILE: tools/virtiofsd/fuse_lowlevel.c:1735:
+^I(void) nodeid;$
ERROR: code indent should never use tabs
#1758: FILE: tools/virtiofsd/fuse_lowlevel.c:1736:
+^Iif (se->debug)$
ERROR: code indent should never use tabs
#1759: FILE: tools/virtiofsd/fuse_lowlevel.c:1737:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "INTERRUPT: %llu\n",$
ERROR: code indent should never use tabs
#1760: FILE: tools/virtiofsd/fuse_lowlevel.c:1738:
+^I^I^I(unsigned long long) arg->unique);$
ERROR: code indent should never use tabs
#1762: FILE: tools/virtiofsd/fuse_lowlevel.c:1740:
+^Ireq->u.i.unique = arg->unique;$
ERROR: code indent should never use tabs
#1764: FILE: tools/virtiofsd/fuse_lowlevel.c:1742:
+^Ipthread_mutex_lock(&se->lock);$
ERROR: code indent should never use tabs
#1765: FILE: tools/virtiofsd/fuse_lowlevel.c:1743:
+^Iif (find_interrupted(se, req))$
ERROR: braces {} are necessary for all arms of this statement
#1765: FILE: tools/virtiofsd/fuse_lowlevel.c:1743:
+ if (find_interrupted(se, req))
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1766: FILE: tools/virtiofsd/fuse_lowlevel.c:1744:
+^I^Idestroy_req(req);$
ERROR: code indent should never use tabs
#1767: FILE: tools/virtiofsd/fuse_lowlevel.c:1745:
+^Ielse$
ERROR: code indent should never use tabs
#1768: FILE: tools/virtiofsd/fuse_lowlevel.c:1746:
+^I^Ilist_add_req(req, &se->interrupts);$
ERROR: code indent should never use tabs
#1769: FILE: tools/virtiofsd/fuse_lowlevel.c:1747:
+^Ipthread_mutex_unlock(&se->lock);$
ERROR: code indent should never use tabs
#1773: FILE: tools/virtiofsd/fuse_lowlevel.c:1751:
+^I^I^I^I^Istruct fuse_req *req)$
ERROR: code indent should never use tabs
#1775: FILE: tools/virtiofsd/fuse_lowlevel.c:1753:
+^Istruct fuse_req *curr;$
ERROR: code indent should never use tabs
#1777: FILE: tools/virtiofsd/fuse_lowlevel.c:1755:
+^Ifor (curr = se->interrupts.next; curr != &se->interrupts;$
ERROR: code indent should never use tabs
#1778: FILE: tools/virtiofsd/fuse_lowlevel.c:1756:
+^I curr = curr->next) {$
ERROR: code indent should never use tabs
#1779: FILE: tools/virtiofsd/fuse_lowlevel.c:1757:
+^I^Iif (curr->u.i.unique == req->unique) {$
ERROR: code indent should never use tabs
#1780: FILE: tools/virtiofsd/fuse_lowlevel.c:1758:
+^I^I^Ireq->interrupted = 1;$
ERROR: code indent should never use tabs
#1781: FILE: tools/virtiofsd/fuse_lowlevel.c:1759:
+^I^I^Ilist_del_req(curr);$
ERROR: code indent should never use tabs
#1782: FILE: tools/virtiofsd/fuse_lowlevel.c:1760:
+^I^I^Ifree(curr);$
ERROR: code indent should never use tabs
#1783: FILE: tools/virtiofsd/fuse_lowlevel.c:1761:
+^I^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#1784: FILE: tools/virtiofsd/fuse_lowlevel.c:1762:
+^I^I}$
ERROR: code indent should never use tabs
#1785: FILE: tools/virtiofsd/fuse_lowlevel.c:1763:
+^I}$
ERROR: code indent should never use tabs
#1786: FILE: tools/virtiofsd/fuse_lowlevel.c:1764:
+^Icurr = se->interrupts.next;$
ERROR: code indent should never use tabs
#1787: FILE: tools/virtiofsd/fuse_lowlevel.c:1765:
+^Iif (curr != &se->interrupts) {$
ERROR: code indent should never use tabs
#1788: FILE: tools/virtiofsd/fuse_lowlevel.c:1766:
+^I^Ilist_del_req(curr);$
ERROR: code indent should never use tabs
#1789: FILE: tools/virtiofsd/fuse_lowlevel.c:1767:
+^I^Ilist_init_req(curr);$
ERROR: code indent should never use tabs
#1790: FILE: tools/virtiofsd/fuse_lowlevel.c:1768:
+^I^Ireturn curr;$
ERROR: code indent should never use tabs
#1791: FILE: tools/virtiofsd/fuse_lowlevel.c:1769:
+^I} else$
ERROR: code indent should never use tabs
#1792: FILE: tools/virtiofsd/fuse_lowlevel.c:1770:
+^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#1797: FILE: tools/virtiofsd/fuse_lowlevel.c:1775:
+^Istruct fuse_bmap_in *arg = (struct fuse_bmap_in *) inarg;$
ERROR: code indent should never use tabs
#1799: FILE: tools/virtiofsd/fuse_lowlevel.c:1777:
+^Iif (req->se->op.bmap)$
ERROR: braces {} are necessary for all arms of this statement
#1799: FILE: tools/virtiofsd/fuse_lowlevel.c:1777:
+ if (req->se->op.bmap)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1800: FILE: tools/virtiofsd/fuse_lowlevel.c:1778:
+^I^Ireq->se->op.bmap(req, nodeid, arg->blocksize, arg->block);$
ERROR: code indent should never use tabs
#1801: FILE: tools/virtiofsd/fuse_lowlevel.c:1779:
+^Ielse$
ERROR: code indent should never use tabs
#1802: FILE: tools/virtiofsd/fuse_lowlevel.c:1780:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1807: FILE: tools/virtiofsd/fuse_lowlevel.c:1785:
+^Istruct fuse_ioctl_in *arg = (struct fuse_ioctl_in *) inarg;$
ERROR: code indent should never use tabs
#1808: FILE: tools/virtiofsd/fuse_lowlevel.c:1786:
+^Iunsigned int flags = arg->flags;$
ERROR: code indent should never use tabs
#1809: FILE: tools/virtiofsd/fuse_lowlevel.c:1787:
+^Ivoid *in_buf = arg->in_size ? PARAM(arg) : NULL;$
ERROR: code indent should never use tabs
#1810: FILE: tools/virtiofsd/fuse_lowlevel.c:1788:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1812: FILE: tools/virtiofsd/fuse_lowlevel.c:1790:
+^Iif (flags & FUSE_IOCTL_DIR &&$
ERROR: code indent should never use tabs
#1813: FILE: tools/virtiofsd/fuse_lowlevel.c:1791:
+^I !(req->se->conn.want & FUSE_CAP_IOCTL_DIR)) {$
ERROR: code indent should never use tabs
#1814: FILE: tools/virtiofsd/fuse_lowlevel.c:1792:
+^I^Ifuse_reply_err(req, ENOTTY);$
ERROR: code indent should never use tabs
#1815: FILE: tools/virtiofsd/fuse_lowlevel.c:1793:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#1816: FILE: tools/virtiofsd/fuse_lowlevel.c:1794:
+^I}$
ERROR: code indent should never use tabs
#1818: FILE: tools/virtiofsd/fuse_lowlevel.c:1796:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1819: FILE: tools/virtiofsd/fuse_lowlevel.c:1797:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1821: FILE: tools/virtiofsd/fuse_lowlevel.c:1799:
+^Iif (sizeof(void *) == 4 && req->se->conn.proto_minor >= 16 &&$
ERROR: code indent should never use tabs
#1822: FILE: tools/virtiofsd/fuse_lowlevel.c:1800:
+^I !(flags & FUSE_IOCTL_32BIT)) {$
ERROR: code indent should never use tabs
#1823: FILE: tools/virtiofsd/fuse_lowlevel.c:1801:
+^I^Ireq->ioctl_64bit = 1;$
ERROR: code indent should never use tabs
#1824: FILE: tools/virtiofsd/fuse_lowlevel.c:1802:
+^I}$
ERROR: code indent should never use tabs
#1826: FILE: tools/virtiofsd/fuse_lowlevel.c:1804:
+^Iif (req->se->op.ioctl)$
ERROR: code indent should never use tabs
#1827: FILE: tools/virtiofsd/fuse_lowlevel.c:1805:
+^I^Ireq->se->op.ioctl(req, nodeid, arg->cmd,$
ERROR: code indent should never use tabs
#1828: FILE: tools/virtiofsd/fuse_lowlevel.c:1806:
+^I^I^I^I (void *)(uintptr_t)arg->arg, &fi, flags,$
ERROR: code indent should never use tabs
#1829: FILE: tools/virtiofsd/fuse_lowlevel.c:1807:
+^I^I^I^I in_buf, arg->in_size, arg->out_size);$
ERROR: code indent should never use tabs
#1830: FILE: tools/virtiofsd/fuse_lowlevel.c:1808:
+^Ielse$
ERROR: code indent should never use tabs
#1831: FILE: tools/virtiofsd/fuse_lowlevel.c:1809:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1836: FILE: tools/virtiofsd/fuse_lowlevel.c:1814:
+^Ifree(ph);$
ERROR: code indent should never use tabs
#1841: FILE: tools/virtiofsd/fuse_lowlevel.c:1819:
+^Istruct fuse_poll_in *arg = (struct fuse_poll_in *) inarg;$
ERROR: code indent should never use tabs
#1842: FILE: tools/virtiofsd/fuse_lowlevel.c:1820:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1844: FILE: tools/virtiofsd/fuse_lowlevel.c:1822:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1845: FILE: tools/virtiofsd/fuse_lowlevel.c:1823:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1846: FILE: tools/virtiofsd/fuse_lowlevel.c:1824:
+^Ifi.poll_events = arg->events;$
ERROR: code indent should never use tabs
#1848: FILE: tools/virtiofsd/fuse_lowlevel.c:1826:
+^Iif (req->se->op.poll) {$
ERROR: code indent should never use tabs
#1849: FILE: tools/virtiofsd/fuse_lowlevel.c:1827:
+^I^Istruct fuse_pollhandle *ph = NULL;$
ERROR: code indent should never use tabs
#1851: FILE: tools/virtiofsd/fuse_lowlevel.c:1829:
+^I^Iif (arg->flags & FUSE_POLL_SCHEDULE_NOTIFY) {$
ERROR: code indent should never use tabs
#1852: FILE: tools/virtiofsd/fuse_lowlevel.c:1830:
+^I^I^Iph = malloc(sizeof(struct fuse_pollhandle));$
ERROR: code indent should never use tabs
#1853: FILE: tools/virtiofsd/fuse_lowlevel.c:1831:
+^I^I^Iif (ph == NULL) {$
ERROR: code indent should never use tabs
#1854: FILE: tools/virtiofsd/fuse_lowlevel.c:1832:
+^I^I^I^Ifuse_reply_err(req, ENOMEM);$
ERROR: code indent should never use tabs
#1855: FILE: tools/virtiofsd/fuse_lowlevel.c:1833:
+^I^I^I^Ireturn;$
ERROR: code indent should never use tabs
#1856: FILE: tools/virtiofsd/fuse_lowlevel.c:1834:
+^I^I^I}$
ERROR: code indent should never use tabs
#1857: FILE: tools/virtiofsd/fuse_lowlevel.c:1835:
+^I^I^Iph->kh = arg->kh;$
ERROR: code indent should never use tabs
#1858: FILE: tools/virtiofsd/fuse_lowlevel.c:1836:
+^I^I^Iph->se = req->se;$
ERROR: code indent should never use tabs
#1859: FILE: tools/virtiofsd/fuse_lowlevel.c:1837:
+^I^I}$
ERROR: code indent should never use tabs
#1861: FILE: tools/virtiofsd/fuse_lowlevel.c:1839:
+^I^Ireq->se->op.poll(req, nodeid, &fi, ph);$
ERROR: code indent should never use tabs
#1862: FILE: tools/virtiofsd/fuse_lowlevel.c:1840:
+^I} else {$
ERROR: code indent should never use tabs
#1863: FILE: tools/virtiofsd/fuse_lowlevel.c:1841:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1864: FILE: tools/virtiofsd/fuse_lowlevel.c:1842:
+^I}$
ERROR: code indent should never use tabs
#1869: FILE: tools/virtiofsd/fuse_lowlevel.c:1847:
+^Istruct fuse_fallocate_in *arg = (struct fuse_fallocate_in *) inarg;$
ERROR: code indent should never use tabs
#1870: FILE: tools/virtiofsd/fuse_lowlevel.c:1848:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1872: FILE: tools/virtiofsd/fuse_lowlevel.c:1850:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1873: FILE: tools/virtiofsd/fuse_lowlevel.c:1851:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1875: FILE: tools/virtiofsd/fuse_lowlevel.c:1853:
+^Iif (req->se->op.fallocate)$
ERROR: braces {} are necessary for all arms of this statement
#1875: FILE: tools/virtiofsd/fuse_lowlevel.c:1853:
+ if (req->se->op.fallocate)
[...]
+ else
[...]
ERROR: line over 90 characters
#1876: FILE: tools/virtiofsd/fuse_lowlevel.c:1854:
+ req->se->op.fallocate(req, nodeid, arg->mode, arg->offset, arg->length, &fi);
ERROR: code indent should never use tabs
#1876: FILE: tools/virtiofsd/fuse_lowlevel.c:1854:
+^I^Ireq->se->op.fallocate(req, nodeid, arg->mode, arg->offset, arg->length, &fi);$
ERROR: code indent should never use tabs
#1877: FILE: tools/virtiofsd/fuse_lowlevel.c:1855:
+^Ielse$
ERROR: code indent should never use tabs
#1878: FILE: tools/virtiofsd/fuse_lowlevel.c:1856:
+^I^Ifuse_reply_err(req, ENOSYS);$
WARNING: line over 80 characters
#1881: FILE: tools/virtiofsd/fuse_lowlevel.c:1859:
+static void do_copy_file_range(fuse_req_t req, fuse_ino_t nodeid_in, const void *inarg)
WARNING: line over 80 characters
#1883: FILE: tools/virtiofsd/fuse_lowlevel.c:1861:
+ struct fuse_copy_file_range_in *arg = (struct fuse_copy_file_range_in *) inarg;
ERROR: code indent should never use tabs
#1883: FILE: tools/virtiofsd/fuse_lowlevel.c:1861:
+^Istruct fuse_copy_file_range_in *arg = (struct fuse_copy_file_range_in *) inarg;$
ERROR: code indent should never use tabs
#1884: FILE: tools/virtiofsd/fuse_lowlevel.c:1862:
+^Istruct fuse_file_info fi_in, fi_out;$
ERROR: code indent should never use tabs
#1886: FILE: tools/virtiofsd/fuse_lowlevel.c:1864:
+^Imemset(&fi_in, 0, sizeof(fi_in));$
ERROR: code indent should never use tabs
#1887: FILE: tools/virtiofsd/fuse_lowlevel.c:1865:
+^Ifi_in.fh = arg->fh_in;$
ERROR: code indent should never use tabs
#1889: FILE: tools/virtiofsd/fuse_lowlevel.c:1867:
+^Imemset(&fi_out, 0, sizeof(fi_out));$
ERROR: code indent should never use tabs
#1890: FILE: tools/virtiofsd/fuse_lowlevel.c:1868:
+^Ifi_out.fh = arg->fh_out;$
ERROR: code indent should never use tabs
#1893: FILE: tools/virtiofsd/fuse_lowlevel.c:1871:
+^Iif (req->se->op.copy_file_range)$
ERROR: code indent should never use tabs
#1894: FILE: tools/virtiofsd/fuse_lowlevel.c:1872:
+^I^Ireq->se->op.copy_file_range(req, nodeid_in, arg->off_in,$
ERROR: code indent should never use tabs
#1895: FILE: tools/virtiofsd/fuse_lowlevel.c:1873:
+^I^I^I^I^I &fi_in, arg->nodeid_out,$
ERROR: code indent should never use tabs
#1896: FILE: tools/virtiofsd/fuse_lowlevel.c:1874:
+^I^I^I^I^I arg->off_out, &fi_out, arg->len,$
ERROR: code indent should never use tabs
#1897: FILE: tools/virtiofsd/fuse_lowlevel.c:1875:
+^I^I^I^I^I arg->flags);$
ERROR: code indent should never use tabs
#1898: FILE: tools/virtiofsd/fuse_lowlevel.c:1876:
+^Ielse$
ERROR: code indent should never use tabs
#1899: FILE: tools/virtiofsd/fuse_lowlevel.c:1877:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1904: FILE: tools/virtiofsd/fuse_lowlevel.c:1882:
+^Istruct fuse_lseek_in *arg = (struct fuse_lseek_in *) inarg;$
ERROR: code indent should never use tabs
#1905: FILE: tools/virtiofsd/fuse_lowlevel.c:1883:
+^Istruct fuse_file_info fi;$
ERROR: code indent should never use tabs
#1907: FILE: tools/virtiofsd/fuse_lowlevel.c:1885:
+^Imemset(&fi, 0, sizeof(fi));$
ERROR: code indent should never use tabs
#1908: FILE: tools/virtiofsd/fuse_lowlevel.c:1886:
+^Ifi.fh = arg->fh;$
ERROR: code indent should never use tabs
#1910: FILE: tools/virtiofsd/fuse_lowlevel.c:1888:
+^Iif (req->se->op.lseek)$
ERROR: braces {} are necessary for all arms of this statement
#1910: FILE: tools/virtiofsd/fuse_lowlevel.c:1888:
+ if (req->se->op.lseek)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1911: FILE: tools/virtiofsd/fuse_lowlevel.c:1889:
+^I^Ireq->se->op.lseek(req, nodeid, arg->offset, arg->whence, &fi);$
ERROR: code indent should never use tabs
#1912: FILE: tools/virtiofsd/fuse_lowlevel.c:1890:
+^Ielse$
ERROR: code indent should never use tabs
#1913: FILE: tools/virtiofsd/fuse_lowlevel.c:1891:
+^I^Ifuse_reply_err(req, ENOSYS);$
ERROR: code indent should never use tabs
#1918: FILE: tools/virtiofsd/fuse_lowlevel.c:1896:
+^Istruct fuse_init_in *arg = (struct fuse_init_in *) inarg;$
ERROR: code indent should never use tabs
#1919: FILE: tools/virtiofsd/fuse_lowlevel.c:1897:
+^Istruct fuse_init_out outarg;$
ERROR: code indent should never use tabs
#1920: FILE: tools/virtiofsd/fuse_lowlevel.c:1898:
+^Istruct fuse_session *se = req->se;$
ERROR: code indent should never use tabs
#1921: FILE: tools/virtiofsd/fuse_lowlevel.c:1899:
+^Isize_t bufsize = se->bufsize;$
ERROR: code indent should never use tabs
#1922: FILE: tools/virtiofsd/fuse_lowlevel.c:1900:
+^Isize_t outargsize = sizeof(outarg);$
ERROR: code indent should never use tabs
#1924: FILE: tools/virtiofsd/fuse_lowlevel.c:1902:
+^I(void) nodeid;$
ERROR: code indent should never use tabs
#1925: FILE: tools/virtiofsd/fuse_lowlevel.c:1903:
+^Iif (se->debug) {$
WARNING: line over 80 characters
#1926: FILE: tools/virtiofsd/fuse_lowlevel.c:1904:
+ fuse_log(FUSE_LOG_DEBUG, "INIT: %u.%u\n", arg->major, arg->minor);
ERROR: code indent should never use tabs
#1926: FILE: tools/virtiofsd/fuse_lowlevel.c:1904:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "INIT: %u.%u\n", arg->major, arg->minor);$
ERROR: code indent should never use tabs
#1927: FILE: tools/virtiofsd/fuse_lowlevel.c:1905:
+^I^Iif (arg->major == 7 && arg->minor >= 6) {$
ERROR: code indent should never use tabs
#1928: FILE: tools/virtiofsd/fuse_lowlevel.c:1906:
+^I^I^Ifuse_log(FUSE_LOG_DEBUG, "flags=0x%08x\n", arg->flags);$
ERROR: code indent should never use tabs
#1929: FILE: tools/virtiofsd/fuse_lowlevel.c:1907:
+^I^I^Ifuse_log(FUSE_LOG_DEBUG, "max_readahead=0x%08x\n",$
ERROR: code indent should never use tabs
#1930: FILE: tools/virtiofsd/fuse_lowlevel.c:1908:
+^I^I^I^Iarg->max_readahead);$
ERROR: code indent should never use tabs
#1931: FILE: tools/virtiofsd/fuse_lowlevel.c:1909:
+^I^I}$
ERROR: code indent should never use tabs
#1932: FILE: tools/virtiofsd/fuse_lowlevel.c:1910:
+^I}$
ERROR: code indent should never use tabs
#1933: FILE: tools/virtiofsd/fuse_lowlevel.c:1911:
+^Ise->conn.proto_major = arg->major;$
ERROR: code indent should never use tabs
#1934: FILE: tools/virtiofsd/fuse_lowlevel.c:1912:
+^Ise->conn.proto_minor = arg->minor;$
ERROR: code indent should never use tabs
#1935: FILE: tools/virtiofsd/fuse_lowlevel.c:1913:
+^Ise->conn.capable = 0;$
ERROR: code indent should never use tabs
#1936: FILE: tools/virtiofsd/fuse_lowlevel.c:1914:
+^Ise->conn.want = 0;$
ERROR: code indent should never use tabs
#1938: FILE: tools/virtiofsd/fuse_lowlevel.c:1916:
+^Imemset(&outarg, 0, sizeof(outarg));$
ERROR: code indent should never use tabs
#1939: FILE: tools/virtiofsd/fuse_lowlevel.c:1917:
+^Ioutarg.major = FUSE_KERNEL_VERSION;$
ERROR: code indent should never use tabs
#1940: FILE: tools/virtiofsd/fuse_lowlevel.c:1918:
+^Ioutarg.minor = FUSE_KERNEL_MINOR_VERSION;$
ERROR: code indent should never use tabs
#1942: FILE: tools/virtiofsd/fuse_lowlevel.c:1920:
+^Iif (arg->major < 7) {$
WARNING: line over 80 characters
#1943: FILE: tools/virtiofsd/fuse_lowlevel.c:1921:
+ fuse_log(FUSE_LOG_ERR, "fuse: unsupported protocol version: %u.%u\n",
ERROR: code indent should never use tabs
#1943: FILE: tools/virtiofsd/fuse_lowlevel.c:1921:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: unsupported protocol version: %u.%u\n",$
ERROR: code indent should never use tabs
#1944: FILE: tools/virtiofsd/fuse_lowlevel.c:1922:
+^I^I^Iarg->major, arg->minor);$
ERROR: code indent should never use tabs
#1945: FILE: tools/virtiofsd/fuse_lowlevel.c:1923:
+^I^Ifuse_reply_err(req, EPROTO);$
ERROR: code indent should never use tabs
#1946: FILE: tools/virtiofsd/fuse_lowlevel.c:1924:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#1947: FILE: tools/virtiofsd/fuse_lowlevel.c:1925:
+^I}$
ERROR: code indent should never use tabs
#1949: FILE: tools/virtiofsd/fuse_lowlevel.c:1927:
+^Iif (arg->major > 7) {$
ERROR: code indent should never use tabs
#1950: FILE: tools/virtiofsd/fuse_lowlevel.c:1928:
+^I^I/* Wait for a second INIT request with a 7.X version */$
ERROR: code indent should never use tabs
#1951: FILE: tools/virtiofsd/fuse_lowlevel.c:1929:
+^I^Isend_reply_ok(req, &outarg, sizeof(outarg));$
ERROR: code indent should never use tabs
#1952: FILE: tools/virtiofsd/fuse_lowlevel.c:1930:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#1953: FILE: tools/virtiofsd/fuse_lowlevel.c:1931:
+^I}$
ERROR: code indent should never use tabs
#1955: FILE: tools/virtiofsd/fuse_lowlevel.c:1933:
+^Iif (arg->minor >= 6) {$
ERROR: code indent should never use tabs
#1956: FILE: tools/virtiofsd/fuse_lowlevel.c:1934:
+^I^Iif (arg->max_readahead < se->conn.max_readahead)$
ERROR: braces {} are necessary for all arms of this statement
#1956: FILE: tools/virtiofsd/fuse_lowlevel.c:1934:
+ if (arg->max_readahead < se->conn.max_readahead)
[...]
ERROR: code indent should never use tabs
#1957: FILE: tools/virtiofsd/fuse_lowlevel.c:1935:
+^I^I^Ise->conn.max_readahead = arg->max_readahead;$
ERROR: code indent should never use tabs
#1958: FILE: tools/virtiofsd/fuse_lowlevel.c:1936:
+^I^Iif (arg->flags & FUSE_ASYNC_READ)$
ERROR: braces {} are necessary for all arms of this statement
#1958: FILE: tools/virtiofsd/fuse_lowlevel.c:1936:
+ if (arg->flags & FUSE_ASYNC_READ)
[...]
ERROR: code indent should never use tabs
#1959: FILE: tools/virtiofsd/fuse_lowlevel.c:1937:
+^I^I^Ise->conn.capable |= FUSE_CAP_ASYNC_READ;$
ERROR: code indent should never use tabs
#1960: FILE: tools/virtiofsd/fuse_lowlevel.c:1938:
+^I^Iif (arg->flags & FUSE_POSIX_LOCKS)$
ERROR: braces {} are necessary for all arms of this statement
#1960: FILE: tools/virtiofsd/fuse_lowlevel.c:1938:
+ if (arg->flags & FUSE_POSIX_LOCKS)
[...]
ERROR: code indent should never use tabs
#1961: FILE: tools/virtiofsd/fuse_lowlevel.c:1939:
+^I^I^Ise->conn.capable |= FUSE_CAP_POSIX_LOCKS;$
ERROR: code indent should never use tabs
#1962: FILE: tools/virtiofsd/fuse_lowlevel.c:1940:
+^I^Iif (arg->flags & FUSE_ATOMIC_O_TRUNC)$
ERROR: braces {} are necessary for all arms of this statement
#1962: FILE: tools/virtiofsd/fuse_lowlevel.c:1940:
+ if (arg->flags & FUSE_ATOMIC_O_TRUNC)
[...]
ERROR: code indent should never use tabs
#1963: FILE: tools/virtiofsd/fuse_lowlevel.c:1941:
+^I^I^Ise->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;$
ERROR: code indent should never use tabs
#1964: FILE: tools/virtiofsd/fuse_lowlevel.c:1942:
+^I^Iif (arg->flags & FUSE_EXPORT_SUPPORT)$
ERROR: braces {} are necessary for all arms of this statement
#1964: FILE: tools/virtiofsd/fuse_lowlevel.c:1942:
+ if (arg->flags & FUSE_EXPORT_SUPPORT)
[...]
ERROR: code indent should never use tabs
#1965: FILE: tools/virtiofsd/fuse_lowlevel.c:1943:
+^I^I^Ise->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;$
ERROR: code indent should never use tabs
#1966: FILE: tools/virtiofsd/fuse_lowlevel.c:1944:
+^I^Iif (arg->flags & FUSE_DONT_MASK)$
ERROR: braces {} are necessary for all arms of this statement
#1966: FILE: tools/virtiofsd/fuse_lowlevel.c:1944:
+ if (arg->flags & FUSE_DONT_MASK)
[...]
ERROR: code indent should never use tabs
#1967: FILE: tools/virtiofsd/fuse_lowlevel.c:1945:
+^I^I^Ise->conn.capable |= FUSE_CAP_DONT_MASK;$
ERROR: code indent should never use tabs
#1968: FILE: tools/virtiofsd/fuse_lowlevel.c:1946:
+^I^Iif (arg->flags & FUSE_FLOCK_LOCKS)$
ERROR: braces {} are necessary for all arms of this statement
#1968: FILE: tools/virtiofsd/fuse_lowlevel.c:1946:
+ if (arg->flags & FUSE_FLOCK_LOCKS)
[...]
ERROR: code indent should never use tabs
#1969: FILE: tools/virtiofsd/fuse_lowlevel.c:1947:
+^I^I^Ise->conn.capable |= FUSE_CAP_FLOCK_LOCKS;$
ERROR: code indent should never use tabs
#1970: FILE: tools/virtiofsd/fuse_lowlevel.c:1948:
+^I^Iif (arg->flags & FUSE_AUTO_INVAL_DATA)$
ERROR: braces {} are necessary for all arms of this statement
#1970: FILE: tools/virtiofsd/fuse_lowlevel.c:1948:
+ if (arg->flags & FUSE_AUTO_INVAL_DATA)
[...]
ERROR: code indent should never use tabs
#1971: FILE: tools/virtiofsd/fuse_lowlevel.c:1949:
+^I^I^Ise->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;$
ERROR: code indent should never use tabs
#1972: FILE: tools/virtiofsd/fuse_lowlevel.c:1950:
+^I^Iif (arg->flags & FUSE_DO_READDIRPLUS)$
ERROR: braces {} are necessary for all arms of this statement
#1972: FILE: tools/virtiofsd/fuse_lowlevel.c:1950:
+ if (arg->flags & FUSE_DO_READDIRPLUS)
[...]
ERROR: code indent should never use tabs
#1973: FILE: tools/virtiofsd/fuse_lowlevel.c:1951:
+^I^I^Ise->conn.capable |= FUSE_CAP_READDIRPLUS;$
ERROR: code indent should never use tabs
#1974: FILE: tools/virtiofsd/fuse_lowlevel.c:1952:
+^I^Iif (arg->flags & FUSE_READDIRPLUS_AUTO)$
ERROR: braces {} are necessary for all arms of this statement
#1974: FILE: tools/virtiofsd/fuse_lowlevel.c:1952:
+ if (arg->flags & FUSE_READDIRPLUS_AUTO)
[...]
ERROR: code indent should never use tabs
#1975: FILE: tools/virtiofsd/fuse_lowlevel.c:1953:
+^I^I^Ise->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;$
ERROR: code indent should never use tabs
#1976: FILE: tools/virtiofsd/fuse_lowlevel.c:1954:
+^I^Iif (arg->flags & FUSE_ASYNC_DIO)$
ERROR: braces {} are necessary for all arms of this statement
#1976: FILE: tools/virtiofsd/fuse_lowlevel.c:1954:
+ if (arg->flags & FUSE_ASYNC_DIO)
[...]
ERROR: code indent should never use tabs
#1977: FILE: tools/virtiofsd/fuse_lowlevel.c:1955:
+^I^I^Ise->conn.capable |= FUSE_CAP_ASYNC_DIO;$
ERROR: code indent should never use tabs
#1978: FILE: tools/virtiofsd/fuse_lowlevel.c:1956:
+^I^Iif (arg->flags & FUSE_WRITEBACK_CACHE)$
ERROR: braces {} are necessary for all arms of this statement
#1978: FILE: tools/virtiofsd/fuse_lowlevel.c:1956:
+ if (arg->flags & FUSE_WRITEBACK_CACHE)
[...]
ERROR: code indent should never use tabs
#1979: FILE: tools/virtiofsd/fuse_lowlevel.c:1957:
+^I^I^Ise->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;$
ERROR: code indent should never use tabs
#1980: FILE: tools/virtiofsd/fuse_lowlevel.c:1958:
+^I^Iif (arg->flags & FUSE_NO_OPEN_SUPPORT)$
ERROR: braces {} are necessary for all arms of this statement
#1980: FILE: tools/virtiofsd/fuse_lowlevel.c:1958:
+ if (arg->flags & FUSE_NO_OPEN_SUPPORT)
[...]
ERROR: code indent should never use tabs
#1981: FILE: tools/virtiofsd/fuse_lowlevel.c:1959:
+^I^I^Ise->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;$
ERROR: code indent should never use tabs
#1982: FILE: tools/virtiofsd/fuse_lowlevel.c:1960:
+^I^Iif (arg->flags & FUSE_PARALLEL_DIROPS)$
ERROR: braces {} are necessary for all arms of this statement
#1982: FILE: tools/virtiofsd/fuse_lowlevel.c:1960:
+ if (arg->flags & FUSE_PARALLEL_DIROPS)
[...]
ERROR: code indent should never use tabs
#1983: FILE: tools/virtiofsd/fuse_lowlevel.c:1961:
+^I^I^Ise->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;$
ERROR: code indent should never use tabs
#1984: FILE: tools/virtiofsd/fuse_lowlevel.c:1962:
+^I^Iif (arg->flags & FUSE_POSIX_ACL)$
ERROR: braces {} are necessary for all arms of this statement
#1984: FILE: tools/virtiofsd/fuse_lowlevel.c:1962:
+ if (arg->flags & FUSE_POSIX_ACL)
[...]
ERROR: code indent should never use tabs
#1985: FILE: tools/virtiofsd/fuse_lowlevel.c:1963:
+^I^I^Ise->conn.capable |= FUSE_CAP_POSIX_ACL;$
ERROR: code indent should never use tabs
#1986: FILE: tools/virtiofsd/fuse_lowlevel.c:1964:
+^I^Iif (arg->flags & FUSE_HANDLE_KILLPRIV)$
ERROR: braces {} are necessary for all arms of this statement
#1986: FILE: tools/virtiofsd/fuse_lowlevel.c:1964:
+ if (arg->flags & FUSE_HANDLE_KILLPRIV)
[...]
ERROR: code indent should never use tabs
#1987: FILE: tools/virtiofsd/fuse_lowlevel.c:1965:
+^I^I^Ise->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;$
ERROR: code indent should never use tabs
#1988: FILE: tools/virtiofsd/fuse_lowlevel.c:1966:
+^I^Iif (arg->flags & FUSE_NO_OPENDIR_SUPPORT)$
ERROR: braces {} are necessary for all arms of this statement
#1988: FILE: tools/virtiofsd/fuse_lowlevel.c:1966:
+ if (arg->flags & FUSE_NO_OPENDIR_SUPPORT)
[...]
ERROR: code indent should never use tabs
#1989: FILE: tools/virtiofsd/fuse_lowlevel.c:1967:
+^I^I^Ise->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;$
ERROR: code indent should never use tabs
#1990: FILE: tools/virtiofsd/fuse_lowlevel.c:1968:
+^I^Iif (!(arg->flags & FUSE_MAX_PAGES)) {$
ERROR: code indent should never use tabs
#1991: FILE: tools/virtiofsd/fuse_lowlevel.c:1969:
+^I^I^Isize_t max_bufsize =$
ERROR: code indent should never use tabs
#1992: FILE: tools/virtiofsd/fuse_lowlevel.c:1970:
+^I^I^I^IFUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize()$
ERROR: use qemu_real_host_page_size instead of getpagesize()
#1992: FILE: tools/virtiofsd/fuse_lowlevel.c:1970:
+ FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize()
ERROR: code indent should never use tabs
#1993: FILE: tools/virtiofsd/fuse_lowlevel.c:1971:
+^I^I^I^I+ FUSE_BUFFER_HEADER_SIZE;$
ERROR: code indent should never use tabs
#1994: FILE: tools/virtiofsd/fuse_lowlevel.c:1972:
+^I^I^Iif (bufsize > max_bufsize) {$
ERROR: code indent should never use tabs
#1995: FILE: tools/virtiofsd/fuse_lowlevel.c:1973:
+^I^I^I^Ibufsize = max_bufsize;$
ERROR: code indent should never use tabs
#1996: FILE: tools/virtiofsd/fuse_lowlevel.c:1974:
+^I^I^I}$
ERROR: code indent should never use tabs
#1997: FILE: tools/virtiofsd/fuse_lowlevel.c:1975:
+^I^I}$
ERROR: code indent should never use tabs
#1998: FILE: tools/virtiofsd/fuse_lowlevel.c:1976:
+^I} else {$
ERROR: code indent should never use tabs
#1999: FILE: tools/virtiofsd/fuse_lowlevel.c:1977:
+^I^Ise->conn.max_readahead = 0;$
ERROR: code indent should never use tabs
#2000: FILE: tools/virtiofsd/fuse_lowlevel.c:1978:
+^I}$
ERROR: code indent should never use tabs
#2002: FILE: tools/virtiofsd/fuse_lowlevel.c:1980:
+^Iif (se->conn.proto_minor >= 14) {$
WARNING: line over 80 characters
#2005: FILE: tools/virtiofsd/fuse_lowlevel.c:1983:
+ se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
ERROR: code indent should never use tabs
#2005: FILE: tools/virtiofsd/fuse_lowlevel.c:1983:
+^I^Ise->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;$
ERROR: code indent should never use tabs
#2007: FILE: tools/virtiofsd/fuse_lowlevel.c:1985:
+^I^Ise->conn.capable |= FUSE_CAP_SPLICE_READ;$
ERROR: code indent should never use tabs
#2009: FILE: tools/virtiofsd/fuse_lowlevel.c:1987:
+^I}$
ERROR: code indent should never use tabs
#2010: FILE: tools/virtiofsd/fuse_lowlevel.c:1988:
+^Iif (se->conn.proto_minor >= 18)$
ERROR: braces {} are necessary for all arms of this statement
#2010: FILE: tools/virtiofsd/fuse_lowlevel.c:1988:
+ if (se->conn.proto_minor >= 18)
[...]
ERROR: code indent should never use tabs
#2011: FILE: tools/virtiofsd/fuse_lowlevel.c:1989:
+^I^Ise->conn.capable |= FUSE_CAP_IOCTL_DIR;$
ERROR: code indent should never use tabs
#2013: FILE: tools/virtiofsd/fuse_lowlevel.c:1991:
+^I/* Default settings for modern filesystems.$
WARNING: Block comments use a leading /* on a separate line
#2013: FILE: tools/virtiofsd/fuse_lowlevel.c:1991:
+ /* Default settings for modern filesystems.
ERROR: code indent should never use tabs
#2014: FILE: tools/virtiofsd/fuse_lowlevel.c:1992:
+^I *$
ERROR: code indent should never use tabs
#2015: FILE: tools/virtiofsd/fuse_lowlevel.c:1993:
+^I * Most of these capabilities were disabled by default in$
ERROR: code indent should never use tabs
#2016: FILE: tools/virtiofsd/fuse_lowlevel.c:1994:
+^I * libfuse2 for backwards compatibility reasons. In libfuse3,$
ERROR: code indent should never use tabs
#2017: FILE: tools/virtiofsd/fuse_lowlevel.c:1995:
+^I * we can finally enable them by default (as long as they're$
ERROR: code indent should never use tabs
#2018: FILE: tools/virtiofsd/fuse_lowlevel.c:1996:
+^I * supported by the kernel).$
ERROR: code indent should never use tabs
#2019: FILE: tools/virtiofsd/fuse_lowlevel.c:1997:
+^I */$
ERROR: Macros with complex values should be enclosed in parenthesis
#2020: FILE: tools/virtiofsd/fuse_lowlevel.c:1998:
+#define LL_SET_DEFAULT(cond, cap) \
+ if ((cond) && (se->conn.capable & (cap))) \
+ se->conn.want |= (cap)
ERROR: code indent should never use tabs
#2021: FILE: tools/virtiofsd/fuse_lowlevel.c:1999:
+^Iif ((cond) && (se->conn.capable & (cap))) \$
ERROR: code indent should never use tabs
#2022: FILE: tools/virtiofsd/fuse_lowlevel.c:2000:
+^I^Ise->conn.want |= (cap)$
ERROR: code indent should never use tabs
#2023: FILE: tools/virtiofsd/fuse_lowlevel.c:2001:
+^ILL_SET_DEFAULT(1, FUSE_CAP_ASYNC_READ);$
ERROR: code indent should never use tabs
#2024: FILE: tools/virtiofsd/fuse_lowlevel.c:2002:
+^ILL_SET_DEFAULT(1, FUSE_CAP_PARALLEL_DIROPS);$
ERROR: code indent should never use tabs
#2025: FILE: tools/virtiofsd/fuse_lowlevel.c:2003:
+^ILL_SET_DEFAULT(1, FUSE_CAP_AUTO_INVAL_DATA);$
ERROR: code indent should never use tabs
#2026: FILE: tools/virtiofsd/fuse_lowlevel.c:2004:
+^ILL_SET_DEFAULT(1, FUSE_CAP_HANDLE_KILLPRIV);$
ERROR: code indent should never use tabs
#2027: FILE: tools/virtiofsd/fuse_lowlevel.c:2005:
+^ILL_SET_DEFAULT(1, FUSE_CAP_ASYNC_DIO);$
ERROR: code indent should never use tabs
#2028: FILE: tools/virtiofsd/fuse_lowlevel.c:2006:
+^ILL_SET_DEFAULT(1, FUSE_CAP_IOCTL_DIR);$
ERROR: code indent should never use tabs
#2029: FILE: tools/virtiofsd/fuse_lowlevel.c:2007:
+^ILL_SET_DEFAULT(1, FUSE_CAP_ATOMIC_O_TRUNC);$
ERROR: code indent should never use tabs
#2030: FILE: tools/virtiofsd/fuse_lowlevel.c:2008:
+^ILL_SET_DEFAULT(se->op.write_buf, FUSE_CAP_SPLICE_READ);$
ERROR: code indent should never use tabs
#2031: FILE: tools/virtiofsd/fuse_lowlevel.c:2009:
+^ILL_SET_DEFAULT(se->op.getlk && se->op.setlk,$
ERROR: code indent should never use tabs
#2032: FILE: tools/virtiofsd/fuse_lowlevel.c:2010:
+^I^I FUSE_CAP_POSIX_LOCKS);$
ERROR: code indent should never use tabs
#2033: FILE: tools/virtiofsd/fuse_lowlevel.c:2011:
+^ILL_SET_DEFAULT(se->op.flock, FUSE_CAP_FLOCK_LOCKS);$
ERROR: code indent should never use tabs
#2034: FILE: tools/virtiofsd/fuse_lowlevel.c:2012:
+^ILL_SET_DEFAULT(se->op.readdirplus, FUSE_CAP_READDIRPLUS);$
ERROR: code indent should never use tabs
#2035: FILE: tools/virtiofsd/fuse_lowlevel.c:2013:
+^ILL_SET_DEFAULT(se->op.readdirplus && se->op.readdir,$
ERROR: code indent should never use tabs
#2036: FILE: tools/virtiofsd/fuse_lowlevel.c:2014:
+^I^I FUSE_CAP_READDIRPLUS_AUTO);$
ERROR: code indent should never use tabs
#2037: FILE: tools/virtiofsd/fuse_lowlevel.c:2015:
+^Ise->conn.time_gran = 1;$
ERROR: trailing whitespace
#2038: FILE: tools/virtiofsd/fuse_lowlevel.c:2016:
+^I$
ERROR: code indent should never use tabs
#2038: FILE: tools/virtiofsd/fuse_lowlevel.c:2016:
+^I$
ERROR: code indent should never use tabs
#2039: FILE: tools/virtiofsd/fuse_lowlevel.c:2017:
+^Iif (bufsize < FUSE_MIN_READ_BUFFER) {$
WARNING: line over 80 characters
#2040: FILE: tools/virtiofsd/fuse_lowlevel.c:2018:
+ fuse_log(FUSE_LOG_ERR, "fuse: warning: buffer size too small: %zu\n",
ERROR: code indent should never use tabs
#2040: FILE: tools/virtiofsd/fuse_lowlevel.c:2018:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: warning: buffer size too small: %zu\n",$
ERROR: code indent should never use tabs
#2041: FILE: tools/virtiofsd/fuse_lowlevel.c:2019:
+^I^I^Ibufsize);$
ERROR: code indent should never use tabs
#2042: FILE: tools/virtiofsd/fuse_lowlevel.c:2020:
+^I^Ibufsize = FUSE_MIN_READ_BUFFER;$
ERROR: code indent should never use tabs
#2043: FILE: tools/virtiofsd/fuse_lowlevel.c:2021:
+^I}$
ERROR: code indent should never use tabs
#2044: FILE: tools/virtiofsd/fuse_lowlevel.c:2022:
+^Ise->bufsize = bufsize;$
ERROR: code indent should never use tabs
#2046: FILE: tools/virtiofsd/fuse_lowlevel.c:2024:
+^Iif (se->conn.max_write > bufsize - FUSE_BUFFER_HEADER_SIZE)$
ERROR: braces {} are necessary for all arms of this statement
#2046: FILE: tools/virtiofsd/fuse_lowlevel.c:2024:
+ if (se->conn.max_write > bufsize - FUSE_BUFFER_HEADER_SIZE)
[...]
ERROR: code indent should never use tabs
#2047: FILE: tools/virtiofsd/fuse_lowlevel.c:2025:
+^I^Ise->conn.max_write = bufsize - FUSE_BUFFER_HEADER_SIZE;$
ERROR: code indent should never use tabs
#2049: FILE: tools/virtiofsd/fuse_lowlevel.c:2027:
+^Ise->got_init = 1;$
ERROR: code indent should never use tabs
#2050: FILE: tools/virtiofsd/fuse_lowlevel.c:2028:
+^Iif (se->op.init)$
ERROR: braces {} are necessary for all arms of this statement
#2050: FILE: tools/virtiofsd/fuse_lowlevel.c:2028:
+ if (se->op.init)
[...]
ERROR: code indent should never use tabs
#2051: FILE: tools/virtiofsd/fuse_lowlevel.c:2029:
+^I^Ise->op.init(se->userdata, &se->conn);$
ERROR: code indent should never use tabs
#2053: FILE: tools/virtiofsd/fuse_lowlevel.c:2031:
+^Iif (se->conn.want & (~se->conn.capable)) {$
WARNING: line over 80 characters
#2054: FILE: tools/virtiofsd/fuse_lowlevel.c:2032:
+ fuse_log(FUSE_LOG_ERR, "fuse: error: filesystem requested capabilities "
ERROR: code indent should never use tabs
#2054: FILE: tools/virtiofsd/fuse_lowlevel.c:2032:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: error: filesystem requested capabilities "$
ERROR: code indent should never use tabs
#2055: FILE: tools/virtiofsd/fuse_lowlevel.c:2033:
+^I^I^I"0x%x that are not supported by kernel, aborting.\n",$
ERROR: code indent should never use tabs
#2056: FILE: tools/virtiofsd/fuse_lowlevel.c:2034:
+^I^I^Ise->conn.want & (~se->conn.capable));$
ERROR: code indent should never use tabs
#2057: FILE: tools/virtiofsd/fuse_lowlevel.c:2035:
+^I^Ifuse_reply_err(req, EPROTO);$
ERROR: code indent should never use tabs
#2058: FILE: tools/virtiofsd/fuse_lowlevel.c:2036:
+^I^Ise->error = -EPROTO;$
ERROR: code indent should never use tabs
#2059: FILE: tools/virtiofsd/fuse_lowlevel.c:2037:
+^I^Ifuse_session_exit(se);$
ERROR: code indent should never use tabs
#2060: FILE: tools/virtiofsd/fuse_lowlevel.c:2038:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#2061: FILE: tools/virtiofsd/fuse_lowlevel.c:2039:
+^I}$
ERROR: code indent should never use tabs
#2063: FILE: tools/virtiofsd/fuse_lowlevel.c:2041:
+^Iunsigned max_read_mo = get_max_read(se->mo);$
ERROR: code indent should never use tabs
#2064: FILE: tools/virtiofsd/fuse_lowlevel.c:2042:
+^Iif (se->conn.max_read != max_read_mo) {$
WARNING: line over 80 characters
#2065: FILE: tools/virtiofsd/fuse_lowlevel.c:2043:
+ fuse_log(FUSE_LOG_ERR, "fuse: error: init() and fuse_session_new() "
ERROR: code indent should never use tabs
#2065: FILE: tools/virtiofsd/fuse_lowlevel.c:2043:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: error: init() and fuse_session_new() "$
ERROR: code indent should never use tabs
#2066: FILE: tools/virtiofsd/fuse_lowlevel.c:2044:
+^I^I^I"requested different maximum read size (%u vs %u)\n",$
ERROR: code indent should never use tabs
#2067: FILE: tools/virtiofsd/fuse_lowlevel.c:2045:
+^I^I^Ise->conn.max_read, max_read_mo);$
ERROR: code indent should never use tabs
#2068: FILE: tools/virtiofsd/fuse_lowlevel.c:2046:
+^I^Ifuse_reply_err(req, EPROTO);$
ERROR: code indent should never use tabs
#2069: FILE: tools/virtiofsd/fuse_lowlevel.c:2047:
+^I^Ise->error = -EPROTO;$
ERROR: code indent should never use tabs
#2070: FILE: tools/virtiofsd/fuse_lowlevel.c:2048:
+^I^Ifuse_session_exit(se);$
ERROR: code indent should never use tabs
#2071: FILE: tools/virtiofsd/fuse_lowlevel.c:2049:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#2072: FILE: tools/virtiofsd/fuse_lowlevel.c:2050:
+^I}$
ERROR: code indent should never use tabs
#2074: FILE: tools/virtiofsd/fuse_lowlevel.c:2052:
+^Iif (se->conn.max_write < bufsize - FUSE_BUFFER_HEADER_SIZE) {$
ERROR: code indent should never use tabs
#2075: FILE: tools/virtiofsd/fuse_lowlevel.c:2053:
+^I^Ise->bufsize = se->conn.max_write + FUSE_BUFFER_HEADER_SIZE;$
ERROR: code indent should never use tabs
#2076: FILE: tools/virtiofsd/fuse_lowlevel.c:2054:
+^I}$
ERROR: code indent should never use tabs
#2077: FILE: tools/virtiofsd/fuse_lowlevel.c:2055:
+^Iif (arg->flags & FUSE_MAX_PAGES) {$
ERROR: code indent should never use tabs
#2078: FILE: tools/virtiofsd/fuse_lowlevel.c:2056:
+^I^Ioutarg.flags |= FUSE_MAX_PAGES;$
ERROR: code indent should never use tabs
#2079: FILE: tools/virtiofsd/fuse_lowlevel.c:2057:
+^I^Ioutarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;$
ERROR: use qemu_real_host_page_size instead of getpagesize()
#2079: FILE: tools/virtiofsd/fuse_lowlevel.c:2057:
+ outarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;
ERROR: code indent should never use tabs
#2080: FILE: tools/virtiofsd/fuse_lowlevel.c:2058:
+^I}$
ERROR: code indent should never use tabs
#2082: FILE: tools/virtiofsd/fuse_lowlevel.c:2060:
+^I/* Always enable big writes, this is superseded$
WARNING: Block comments use a leading /* on a separate line
#2082: FILE: tools/virtiofsd/fuse_lowlevel.c:2060:
+ /* Always enable big writes, this is superseded
ERROR: code indent should never use tabs
#2083: FILE: tools/virtiofsd/fuse_lowlevel.c:2061:
+^I by the max_write option */$
WARNING: Block comments use * on subsequent lines
#2083: FILE: tools/virtiofsd/fuse_lowlevel.c:2061:
+ /* Always enable big writes, this is superseded
+ by the max_write option */
WARNING: Block comments use a trailing */ on a separate line
#2083: FILE: tools/virtiofsd/fuse_lowlevel.c:2061:
+ by the max_write option */
ERROR: code indent should never use tabs
#2084: FILE: tools/virtiofsd/fuse_lowlevel.c:2062:
+^Ioutarg.flags |= FUSE_BIG_WRITES;$
ERROR: code indent should never use tabs
#2086: FILE: tools/virtiofsd/fuse_lowlevel.c:2064:
+^Iif (se->conn.want & FUSE_CAP_ASYNC_READ)$
ERROR: braces {} are necessary for all arms of this statement
#2086: FILE: tools/virtiofsd/fuse_lowlevel.c:2064:
+ if (se->conn.want & FUSE_CAP_ASYNC_READ)
[...]
ERROR: code indent should never use tabs
#2087: FILE: tools/virtiofsd/fuse_lowlevel.c:2065:
+^I^Ioutarg.flags |= FUSE_ASYNC_READ;$
ERROR: code indent should never use tabs
#2088: FILE: tools/virtiofsd/fuse_lowlevel.c:2066:
+^Iif (se->conn.want & FUSE_CAP_POSIX_LOCKS)$
ERROR: braces {} are necessary for all arms of this statement
#2088: FILE: tools/virtiofsd/fuse_lowlevel.c:2066:
+ if (se->conn.want & FUSE_CAP_POSIX_LOCKS)
[...]
ERROR: code indent should never use tabs
#2089: FILE: tools/virtiofsd/fuse_lowlevel.c:2067:
+^I^Ioutarg.flags |= FUSE_POSIX_LOCKS;$
ERROR: code indent should never use tabs
#2090: FILE: tools/virtiofsd/fuse_lowlevel.c:2068:
+^Iif (se->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)$
ERROR: braces {} are necessary for all arms of this statement
#2090: FILE: tools/virtiofsd/fuse_lowlevel.c:2068:
+ if (se->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)
[...]
ERROR: code indent should never use tabs
#2091: FILE: tools/virtiofsd/fuse_lowlevel.c:2069:
+^I^Ioutarg.flags |= FUSE_ATOMIC_O_TRUNC;$
ERROR: code indent should never use tabs
#2092: FILE: tools/virtiofsd/fuse_lowlevel.c:2070:
+^Iif (se->conn.want & FUSE_CAP_EXPORT_SUPPORT)$
ERROR: braces {} are necessary for all arms of this statement
#2092: FILE: tools/virtiofsd/fuse_lowlevel.c:2070:
+ if (se->conn.want & FUSE_CAP_EXPORT_SUPPORT)
[...]
ERROR: code indent should never use tabs
#2093: FILE: tools/virtiofsd/fuse_lowlevel.c:2071:
+^I^Ioutarg.flags |= FUSE_EXPORT_SUPPORT;$
ERROR: code indent should never use tabs
#2094: FILE: tools/virtiofsd/fuse_lowlevel.c:2072:
+^Iif (se->conn.want & FUSE_CAP_DONT_MASK)$
ERROR: braces {} are necessary for all arms of this statement
#2094: FILE: tools/virtiofsd/fuse_lowlevel.c:2072:
+ if (se->conn.want & FUSE_CAP_DONT_MASK)
[...]
ERROR: code indent should never use tabs
#2095: FILE: tools/virtiofsd/fuse_lowlevel.c:2073:
+^I^Ioutarg.flags |= FUSE_DONT_MASK;$
ERROR: code indent should never use tabs
#2096: FILE: tools/virtiofsd/fuse_lowlevel.c:2074:
+^Iif (se->conn.want & FUSE_CAP_FLOCK_LOCKS)$
ERROR: braces {} are necessary for all arms of this statement
#2096: FILE: tools/virtiofsd/fuse_lowlevel.c:2074:
+ if (se->conn.want & FUSE_CAP_FLOCK_LOCKS)
[...]
ERROR: code indent should never use tabs
#2097: FILE: tools/virtiofsd/fuse_lowlevel.c:2075:
+^I^Ioutarg.flags |= FUSE_FLOCK_LOCKS;$
ERROR: code indent should never use tabs
#2098: FILE: tools/virtiofsd/fuse_lowlevel.c:2076:
+^Iif (se->conn.want & FUSE_CAP_AUTO_INVAL_DATA)$
ERROR: braces {} are necessary for all arms of this statement
#2098: FILE: tools/virtiofsd/fuse_lowlevel.c:2076:
+ if (se->conn.want & FUSE_CAP_AUTO_INVAL_DATA)
[...]
ERROR: code indent should never use tabs
#2099: FILE: tools/virtiofsd/fuse_lowlevel.c:2077:
+^I^Ioutarg.flags |= FUSE_AUTO_INVAL_DATA;$
ERROR: code indent should never use tabs
#2100: FILE: tools/virtiofsd/fuse_lowlevel.c:2078:
+^Iif (se->conn.want & FUSE_CAP_READDIRPLUS)$
ERROR: braces {} are necessary for all arms of this statement
#2100: FILE: tools/virtiofsd/fuse_lowlevel.c:2078:
+ if (se->conn.want & FUSE_CAP_READDIRPLUS)
[...]
ERROR: code indent should never use tabs
#2101: FILE: tools/virtiofsd/fuse_lowlevel.c:2079:
+^I^Ioutarg.flags |= FUSE_DO_READDIRPLUS;$
ERROR: code indent should never use tabs
#2102: FILE: tools/virtiofsd/fuse_lowlevel.c:2080:
+^Iif (se->conn.want & FUSE_CAP_READDIRPLUS_AUTO)$
ERROR: braces {} are necessary for all arms of this statement
#2102: FILE: tools/virtiofsd/fuse_lowlevel.c:2080:
+ if (se->conn.want & FUSE_CAP_READDIRPLUS_AUTO)
[...]
ERROR: code indent should never use tabs
#2103: FILE: tools/virtiofsd/fuse_lowlevel.c:2081:
+^I^Ioutarg.flags |= FUSE_READDIRPLUS_AUTO;$
ERROR: code indent should never use tabs
#2104: FILE: tools/virtiofsd/fuse_lowlevel.c:2082:
+^Iif (se->conn.want & FUSE_CAP_ASYNC_DIO)$
ERROR: braces {} are necessary for all arms of this statement
#2104: FILE: tools/virtiofsd/fuse_lowlevel.c:2082:
+ if (se->conn.want & FUSE_CAP_ASYNC_DIO)
[...]
ERROR: code indent should never use tabs
#2105: FILE: tools/virtiofsd/fuse_lowlevel.c:2083:
+^I^Ioutarg.flags |= FUSE_ASYNC_DIO;$
ERROR: code indent should never use tabs
#2106: FILE: tools/virtiofsd/fuse_lowlevel.c:2084:
+^Iif (se->conn.want & FUSE_CAP_WRITEBACK_CACHE)$
ERROR: braces {} are necessary for all arms of this statement
#2106: FILE: tools/virtiofsd/fuse_lowlevel.c:2084:
+ if (se->conn.want & FUSE_CAP_WRITEBACK_CACHE)
[...]
ERROR: code indent should never use tabs
#2107: FILE: tools/virtiofsd/fuse_lowlevel.c:2085:
+^I^Ioutarg.flags |= FUSE_WRITEBACK_CACHE;$
ERROR: code indent should never use tabs
#2108: FILE: tools/virtiofsd/fuse_lowlevel.c:2086:
+^Iif (se->conn.want & FUSE_CAP_POSIX_ACL)$
ERROR: braces {} are necessary for all arms of this statement
#2108: FILE: tools/virtiofsd/fuse_lowlevel.c:2086:
+ if (se->conn.want & FUSE_CAP_POSIX_ACL)
[...]
ERROR: code indent should never use tabs
#2109: FILE: tools/virtiofsd/fuse_lowlevel.c:2087:
+^I^Ioutarg.flags |= FUSE_POSIX_ACL;$
ERROR: code indent should never use tabs
#2110: FILE: tools/virtiofsd/fuse_lowlevel.c:2088:
+^Ioutarg.max_readahead = se->conn.max_readahead;$
ERROR: code indent should never use tabs
#2111: FILE: tools/virtiofsd/fuse_lowlevel.c:2089:
+^Ioutarg.max_write = se->conn.max_write;$
ERROR: code indent should never use tabs
#2112: FILE: tools/virtiofsd/fuse_lowlevel.c:2090:
+^Iif (se->conn.proto_minor >= 13) {$
ERROR: code indent should never use tabs
#2113: FILE: tools/virtiofsd/fuse_lowlevel.c:2091:
+^I^Iif (se->conn.max_background >= (1 << 16))$
ERROR: braces {} are necessary for all arms of this statement
#2113: FILE: tools/virtiofsd/fuse_lowlevel.c:2091:
+ if (se->conn.max_background >= (1 << 16))
[...]
ERROR: code indent should never use tabs
#2114: FILE: tools/virtiofsd/fuse_lowlevel.c:2092:
+^I^I^Ise->conn.max_background = (1 << 16) - 1;$
ERROR: code indent should never use tabs
#2115: FILE: tools/virtiofsd/fuse_lowlevel.c:2093:
+^I^Iif (se->conn.congestion_threshold > se->conn.max_background)$
ERROR: braces {} are necessary for all arms of this statement
#2115: FILE: tools/virtiofsd/fuse_lowlevel.c:2093:
+ if (se->conn.congestion_threshold > se->conn.max_background)
[...]
ERROR: code indent should never use tabs
#2116: FILE: tools/virtiofsd/fuse_lowlevel.c:2094:
+^I^I^Ise->conn.congestion_threshold = se->conn.max_background;$
ERROR: code indent should never use tabs
#2117: FILE: tools/virtiofsd/fuse_lowlevel.c:2095:
+^I^Iif (!se->conn.congestion_threshold) {$
ERROR: code indent should never use tabs
#2118: FILE: tools/virtiofsd/fuse_lowlevel.c:2096:
+^I^I^Ise->conn.congestion_threshold =$
ERROR: code indent should never use tabs
#2119: FILE: tools/virtiofsd/fuse_lowlevel.c:2097:
+^I^I^I^Ise->conn.max_background * 3 / 4;$
ERROR: code indent should never use tabs
#2120: FILE: tools/virtiofsd/fuse_lowlevel.c:2098:
+^I^I}$
ERROR: code indent should never use tabs
#2122: FILE: tools/virtiofsd/fuse_lowlevel.c:2100:
+^I^Ioutarg.max_background = se->conn.max_background;$
ERROR: code indent should never use tabs
#2123: FILE: tools/virtiofsd/fuse_lowlevel.c:2101:
+^I^Ioutarg.congestion_threshold = se->conn.congestion_threshold;$
ERROR: code indent should never use tabs
#2124: FILE: tools/virtiofsd/fuse_lowlevel.c:2102:
+^I}$
ERROR: code indent should never use tabs
#2125: FILE: tools/virtiofsd/fuse_lowlevel.c:2103:
+^Iif (se->conn.proto_minor >= 23)$
ERROR: braces {} are necessary for all arms of this statement
#2125: FILE: tools/virtiofsd/fuse_lowlevel.c:2103:
+ if (se->conn.proto_minor >= 23)
[...]
ERROR: code indent should never use tabs
#2126: FILE: tools/virtiofsd/fuse_lowlevel.c:2104:
+^I^Ioutarg.time_gran = se->conn.time_gran;$
ERROR: code indent should never use tabs
#2128: FILE: tools/virtiofsd/fuse_lowlevel.c:2106:
+^Iif (se->debug) {$
WARNING: line over 80 characters
#2129: FILE: tools/virtiofsd/fuse_lowlevel.c:2107:
+ fuse_log(FUSE_LOG_DEBUG, " INIT: %u.%u\n", outarg.major, outarg.minor);
ERROR: code indent should never use tabs
#2129: FILE: tools/virtiofsd/fuse_lowlevel.c:2107:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " INIT: %u.%u\n", outarg.major, outarg.minor);$
ERROR: code indent should never use tabs
#2130: FILE: tools/virtiofsd/fuse_lowlevel.c:2108:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " flags=0x%08x\n", outarg.flags);$
ERROR: code indent should never use tabs
#2131: FILE: tools/virtiofsd/fuse_lowlevel.c:2109:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " max_readahead=0x%08x\n",$
ERROR: code indent should never use tabs
#2132: FILE: tools/virtiofsd/fuse_lowlevel.c:2110:
+^I^I^Ioutarg.max_readahead);$
WARNING: line over 80 characters
#2133: FILE: tools/virtiofsd/fuse_lowlevel.c:2111:
+ fuse_log(FUSE_LOG_DEBUG, " max_write=0x%08x\n", outarg.max_write);
ERROR: code indent should never use tabs
#2133: FILE: tools/virtiofsd/fuse_lowlevel.c:2111:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " max_write=0x%08x\n", outarg.max_write);$
ERROR: code indent should never use tabs
#2134: FILE: tools/virtiofsd/fuse_lowlevel.c:2112:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " max_background=%i\n",$
ERROR: code indent should never use tabs
#2135: FILE: tools/virtiofsd/fuse_lowlevel.c:2113:
+^I^I^Ioutarg.max_background);$
ERROR: code indent should never use tabs
#2136: FILE: tools/virtiofsd/fuse_lowlevel.c:2114:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " congestion_threshold=%i\n",$
ERROR: code indent should never use tabs
#2137: FILE: tools/virtiofsd/fuse_lowlevel.c:2115:
+^I^I^Ioutarg.congestion_threshold);$
ERROR: code indent should never use tabs
#2138: FILE: tools/virtiofsd/fuse_lowlevel.c:2116:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " time_gran=%u\n",$
ERROR: code indent should never use tabs
#2139: FILE: tools/virtiofsd/fuse_lowlevel.c:2117:
+^I^I^Ioutarg.time_gran);$
ERROR: code indent should never use tabs
#2140: FILE: tools/virtiofsd/fuse_lowlevel.c:2118:
+^I}$
ERROR: code indent should never use tabs
#2141: FILE: tools/virtiofsd/fuse_lowlevel.c:2119:
+^Iif (arg->minor < 5)$
ERROR: braces {} are necessary for all arms of this statement
#2141: FILE: tools/virtiofsd/fuse_lowlevel.c:2119:
+ if (arg->minor < 5)
[...]
+ else if (arg->minor < 23)
[...]
ERROR: code indent should never use tabs
#2142: FILE: tools/virtiofsd/fuse_lowlevel.c:2120:
+^I^Ioutargsize = FUSE_COMPAT_INIT_OUT_SIZE;$
ERROR: code indent should never use tabs
#2143: FILE: tools/virtiofsd/fuse_lowlevel.c:2121:
+^Ielse if (arg->minor < 23)$
ERROR: braces {} are necessary for all arms of this statement
#2143: FILE: tools/virtiofsd/fuse_lowlevel.c:2121:
+ else if (arg->minor < 23)
[...]
ERROR: code indent should never use tabs
#2144: FILE: tools/virtiofsd/fuse_lowlevel.c:2122:
+^I^Ioutargsize = FUSE_COMPAT_22_INIT_OUT_SIZE;$
ERROR: code indent should never use tabs
#2146: FILE: tools/virtiofsd/fuse_lowlevel.c:2124:
+^Isend_reply_ok(req, &outarg, outargsize);$
ERROR: code indent should never use tabs
#2151: FILE: tools/virtiofsd/fuse_lowlevel.c:2129:
+^Istruct fuse_session *se = req->se;$
ERROR: code indent should never use tabs
#2153: FILE: tools/virtiofsd/fuse_lowlevel.c:2131:
+^I(void) nodeid;$
ERROR: code indent should never use tabs
#2154: FILE: tools/virtiofsd/fuse_lowlevel.c:2132:
+^I(void) inarg;$
ERROR: code indent should never use tabs
#2156: FILE: tools/virtiofsd/fuse_lowlevel.c:2134:
+^Ise->got_destroy = 1;$
ERROR: code indent should never use tabs
#2157: FILE: tools/virtiofsd/fuse_lowlevel.c:2135:
+^Iif (se->op.destroy)$
ERROR: braces {} are necessary for all arms of this statement
#2157: FILE: tools/virtiofsd/fuse_lowlevel.c:2135:
+ if (se->op.destroy)
[...]
ERROR: code indent should never use tabs
#2158: FILE: tools/virtiofsd/fuse_lowlevel.c:2136:
+^I^Ise->op.destroy(se->userdata);$
ERROR: code indent should never use tabs
#2160: FILE: tools/virtiofsd/fuse_lowlevel.c:2138:
+^Isend_reply_ok(req, NULL, 0);$
ERROR: code indent should never use tabs
#2165: FILE: tools/virtiofsd/fuse_lowlevel.c:2143:
+^Istruct fuse_notify_req *prev = nreq->prev;$
ERROR: code indent should never use tabs
#2166: FILE: tools/virtiofsd/fuse_lowlevel.c:2144:
+^Istruct fuse_notify_req *next = nreq->next;$
ERROR: code indent should never use tabs
#2167: FILE: tools/virtiofsd/fuse_lowlevel.c:2145:
+^Iprev->next = next;$
ERROR: code indent should never use tabs
#2168: FILE: tools/virtiofsd/fuse_lowlevel.c:2146:
+^Inext->prev = prev;$
ERROR: code indent should never use tabs
#2172: FILE: tools/virtiofsd/fuse_lowlevel.c:2150:
+^I^I^I struct fuse_notify_req *next)$
ERROR: code indent should never use tabs
#2174: FILE: tools/virtiofsd/fuse_lowlevel.c:2152:
+^Istruct fuse_notify_req *prev = next->prev;$
ERROR: code indent should never use tabs
#2175: FILE: tools/virtiofsd/fuse_lowlevel.c:2153:
+^Inreq->next = next;$
ERROR: code indent should never use tabs
#2176: FILE: tools/virtiofsd/fuse_lowlevel.c:2154:
+^Inreq->prev = prev;$
ERROR: code indent should never use tabs
#2177: FILE: tools/virtiofsd/fuse_lowlevel.c:2155:
+^Iprev->next = nreq;$
ERROR: code indent should never use tabs
#2178: FILE: tools/virtiofsd/fuse_lowlevel.c:2156:
+^Inext->prev = nreq;$
ERROR: code indent should never use tabs
#2183: FILE: tools/virtiofsd/fuse_lowlevel.c:2161:
+^Inreq->next = nreq;$
ERROR: code indent should never use tabs
#2184: FILE: tools/virtiofsd/fuse_lowlevel.c:2162:
+^Inreq->prev = nreq;$
ERROR: code indent should never use tabs
#2188: FILE: tools/virtiofsd/fuse_lowlevel.c:2166:
+^I^I^I const void *inarg, const struct fuse_buf *buf)$
ERROR: code indent should never use tabs
#2190: FILE: tools/virtiofsd/fuse_lowlevel.c:2168:
+^Istruct fuse_session *se = req->se;$
ERROR: code indent should never use tabs
#2191: FILE: tools/virtiofsd/fuse_lowlevel.c:2169:
+^Istruct fuse_notify_req *nreq;$
ERROR: code indent should never use tabs
#2192: FILE: tools/virtiofsd/fuse_lowlevel.c:2170:
+^Istruct fuse_notify_req *head;$
ERROR: code indent should never use tabs
#2194: FILE: tools/virtiofsd/fuse_lowlevel.c:2172:
+^Ipthread_mutex_lock(&se->lock);$
ERROR: code indent should never use tabs
#2195: FILE: tools/virtiofsd/fuse_lowlevel.c:2173:
+^Ihead = &se->notify_list;$
ERROR: code indent should never use tabs
#2196: FILE: tools/virtiofsd/fuse_lowlevel.c:2174:
+^Ifor (nreq = head->next; nreq != head; nreq = nreq->next) {$
ERROR: code indent should never use tabs
#2197: FILE: tools/virtiofsd/fuse_lowlevel.c:2175:
+^I^Iif (nreq->unique == req->unique) {$
ERROR: code indent should never use tabs
#2198: FILE: tools/virtiofsd/fuse_lowlevel.c:2176:
+^I^I^Ilist_del_nreq(nreq);$
ERROR: code indent should never use tabs
#2199: FILE: tools/virtiofsd/fuse_lowlevel.c:2177:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#2200: FILE: tools/virtiofsd/fuse_lowlevel.c:2178:
+^I^I}$
ERROR: code indent should never use tabs
#2201: FILE: tools/virtiofsd/fuse_lowlevel.c:2179:
+^I}$
ERROR: code indent should never use tabs
#2202: FILE: tools/virtiofsd/fuse_lowlevel.c:2180:
+^Ipthread_mutex_unlock(&se->lock);$
ERROR: code indent should never use tabs
#2204: FILE: tools/virtiofsd/fuse_lowlevel.c:2182:
+^Iif (nreq != head)$
ERROR: braces {} are necessary for all arms of this statement
#2204: FILE: tools/virtiofsd/fuse_lowlevel.c:2182:
+ if (nreq != head)
[...]
ERROR: code indent should never use tabs
#2205: FILE: tools/virtiofsd/fuse_lowlevel.c:2183:
+^I^Inreq->reply(nreq, req, nodeid, inarg, buf);$
ERROR: code indent should never use tabs
#2209: FILE: tools/virtiofsd/fuse_lowlevel.c:2187:
+^I^I^I struct iovec *iov, int count)$
ERROR: code indent should never use tabs
#2211: FILE: tools/virtiofsd/fuse_lowlevel.c:2189:
+^Istruct fuse_out_header out;$
ERROR: code indent should never use tabs
#2213: FILE: tools/virtiofsd/fuse_lowlevel.c:2191:
+^Iif (!se->got_init)$
ERROR: braces {} are necessary for all arms of this statement
#2213: FILE: tools/virtiofsd/fuse_lowlevel.c:2191:
+ if (!se->got_init)
[...]
ERROR: code indent should never use tabs
#2214: FILE: tools/virtiofsd/fuse_lowlevel.c:2192:
+^I^Ireturn -ENOTCONN;$
ERROR: code indent should never use tabs
#2216: FILE: tools/virtiofsd/fuse_lowlevel.c:2194:
+^Iout.unique = 0;$
ERROR: code indent should never use tabs
#2217: FILE: tools/virtiofsd/fuse_lowlevel.c:2195:
+^Iout.error = notify_code;$
ERROR: code indent should never use tabs
#2218: FILE: tools/virtiofsd/fuse_lowlevel.c:2196:
+^Iiov[0].iov_base = &out;$
ERROR: code indent should never use tabs
#2219: FILE: tools/virtiofsd/fuse_lowlevel.c:2197:
+^Iiov[0].iov_len = sizeof(struct fuse_out_header);$
ERROR: code indent should never use tabs
#2221: FILE: tools/virtiofsd/fuse_lowlevel.c:2199:
+^Ireturn fuse_send_msg(se, NULL, iov, count);$
ERROR: code indent should never use tabs
#2226: FILE: tools/virtiofsd/fuse_lowlevel.c:2204:
+^Iif (ph != NULL) {$
ERROR: code indent should never use tabs
#2227: FILE: tools/virtiofsd/fuse_lowlevel.c:2205:
+^I^Istruct fuse_notify_poll_wakeup_out outarg;$
ERROR: code indent should never use tabs
#2228: FILE: tools/virtiofsd/fuse_lowlevel.c:2206:
+^I^Istruct iovec iov[2];$
ERROR: code indent should never use tabs
#2230: FILE: tools/virtiofsd/fuse_lowlevel.c:2208:
+^I^Ioutarg.kh = ph->kh;$
ERROR: code indent should never use tabs
#2232: FILE: tools/virtiofsd/fuse_lowlevel.c:2210:
+^I^Iiov[1].iov_base = &outarg;$
ERROR: code indent should never use tabs
#2233: FILE: tools/virtiofsd/fuse_lowlevel.c:2211:
+^I^Iiov[1].iov_len = sizeof(outarg);$
ERROR: code indent should never use tabs
#2235: FILE: tools/virtiofsd/fuse_lowlevel.c:2213:
+^I^Ireturn send_notify_iov(ph->se, FUSE_NOTIFY_POLL, iov, 2);$
ERROR: code indent should never use tabs
#2236: FILE: tools/virtiofsd/fuse_lowlevel.c:2214:
+^I} else {$
ERROR: code indent should never use tabs
#2237: FILE: tools/virtiofsd/fuse_lowlevel.c:2215:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#2238: FILE: tools/virtiofsd/fuse_lowlevel.c:2216:
+^I}$
ERROR: code indent should never use tabs
#2242: FILE: tools/virtiofsd/fuse_lowlevel.c:2220:
+^I^I^I^I off_t off, off_t len)$
ERROR: code indent should never use tabs
#2244: FILE: tools/virtiofsd/fuse_lowlevel.c:2222:
+^Istruct fuse_notify_inval_inode_out outarg;$
ERROR: code indent should never use tabs
#2245: FILE: tools/virtiofsd/fuse_lowlevel.c:2223:
+^Istruct iovec iov[2];$
ERROR: code indent should never use tabs
#2247: FILE: tools/virtiofsd/fuse_lowlevel.c:2225:
+^Iif (!se)$
ERROR: braces {} are necessary for all arms of this statement
#2247: FILE: tools/virtiofsd/fuse_lowlevel.c:2225:
+ if (!se)
[...]
ERROR: code indent should never use tabs
#2248: FILE: tools/virtiofsd/fuse_lowlevel.c:2226:
+^I^Ireturn -EINVAL;$
ERROR: code indent should never use tabs
#2250: FILE: tools/virtiofsd/fuse_lowlevel.c:2228:
+^Iif (se->conn.proto_major < 6 || se->conn.proto_minor < 12)$
ERROR: braces {} are necessary for all arms of this statement
#2250: FILE: tools/virtiofsd/fuse_lowlevel.c:2228:
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
[...]
ERROR: code indent should never use tabs
#2251: FILE: tools/virtiofsd/fuse_lowlevel.c:2229:
+^I^Ireturn -ENOSYS;$
ERROR: trailing whitespace
#2252: FILE: tools/virtiofsd/fuse_lowlevel.c:2230:
+^I$
ERROR: code indent should never use tabs
#2252: FILE: tools/virtiofsd/fuse_lowlevel.c:2230:
+^I$
ERROR: code indent should never use tabs
#2253: FILE: tools/virtiofsd/fuse_lowlevel.c:2231:
+^Ioutarg.ino = ino;$
ERROR: code indent should never use tabs
#2254: FILE: tools/virtiofsd/fuse_lowlevel.c:2232:
+^Ioutarg.off = off;$
ERROR: code indent should never use tabs
#2255: FILE: tools/virtiofsd/fuse_lowlevel.c:2233:
+^Ioutarg.len = len;$
ERROR: code indent should never use tabs
#2257: FILE: tools/virtiofsd/fuse_lowlevel.c:2235:
+^Iiov[1].iov_base = &outarg;$
ERROR: code indent should never use tabs
#2258: FILE: tools/virtiofsd/fuse_lowlevel.c:2236:
+^Iiov[1].iov_len = sizeof(outarg);$
ERROR: code indent should never use tabs
#2260: FILE: tools/virtiofsd/fuse_lowlevel.c:2238:
+^Ireturn send_notify_iov(se, FUSE_NOTIFY_INVAL_INODE, iov, 2);$
ERROR: code indent should never use tabs
#2264: FILE: tools/virtiofsd/fuse_lowlevel.c:2242:
+^I^I^I^I const char *name, size_t namelen)$
ERROR: code indent should never use tabs
#2266: FILE: tools/virtiofsd/fuse_lowlevel.c:2244:
+^Istruct fuse_notify_inval_entry_out outarg;$
ERROR: code indent should never use tabs
#2267: FILE: tools/virtiofsd/fuse_lowlevel.c:2245:
+^Istruct iovec iov[3];$
ERROR: code indent should never use tabs
#2269: FILE: tools/virtiofsd/fuse_lowlevel.c:2247:
+^Iif (!se)$
ERROR: braces {} are necessary for all arms of this statement
#2269: FILE: tools/virtiofsd/fuse_lowlevel.c:2247:
+ if (!se)
[...]
ERROR: code indent should never use tabs
#2270: FILE: tools/virtiofsd/fuse_lowlevel.c:2248:
+^I^Ireturn -EINVAL;$
ERROR: trailing whitespace
#2271: FILE: tools/virtiofsd/fuse_lowlevel.c:2249:
+^I$
ERROR: code indent should never use tabs
#2271: FILE: tools/virtiofsd/fuse_lowlevel.c:2249:
+^I$
ERROR: code indent should never use tabs
#2272: FILE: tools/virtiofsd/fuse_lowlevel.c:2250:
+^Iif (se->conn.proto_major < 6 || se->conn.proto_minor < 12)$
ERROR: braces {} are necessary for all arms of this statement
#2272: FILE: tools/virtiofsd/fuse_lowlevel.c:2250:
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
[...]
ERROR: code indent should never use tabs
#2273: FILE: tools/virtiofsd/fuse_lowlevel.c:2251:
+^I^Ireturn -ENOSYS;$
ERROR: code indent should never use tabs
#2275: FILE: tools/virtiofsd/fuse_lowlevel.c:2253:
+^Ioutarg.parent = parent;$
ERROR: code indent should never use tabs
#2276: FILE: tools/virtiofsd/fuse_lowlevel.c:2254:
+^Ioutarg.namelen = namelen;$
ERROR: code indent should never use tabs
#2277: FILE: tools/virtiofsd/fuse_lowlevel.c:2255:
+^Ioutarg.padding = 0;$
ERROR: code indent should never use tabs
#2279: FILE: tools/virtiofsd/fuse_lowlevel.c:2257:
+^Iiov[1].iov_base = &outarg;$
ERROR: code indent should never use tabs
#2280: FILE: tools/virtiofsd/fuse_lowlevel.c:2258:
+^Iiov[1].iov_len = sizeof(outarg);$
ERROR: code indent should never use tabs
#2281: FILE: tools/virtiofsd/fuse_lowlevel.c:2259:
+^Iiov[2].iov_base = (void *)name;$
ERROR: code indent should never use tabs
#2282: FILE: tools/virtiofsd/fuse_lowlevel.c:2260:
+^Iiov[2].iov_len = namelen + 1;$
ERROR: code indent should never use tabs
#2284: FILE: tools/virtiofsd/fuse_lowlevel.c:2262:
+^Ireturn send_notify_iov(se, FUSE_NOTIFY_INVAL_ENTRY, iov, 3);$
ERROR: code indent should never use tabs
#2288: FILE: tools/virtiofsd/fuse_lowlevel.c:2266:
+^I^I^I^Ifuse_ino_t parent, fuse_ino_t child,$
ERROR: code indent should never use tabs
#2289: FILE: tools/virtiofsd/fuse_lowlevel.c:2267:
+^I^I^I^Iconst char *name, size_t namelen)$
ERROR: code indent should never use tabs
#2291: FILE: tools/virtiofsd/fuse_lowlevel.c:2269:
+^Istruct fuse_notify_delete_out outarg;$
ERROR: code indent should never use tabs
#2292: FILE: tools/virtiofsd/fuse_lowlevel.c:2270:
+^Istruct iovec iov[3];$
ERROR: code indent should never use tabs
#2294: FILE: tools/virtiofsd/fuse_lowlevel.c:2272:
+^Iif (!se)$
ERROR: braces {} are necessary for all arms of this statement
#2294: FILE: tools/virtiofsd/fuse_lowlevel.c:2272:
+ if (!se)
[...]
ERROR: code indent should never use tabs
#2295: FILE: tools/virtiofsd/fuse_lowlevel.c:2273:
+^I^Ireturn -EINVAL;$
ERROR: code indent should never use tabs
#2297: FILE: tools/virtiofsd/fuse_lowlevel.c:2275:
+^Iif (se->conn.proto_major < 6 || se->conn.proto_minor < 18)$
ERROR: braces {} are necessary for all arms of this statement
#2297: FILE: tools/virtiofsd/fuse_lowlevel.c:2275:
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 18)
[...]
ERROR: code indent should never use tabs
#2298: FILE: tools/virtiofsd/fuse_lowlevel.c:2276:
+^I^Ireturn -ENOSYS;$
ERROR: code indent should never use tabs
#2300: FILE: tools/virtiofsd/fuse_lowlevel.c:2278:
+^Ioutarg.parent = parent;$
ERROR: code indent should never use tabs
#2301: FILE: tools/virtiofsd/fuse_lowlevel.c:2279:
+^Ioutarg.child = child;$
ERROR: code indent should never use tabs
#2302: FILE: tools/virtiofsd/fuse_lowlevel.c:2280:
+^Ioutarg.namelen = namelen;$
ERROR: code indent should never use tabs
#2303: FILE: tools/virtiofsd/fuse_lowlevel.c:2281:
+^Ioutarg.padding = 0;$
ERROR: code indent should never use tabs
#2305: FILE: tools/virtiofsd/fuse_lowlevel.c:2283:
+^Iiov[1].iov_base = &outarg;$
ERROR: code indent should never use tabs
#2306: FILE: tools/virtiofsd/fuse_lowlevel.c:2284:
+^Iiov[1].iov_len = sizeof(outarg);$
ERROR: code indent should never use tabs
#2307: FILE: tools/virtiofsd/fuse_lowlevel.c:2285:
+^Iiov[2].iov_base = (void *)name;$
ERROR: code indent should never use tabs
#2308: FILE: tools/virtiofsd/fuse_lowlevel.c:2286:
+^Iiov[2].iov_len = namelen + 1;$
ERROR: code indent should never use tabs
#2310: FILE: tools/virtiofsd/fuse_lowlevel.c:2288:
+^Ireturn send_notify_iov(se, FUSE_NOTIFY_DELETE, iov, 3);$
ERROR: code indent should never use tabs
#2314: FILE: tools/virtiofsd/fuse_lowlevel.c:2292:
+^I^I^I off_t offset, struct fuse_bufvec *bufv,$
ERROR: code indent should never use tabs
#2315: FILE: tools/virtiofsd/fuse_lowlevel.c:2293:
+^I^I^I enum fuse_buf_copy_flags flags)$
ERROR: code indent should never use tabs
#2317: FILE: tools/virtiofsd/fuse_lowlevel.c:2295:
+^Istruct fuse_out_header out;$
ERROR: code indent should never use tabs
#2318: FILE: tools/virtiofsd/fuse_lowlevel.c:2296:
+^Istruct fuse_notify_store_out outarg;$
ERROR: code indent should never use tabs
#2319: FILE: tools/virtiofsd/fuse_lowlevel.c:2297:
+^Istruct iovec iov[3];$
ERROR: code indent should never use tabs
#2320: FILE: tools/virtiofsd/fuse_lowlevel.c:2298:
+^Isize_t size = fuse_buf_size(bufv);$
ERROR: code indent should never use tabs
#2321: FILE: tools/virtiofsd/fuse_lowlevel.c:2299:
+^Iint res;$
ERROR: code indent should never use tabs
#2323: FILE: tools/virtiofsd/fuse_lowlevel.c:2301:
+^Iif (!se)$
ERROR: braces {} are necessary for all arms of this statement
#2323: FILE: tools/virtiofsd/fuse_lowlevel.c:2301:
+ if (!se)
[...]
ERROR: code indent should never use tabs
#2324: FILE: tools/virtiofsd/fuse_lowlevel.c:2302:
+^I^Ireturn -EINVAL;$
ERROR: code indent should never use tabs
#2326: FILE: tools/virtiofsd/fuse_lowlevel.c:2304:
+^Iif (se->conn.proto_major < 6 || se->conn.proto_minor < 15)$
ERROR: braces {} are necessary for all arms of this statement
#2326: FILE: tools/virtiofsd/fuse_lowlevel.c:2304:
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 15)
[...]
ERROR: code indent should never use tabs
#2327: FILE: tools/virtiofsd/fuse_lowlevel.c:2305:
+^I^Ireturn -ENOSYS;$
ERROR: code indent should never use tabs
#2329: FILE: tools/virtiofsd/fuse_lowlevel.c:2307:
+^Iout.unique = 0;$
ERROR: code indent should never use tabs
#2330: FILE: tools/virtiofsd/fuse_lowlevel.c:2308:
+^Iout.error = FUSE_NOTIFY_STORE;$
ERROR: code indent should never use tabs
#2332: FILE: tools/virtiofsd/fuse_lowlevel.c:2310:
+^Ioutarg.nodeid = ino;$
ERROR: code indent should never use tabs
#2333: FILE: tools/virtiofsd/fuse_lowlevel.c:2311:
+^Ioutarg.offset = offset;$
ERROR: code indent should never use tabs
#2334: FILE: tools/virtiofsd/fuse_lowlevel.c:2312:
+^Ioutarg.size = size;$
ERROR: code indent should never use tabs
#2335: FILE: tools/virtiofsd/fuse_lowlevel.c:2313:
+^Ioutarg.padding = 0;$
ERROR: code indent should never use tabs
#2337: FILE: tools/virtiofsd/fuse_lowlevel.c:2315:
+^Iiov[0].iov_base = &out;$
ERROR: code indent should never use tabs
#2338: FILE: tools/virtiofsd/fuse_lowlevel.c:2316:
+^Iiov[0].iov_len = sizeof(out);$
ERROR: code indent should never use tabs
#2339: FILE: tools/virtiofsd/fuse_lowlevel.c:2317:
+^Iiov[1].iov_base = &outarg;$
ERROR: code indent should never use tabs
#2340: FILE: tools/virtiofsd/fuse_lowlevel.c:2318:
+^Iiov[1].iov_len = sizeof(outarg);$
ERROR: code indent should never use tabs
#2342: FILE: tools/virtiofsd/fuse_lowlevel.c:2320:
+^Ires = fuse_send_data_iov(se, NULL, iov, 2, bufv, flags);$
ERROR: code indent should never use tabs
#2343: FILE: tools/virtiofsd/fuse_lowlevel.c:2321:
+^Iif (res > 0)$
ERROR: braces {} are necessary for all arms of this statement
#2343: FILE: tools/virtiofsd/fuse_lowlevel.c:2321:
+ if (res > 0)
[...]
ERROR: code indent should never use tabs
#2344: FILE: tools/virtiofsd/fuse_lowlevel.c:2322:
+^I^Ires = -res;$
ERROR: code indent should never use tabs
#2346: FILE: tools/virtiofsd/fuse_lowlevel.c:2324:
+^Ireturn res;$
ERROR: code indent should never use tabs
#2350: FILE: tools/virtiofsd/fuse_lowlevel.c:2328:
+^Istruct fuse_notify_req nreq;$
ERROR: code indent should never use tabs
#2351: FILE: tools/virtiofsd/fuse_lowlevel.c:2329:
+^Ivoid *cookie;$
ERROR: code indent should never use tabs
#2355: FILE: tools/virtiofsd/fuse_lowlevel.c:2333:
+^I^I^I^I fuse_req_t req, fuse_ino_t ino,$
ERROR: code indent should never use tabs
#2356: FILE: tools/virtiofsd/fuse_lowlevel.c:2334:
+^I^I^I^I const void *inarg,$
ERROR: code indent should never use tabs
#2357: FILE: tools/virtiofsd/fuse_lowlevel.c:2335:
+^I^I^I^I const struct fuse_buf *ibuf)$
ERROR: code indent should never use tabs
#2359: FILE: tools/virtiofsd/fuse_lowlevel.c:2337:
+^Istruct fuse_session *se = req->se;$
ERROR: code indent should never use tabs
#2360: FILE: tools/virtiofsd/fuse_lowlevel.c:2338:
+^Istruct fuse_retrieve_req *rreq =$
ERROR: code indent should never use tabs
#2361: FILE: tools/virtiofsd/fuse_lowlevel.c:2339:
+^I^Icontainer_of(nreq, struct fuse_retrieve_req, nreq);$
ERROR: code indent should never use tabs
#2362: FILE: tools/virtiofsd/fuse_lowlevel.c:2340:
+^Iconst struct fuse_notify_retrieve_in *arg = inarg;$
ERROR: code indent should never use tabs
#2363: FILE: tools/virtiofsd/fuse_lowlevel.c:2341:
+^Istruct fuse_bufvec bufv = {$
ERROR: code indent should never use tabs
#2364: FILE: tools/virtiofsd/fuse_lowlevel.c:2342:
+^I^I.buf[0] = *ibuf,$
ERROR: code indent should never use tabs
#2365: FILE: tools/virtiofsd/fuse_lowlevel.c:2343:
+^I^I.count = 1,$
ERROR: code indent should never use tabs
#2366: FILE: tools/virtiofsd/fuse_lowlevel.c:2344:
+^I};$
ERROR: code indent should never use tabs
#2368: FILE: tools/virtiofsd/fuse_lowlevel.c:2346:
+^Iif (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))$
ERROR: braces {} are necessary for all arms of this statement
#2368: FILE: tools/virtiofsd/fuse_lowlevel.c:2346:
+ if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
[...]
ERROR: code indent should never use tabs
#2369: FILE: tools/virtiofsd/fuse_lowlevel.c:2347:
+^I^Ibufv.buf[0].mem = PARAM(arg);$
ERROR: code indent should never use tabs
#2371: FILE: tools/virtiofsd/fuse_lowlevel.c:2349:
+^Ibufv.buf[0].size -= sizeof(struct fuse_in_header) +$
ERROR: code indent should never use tabs
#2372: FILE: tools/virtiofsd/fuse_lowlevel.c:2350:
+^I^Isizeof(struct fuse_notify_retrieve_in);$
ERROR: code indent should never use tabs
#2374: FILE: tools/virtiofsd/fuse_lowlevel.c:2352:
+^Iif (bufv.buf[0].size < arg->size) {$
WARNING: line over 80 characters
#2375: FILE: tools/virtiofsd/fuse_lowlevel.c:2353:
+ fuse_log(FUSE_LOG_ERR, "fuse: retrieve reply: buffer size too small\n");
ERROR: code indent should never use tabs
#2375: FILE: tools/virtiofsd/fuse_lowlevel.c:2353:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: retrieve reply: buffer size too small\n");$
ERROR: code indent should never use tabs
#2376: FILE: tools/virtiofsd/fuse_lowlevel.c:2354:
+^I^Ifuse_reply_none(req);$
ERROR: code indent should never use tabs
#2377: FILE: tools/virtiofsd/fuse_lowlevel.c:2355:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#2378: FILE: tools/virtiofsd/fuse_lowlevel.c:2356:
+^I}$
ERROR: code indent should never use tabs
#2379: FILE: tools/virtiofsd/fuse_lowlevel.c:2357:
+^Ibufv.buf[0].size = arg->size;$
ERROR: code indent should never use tabs
#2381: FILE: tools/virtiofsd/fuse_lowlevel.c:2359:
+^Iif (se->op.retrieve_reply) {$
ERROR: code indent should never use tabs
#2382: FILE: tools/virtiofsd/fuse_lowlevel.c:2360:
+^I^Ise->op.retrieve_reply(req, rreq->cookie, ino,$
ERROR: code indent should never use tabs
#2383: FILE: tools/virtiofsd/fuse_lowlevel.c:2361:
+^I^I^I^I^I arg->offset, &bufv);$
ERROR: code indent should never use tabs
#2384: FILE: tools/virtiofsd/fuse_lowlevel.c:2362:
+^I} else {$
ERROR: code indent should never use tabs
#2385: FILE: tools/virtiofsd/fuse_lowlevel.c:2363:
+^I^Ifuse_reply_none(req);$
ERROR: code indent should never use tabs
#2386: FILE: tools/virtiofsd/fuse_lowlevel.c:2364:
+^I}$
ERROR: code indent should never use tabs
#2388: FILE: tools/virtiofsd/fuse_lowlevel.c:2366:
+^Ifree(rreq);$
ERROR: code indent should never use tabs
#2389: FILE: tools/virtiofsd/fuse_lowlevel.c:2367:
+^Iif ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)$
ERROR: braces {} are necessary for all arms of this statement
#2389: FILE: tools/virtiofsd/fuse_lowlevel.c:2367:
+ if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
[...]
ERROR: code indent should never use tabs
#2390: FILE: tools/virtiofsd/fuse_lowlevel.c:2368:
+^I^Ifuse_ll_clear_pipe(se);$
ERROR: code indent should never use tabs
#2394: FILE: tools/virtiofsd/fuse_lowlevel.c:2372:
+^I^I^I^I size_t size, off_t offset, void *cookie)$
ERROR: code indent should never use tabs
#2396: FILE: tools/virtiofsd/fuse_lowlevel.c:2374:
+^Istruct fuse_notify_retrieve_out outarg;$
ERROR: code indent should never use tabs
#2397: FILE: tools/virtiofsd/fuse_lowlevel.c:2375:
+^Istruct iovec iov[2];$
ERROR: code indent should never use tabs
#2398: FILE: tools/virtiofsd/fuse_lowlevel.c:2376:
+^Istruct fuse_retrieve_req *rreq;$
ERROR: code indent should never use tabs
#2399: FILE: tools/virtiofsd/fuse_lowlevel.c:2377:
+^Iint err;$
ERROR: code indent should never use tabs
#2401: FILE: tools/virtiofsd/fuse_lowlevel.c:2379:
+^Iif (!se)$
ERROR: braces {} are necessary for all arms of this statement
#2401: FILE: tools/virtiofsd/fuse_lowlevel.c:2379:
+ if (!se)
[...]
ERROR: code indent should never use tabs
#2402: FILE: tools/virtiofsd/fuse_lowlevel.c:2380:
+^I^Ireturn -EINVAL;$
ERROR: code indent should never use tabs
#2404: FILE: tools/virtiofsd/fuse_lowlevel.c:2382:
+^Iif (se->conn.proto_major < 6 || se->conn.proto_minor < 15)$
ERROR: braces {} are necessary for all arms of this statement
#2404: FILE: tools/virtiofsd/fuse_lowlevel.c:2382:
+ if (se->conn.proto_major < 6 || se->conn.proto_minor < 15)
[...]
ERROR: code indent should never use tabs
#2405: FILE: tools/virtiofsd/fuse_lowlevel.c:2383:
+^I^Ireturn -ENOSYS;$
ERROR: code indent should never use tabs
#2407: FILE: tools/virtiofsd/fuse_lowlevel.c:2385:
+^Irreq = malloc(sizeof(*rreq));$
ERROR: code indent should never use tabs
#2408: FILE: tools/virtiofsd/fuse_lowlevel.c:2386:
+^Iif (rreq == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#2408: FILE: tools/virtiofsd/fuse_lowlevel.c:2386:
+ if (rreq == NULL)
[...]
ERROR: code indent should never use tabs
#2409: FILE: tools/virtiofsd/fuse_lowlevel.c:2387:
+^I^Ireturn -ENOMEM;$
ERROR: code indent should never use tabs
#2411: FILE: tools/virtiofsd/fuse_lowlevel.c:2389:
+^Ipthread_mutex_lock(&se->lock);$
ERROR: code indent should never use tabs
#2412: FILE: tools/virtiofsd/fuse_lowlevel.c:2390:
+^Irreq->cookie = cookie;$
ERROR: code indent should never use tabs
#2413: FILE: tools/virtiofsd/fuse_lowlevel.c:2391:
+^Irreq->nreq.unique = se->notify_ctr++;$
ERROR: code indent should never use tabs
#2414: FILE: tools/virtiofsd/fuse_lowlevel.c:2392:
+^Irreq->nreq.reply = fuse_ll_retrieve_reply;$
ERROR: code indent should never use tabs
#2415: FILE: tools/virtiofsd/fuse_lowlevel.c:2393:
+^Ilist_add_nreq(&rreq->nreq, &se->notify_list);$
ERROR: code indent should never use tabs
#2416: FILE: tools/virtiofsd/fuse_lowlevel.c:2394:
+^Ipthread_mutex_unlock(&se->lock);$
ERROR: code indent should never use tabs
#2418: FILE: tools/virtiofsd/fuse_lowlevel.c:2396:
+^Ioutarg.notify_unique = rreq->nreq.unique;$
ERROR: code indent should never use tabs
#2419: FILE: tools/virtiofsd/fuse_lowlevel.c:2397:
+^Ioutarg.nodeid = ino;$
ERROR: code indent should never use tabs
#2420: FILE: tools/virtiofsd/fuse_lowlevel.c:2398:
+^Ioutarg.offset = offset;$
ERROR: code indent should never use tabs
#2421: FILE: tools/virtiofsd/fuse_lowlevel.c:2399:
+^Ioutarg.size = size;$
ERROR: code indent should never use tabs
#2422: FILE: tools/virtiofsd/fuse_lowlevel.c:2400:
+^Ioutarg.padding = 0;$
ERROR: code indent should never use tabs
#2424: FILE: tools/virtiofsd/fuse_lowlevel.c:2402:
+^Iiov[1].iov_base = &outarg;$
ERROR: code indent should never use tabs
#2425: FILE: tools/virtiofsd/fuse_lowlevel.c:2403:
+^Iiov[1].iov_len = sizeof(outarg);$
ERROR: code indent should never use tabs
#2427: FILE: tools/virtiofsd/fuse_lowlevel.c:2405:
+^Ierr = send_notify_iov(se, FUSE_NOTIFY_RETRIEVE, iov, 2);$
ERROR: code indent should never use tabs
#2428: FILE: tools/virtiofsd/fuse_lowlevel.c:2406:
+^Iif (err) {$
ERROR: code indent should never use tabs
#2429: FILE: tools/virtiofsd/fuse_lowlevel.c:2407:
+^I^Ipthread_mutex_lock(&se->lock);$
ERROR: code indent should never use tabs
#2430: FILE: tools/virtiofsd/fuse_lowlevel.c:2408:
+^I^Ilist_del_nreq(&rreq->nreq);$
ERROR: code indent should never use tabs
#2431: FILE: tools/virtiofsd/fuse_lowlevel.c:2409:
+^I^Ipthread_mutex_unlock(&se->lock);$
ERROR: code indent should never use tabs
#2432: FILE: tools/virtiofsd/fuse_lowlevel.c:2410:
+^I^Ifree(rreq);$
ERROR: code indent should never use tabs
#2433: FILE: tools/virtiofsd/fuse_lowlevel.c:2411:
+^I}$
ERROR: code indent should never use tabs
#2435: FILE: tools/virtiofsd/fuse_lowlevel.c:2413:
+^Ireturn err;$
ERROR: code indent should never use tabs
#2440: FILE: tools/virtiofsd/fuse_lowlevel.c:2418:
+^Ireturn req->se->userdata;$
ERROR: code indent should never use tabs
#2445: FILE: tools/virtiofsd/fuse_lowlevel.c:2423:
+^Ireturn &req->ctx;$
ERROR: code indent should never use tabs
#2449: FILE: tools/virtiofsd/fuse_lowlevel.c:2427:
+^I^I^I void *data)$
ERROR: code indent should never use tabs
#2451: FILE: tools/virtiofsd/fuse_lowlevel.c:2429:
+^Ipthread_mutex_lock(&req->lock);$
ERROR: code indent should never use tabs
#2452: FILE: tools/virtiofsd/fuse_lowlevel.c:2430:
+^Ipthread_mutex_lock(&req->se->lock);$
ERROR: code indent should never use tabs
#2453: FILE: tools/virtiofsd/fuse_lowlevel.c:2431:
+^Ireq->u.ni.func = func;$
ERROR: code indent should never use tabs
#2454: FILE: tools/virtiofsd/fuse_lowlevel.c:2432:
+^Ireq->u.ni.data = data;$
ERROR: code indent should never use tabs
#2455: FILE: tools/virtiofsd/fuse_lowlevel.c:2433:
+^Ipthread_mutex_unlock(&req->se->lock);$
ERROR: code indent should never use tabs
#2456: FILE: tools/virtiofsd/fuse_lowlevel.c:2434:
+^Iif (req->interrupted && func)$
ERROR: braces {} are necessary for all arms of this statement
#2456: FILE: tools/virtiofsd/fuse_lowlevel.c:2434:
+ if (req->interrupted && func)
[...]
ERROR: code indent should never use tabs
#2457: FILE: tools/virtiofsd/fuse_lowlevel.c:2435:
+^I^Ifunc(req, data);$
ERROR: code indent should never use tabs
#2458: FILE: tools/virtiofsd/fuse_lowlevel.c:2436:
+^Ipthread_mutex_unlock(&req->lock);$
ERROR: code indent should never use tabs
#2463: FILE: tools/virtiofsd/fuse_lowlevel.c:2441:
+^Iint interrupted;$
ERROR: code indent should never use tabs
#2465: FILE: tools/virtiofsd/fuse_lowlevel.c:2443:
+^Ipthread_mutex_lock(&req->se->lock);$
ERROR: code indent should never use tabs
#2466: FILE: tools/virtiofsd/fuse_lowlevel.c:2444:
+^Iinterrupted = req->interrupted;$
ERROR: code indent should never use tabs
#2467: FILE: tools/virtiofsd/fuse_lowlevel.c:2445:
+^Ipthread_mutex_unlock(&req->se->lock);$
ERROR: code indent should never use tabs
#2469: FILE: tools/virtiofsd/fuse_lowlevel.c:2447:
+^Ireturn interrupted;$
ERROR: code indent should never use tabs
#2473: FILE: tools/virtiofsd/fuse_lowlevel.c:2451:
+^Ivoid (*func)(fuse_req_t, fuse_ino_t, const void *);$
ERROR: code indent should never use tabs
#2474: FILE: tools/virtiofsd/fuse_lowlevel.c:2452:
+^Iconst char *name;$
ERROR: code indent should never use tabs
#2476: FILE: tools/virtiofsd/fuse_lowlevel.c:2454:
+^I[FUSE_LOOKUP]^I = { do_lookup, "LOOKUP"^I },$
ERROR: code indent should never use tabs
#2477: FILE: tools/virtiofsd/fuse_lowlevel.c:2455:
+^I[FUSE_FORGET]^I = { do_forget, "FORGET"^I },$
ERROR: code indent should never use tabs
#2478: FILE: tools/virtiofsd/fuse_lowlevel.c:2456:
+^I[FUSE_GETATTR]^I = { do_getattr, "GETATTR" },$
ERROR: code indent should never use tabs
#2479: FILE: tools/virtiofsd/fuse_lowlevel.c:2457:
+^I[FUSE_SETATTR]^I = { do_setattr, "SETATTR" },$
ERROR: code indent should never use tabs
#2480: FILE: tools/virtiofsd/fuse_lowlevel.c:2458:
+^I[FUSE_READLINK]^I = { do_readlink, "READLINK" },$
ERROR: code indent should never use tabs
#2481: FILE: tools/virtiofsd/fuse_lowlevel.c:2459:
+^I[FUSE_SYMLINK]^I = { do_symlink, "SYMLINK" },$
ERROR: code indent should never use tabs
#2482: FILE: tools/virtiofsd/fuse_lowlevel.c:2460:
+^I[FUSE_MKNOD]^I = { do_mknod, "MKNOD"^I },$
ERROR: code indent should never use tabs
#2483: FILE: tools/virtiofsd/fuse_lowlevel.c:2461:
+^I[FUSE_MKDIR]^I = { do_mkdir, "MKDIR"^I },$
ERROR: code indent should never use tabs
#2484: FILE: tools/virtiofsd/fuse_lowlevel.c:2462:
+^I[FUSE_UNLINK]^I = { do_unlink, "UNLINK"^I },$
ERROR: code indent should never use tabs
#2485: FILE: tools/virtiofsd/fuse_lowlevel.c:2463:
+^I[FUSE_RMDIR]^I = { do_rmdir, "RMDIR"^I },$
ERROR: code indent should never use tabs
#2486: FILE: tools/virtiofsd/fuse_lowlevel.c:2464:
+^I[FUSE_RENAME]^I = { do_rename, "RENAME"^I },$
ERROR: code indent should never use tabs
#2487: FILE: tools/virtiofsd/fuse_lowlevel.c:2465:
+^I[FUSE_LINK]^I = { do_link,^I "LINK"^I },$
ERROR: code indent should never use tabs
#2488: FILE: tools/virtiofsd/fuse_lowlevel.c:2466:
+^I[FUSE_OPEN]^I = { do_open,^I "OPEN"^I },$
ERROR: code indent should never use tabs
#2489: FILE: tools/virtiofsd/fuse_lowlevel.c:2467:
+^I[FUSE_READ]^I = { do_read,^I "READ"^I },$
ERROR: code indent should never use tabs
#2490: FILE: tools/virtiofsd/fuse_lowlevel.c:2468:
+^I[FUSE_WRITE]^I = { do_write, "WRITE"^I },$
ERROR: code indent should never use tabs
#2491: FILE: tools/virtiofsd/fuse_lowlevel.c:2469:
+^I[FUSE_STATFS]^I = { do_statfs, "STATFS"^I },$
ERROR: code indent should never use tabs
#2492: FILE: tools/virtiofsd/fuse_lowlevel.c:2470:
+^I[FUSE_RELEASE]^I = { do_release, "RELEASE" },$
ERROR: code indent should never use tabs
#2493: FILE: tools/virtiofsd/fuse_lowlevel.c:2471:
+^I[FUSE_FSYNC]^I = { do_fsync, "FSYNC"^I },$
ERROR: code indent should never use tabs
#2494: FILE: tools/virtiofsd/fuse_lowlevel.c:2472:
+^I[FUSE_SETXATTR]^I = { do_setxattr, "SETXATTR" },$
ERROR: code indent should never use tabs
#2495: FILE: tools/virtiofsd/fuse_lowlevel.c:2473:
+^I[FUSE_GETXATTR]^I = { do_getxattr, "GETXATTR" },$
ERROR: code indent should never use tabs
#2496: FILE: tools/virtiofsd/fuse_lowlevel.c:2474:
+^I[FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" },$
ERROR: code indent should never use tabs
#2497: FILE: tools/virtiofsd/fuse_lowlevel.c:2475:
+^I[FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" },$
ERROR: code indent should never use tabs
#2498: FILE: tools/virtiofsd/fuse_lowlevel.c:2476:
+^I[FUSE_FLUSH]^I = { do_flush, "FLUSH"^I },$
ERROR: code indent should never use tabs
#2499: FILE: tools/virtiofsd/fuse_lowlevel.c:2477:
+^I[FUSE_INIT]^I = { do_init,^I "INIT"^I },$
ERROR: code indent should never use tabs
#2500: FILE: tools/virtiofsd/fuse_lowlevel.c:2478:
+^I[FUSE_OPENDIR]^I = { do_opendir, "OPENDIR" },$
ERROR: code indent should never use tabs
#2501: FILE: tools/virtiofsd/fuse_lowlevel.c:2479:
+^I[FUSE_READDIR]^I = { do_readdir, "READDIR" },$
ERROR: code indent should never use tabs
#2502: FILE: tools/virtiofsd/fuse_lowlevel.c:2480:
+^I[FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" },$
ERROR: code indent should never use tabs
#2503: FILE: tools/virtiofsd/fuse_lowlevel.c:2481:
+^I[FUSE_FSYNCDIR]^I = { do_fsyncdir, "FSYNCDIR" },$
ERROR: code indent should never use tabs
#2504: FILE: tools/virtiofsd/fuse_lowlevel.c:2482:
+^I[FUSE_GETLK]^I = { do_getlk, "GETLK"^I },$
ERROR: code indent should never use tabs
#2505: FILE: tools/virtiofsd/fuse_lowlevel.c:2483:
+^I[FUSE_SETLK]^I = { do_setlk, "SETLK"^I },$
ERROR: code indent should never use tabs
#2506: FILE: tools/virtiofsd/fuse_lowlevel.c:2484:
+^I[FUSE_SETLKW]^I = { do_setlkw, "SETLKW"^I },$
ERROR: code indent should never use tabs
#2507: FILE: tools/virtiofsd/fuse_lowlevel.c:2485:
+^I[FUSE_ACCESS]^I = { do_access, "ACCESS"^I },$
ERROR: code indent should never use tabs
#2508: FILE: tools/virtiofsd/fuse_lowlevel.c:2486:
+^I[FUSE_CREATE]^I = { do_create, "CREATE"^I },$
ERROR: code indent should never use tabs
#2509: FILE: tools/virtiofsd/fuse_lowlevel.c:2487:
+^I[FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" },$
ERROR: code indent should never use tabs
#2510: FILE: tools/virtiofsd/fuse_lowlevel.c:2488:
+^I[FUSE_BMAP]^I = { do_bmap,^I "BMAP"^I },$
ERROR: code indent should never use tabs
#2511: FILE: tools/virtiofsd/fuse_lowlevel.c:2489:
+^I[FUSE_IOCTL]^I = { do_ioctl, "IOCTL"^I },$
ERROR: code indent should never use tabs
#2512: FILE: tools/virtiofsd/fuse_lowlevel.c:2490:
+^I[FUSE_POLL]^I = { do_poll, "POLL"^I },$
ERROR: code indent should never use tabs
#2513: FILE: tools/virtiofsd/fuse_lowlevel.c:2491:
+^I[FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" },$
ERROR: code indent should never use tabs
#2514: FILE: tools/virtiofsd/fuse_lowlevel.c:2492:
+^I[FUSE_DESTROY]^I = { do_destroy, "DESTROY" },$
ERROR: code indent should never use tabs
#2515: FILE: tools/virtiofsd/fuse_lowlevel.c:2493:
+^I[FUSE_NOTIFY_REPLY] = { (void *) 1, "NOTIFY_REPLY" },$
ERROR: code indent should never use tabs
#2516: FILE: tools/virtiofsd/fuse_lowlevel.c:2494:
+^I[FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" },$
ERROR: code indent should never use tabs
#2517: FILE: tools/virtiofsd/fuse_lowlevel.c:2495:
+^I[FUSE_READDIRPLUS] = { do_readdirplus,^I"READDIRPLUS"},$
ERROR: code indent should never use tabs
#2518: FILE: tools/virtiofsd/fuse_lowlevel.c:2496:
+^I[FUSE_RENAME2] = { do_rename2, "RENAME2" },$
ERROR: code indent should never use tabs
#2519: FILE: tools/virtiofsd/fuse_lowlevel.c:2497:
+^I[FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" },$
ERROR: code indent should never use tabs
#2520: FILE: tools/virtiofsd/fuse_lowlevel.c:2498:
+^I[FUSE_LSEEK]^I = { do_lseek, "LSEEK"^I },$
ERROR: code indent should never use tabs
#2521: FILE: tools/virtiofsd/fuse_lowlevel.c:2499:
+^I[CUSE_INIT]^I = { cuse_lowlevel_init, "CUSE_INIT" },$
ERROR: code indent should never use tabs
#2528: FILE: tools/virtiofsd/fuse_lowlevel.c:2506:
+^Iif (opcode >= FUSE_MAXOP || !fuse_ll_ops[opcode].name)$
ERROR: braces {} are necessary for all arms of this statement
#2528: FILE: tools/virtiofsd/fuse_lowlevel.c:2506:
+ if (opcode >= FUSE_MAXOP || !fuse_ll_ops[opcode].name)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#2529: FILE: tools/virtiofsd/fuse_lowlevel.c:2507:
+^I^Ireturn "???";$
ERROR: code indent should never use tabs
#2530: FILE: tools/virtiofsd/fuse_lowlevel.c:2508:
+^Ielse$
ERROR: code indent should never use tabs
#2531: FILE: tools/virtiofsd/fuse_lowlevel.c:2509:
+^I^Ireturn fuse_ll_ops[opcode].name;$
ERROR: code indent should never use tabs
#2535: FILE: tools/virtiofsd/fuse_lowlevel.c:2513:
+^I^I^I^I struct fuse_bufvec *src)$
ERROR: code indent should never use tabs
#2537: FILE: tools/virtiofsd/fuse_lowlevel.c:2515:
+^Issize_t res = fuse_buf_copy(dst, src, 0);$
ERROR: code indent should never use tabs
#2538: FILE: tools/virtiofsd/fuse_lowlevel.c:2516:
+^Iif (res < 0) {$
WARNING: line over 80 characters
#2539: FILE: tools/virtiofsd/fuse_lowlevel.c:2517:
+ fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: %s\n", strerror(-res));
ERROR: code indent should never use tabs
#2539: FILE: tools/virtiofsd/fuse_lowlevel.c:2517:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: %s\n", strerror(-res));$
ERROR: code indent should never use tabs
#2540: FILE: tools/virtiofsd/fuse_lowlevel.c:2518:
+^I^Ireturn res;$
ERROR: code indent should never use tabs
#2541: FILE: tools/virtiofsd/fuse_lowlevel.c:2519:
+^I}$
ERROR: code indent should never use tabs
#2542: FILE: tools/virtiofsd/fuse_lowlevel.c:2520:
+^Iif ((size_t)res < fuse_buf_size(dst)) {$
ERROR: code indent should never use tabs
#2543: FILE: tools/virtiofsd/fuse_lowlevel.c:2521:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: short read\n");$
ERROR: code indent should never use tabs
#2544: FILE: tools/virtiofsd/fuse_lowlevel.c:2522:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#2545: FILE: tools/virtiofsd/fuse_lowlevel.c:2523:
+^I}$
ERROR: code indent should never use tabs
#2546: FILE: tools/virtiofsd/fuse_lowlevel.c:2524:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#2550: FILE: tools/virtiofsd/fuse_lowlevel.c:2528:
+^I^I^I const struct fuse_buf *buf)$
ERROR: code indent should never use tabs
#2552: FILE: tools/virtiofsd/fuse_lowlevel.c:2530:
+^Ifuse_session_process_buf_int(se, buf, NULL);$
WARNING: line over 80 characters
#2556: FILE: tools/virtiofsd/fuse_lowlevel.c:2534:
+ const struct fuse_buf *buf, struct fuse_chan *ch)
ERROR: code indent should never use tabs
#2556: FILE: tools/virtiofsd/fuse_lowlevel.c:2534:
+^I^I^I^I const struct fuse_buf *buf, struct fuse_chan *ch)$
ERROR: code indent should never use tabs
#2558: FILE: tools/virtiofsd/fuse_lowlevel.c:2536:
+^Iconst size_t write_header_size = sizeof(struct fuse_in_header) +$
ERROR: code indent should never use tabs
#2559: FILE: tools/virtiofsd/fuse_lowlevel.c:2537:
+^I^Isizeof(struct fuse_write_in);$
ERROR: code indent should never use tabs
#2560: FILE: tools/virtiofsd/fuse_lowlevel.c:2538:
+^Istruct fuse_bufvec bufv = { .buf[0] = *buf, .count = 1 };$
ERROR: code indent should never use tabs
#2561: FILE: tools/virtiofsd/fuse_lowlevel.c:2539:
+^Istruct fuse_bufvec tmpbuf = FUSE_BUFVEC_INIT(write_header_size);$
ERROR: code indent should never use tabs
#2562: FILE: tools/virtiofsd/fuse_lowlevel.c:2540:
+^Istruct fuse_in_header *in;$
ERROR: code indent should never use tabs
#2563: FILE: tools/virtiofsd/fuse_lowlevel.c:2541:
+^Iconst void *inarg;$
ERROR: code indent should never use tabs
#2564: FILE: tools/virtiofsd/fuse_lowlevel.c:2542:
+^Istruct fuse_req *req;$
ERROR: code indent should never use tabs
#2565: FILE: tools/virtiofsd/fuse_lowlevel.c:2543:
+^Ivoid *mbuf = NULL;$
ERROR: code indent should never use tabs
#2566: FILE: tools/virtiofsd/fuse_lowlevel.c:2544:
+^Iint err;$
ERROR: code indent should never use tabs
#2567: FILE: tools/virtiofsd/fuse_lowlevel.c:2545:
+^Iint res;$
ERROR: code indent should never use tabs
#2569: FILE: tools/virtiofsd/fuse_lowlevel.c:2547:
+^Iif (buf->flags & FUSE_BUF_IS_FD) {$
ERROR: code indent should never use tabs
#2570: FILE: tools/virtiofsd/fuse_lowlevel.c:2548:
+^I^Iif (buf->size < tmpbuf.buf[0].size)$
ERROR: braces {} are necessary for all arms of this statement
#2570: FILE: tools/virtiofsd/fuse_lowlevel.c:2548:
+ if (buf->size < tmpbuf.buf[0].size)
[...]
ERROR: code indent should never use tabs
#2571: FILE: tools/virtiofsd/fuse_lowlevel.c:2549:
+^I^I^Itmpbuf.buf[0].size = buf->size;$
ERROR: code indent should never use tabs
#2573: FILE: tools/virtiofsd/fuse_lowlevel.c:2551:
+^I^Imbuf = malloc(tmpbuf.buf[0].size);$
ERROR: code indent should never use tabs
#2574: FILE: tools/virtiofsd/fuse_lowlevel.c:2552:
+^I^Iif (mbuf == NULL) {$
WARNING: line over 80 characters
#2575: FILE: tools/virtiofsd/fuse_lowlevel.c:2553:
+ fuse_log(FUSE_LOG_ERR, "fuse: failed to allocate header\n");
ERROR: code indent should never use tabs
#2575: FILE: tools/virtiofsd/fuse_lowlevel.c:2553:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "fuse: failed to allocate header\n");$
ERROR: code indent should never use tabs
#2576: FILE: tools/virtiofsd/fuse_lowlevel.c:2554:
+^I^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#2577: FILE: tools/virtiofsd/fuse_lowlevel.c:2555:
+^I^I}$
ERROR: code indent should never use tabs
#2578: FILE: tools/virtiofsd/fuse_lowlevel.c:2556:
+^I^Itmpbuf.buf[0].mem = mbuf;$
ERROR: code indent should never use tabs
#2580: FILE: tools/virtiofsd/fuse_lowlevel.c:2558:
+^I^Ires = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);$
ERROR: code indent should never use tabs
#2581: FILE: tools/virtiofsd/fuse_lowlevel.c:2559:
+^I^Iif (res < 0)$
ERROR: braces {} are necessary for all arms of this statement
#2581: FILE: tools/virtiofsd/fuse_lowlevel.c:2559:
+ if (res < 0)
[...]
ERROR: code indent should never use tabs
#2582: FILE: tools/virtiofsd/fuse_lowlevel.c:2560:
+^I^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#2584: FILE: tools/virtiofsd/fuse_lowlevel.c:2562:
+^I^Iin = mbuf;$
ERROR: code indent should never use tabs
#2585: FILE: tools/virtiofsd/fuse_lowlevel.c:2563:
+^I} else {$
ERROR: code indent should never use tabs
#2586: FILE: tools/virtiofsd/fuse_lowlevel.c:2564:
+^I^Iin = buf->mem;$
ERROR: code indent should never use tabs
#2587: FILE: tools/virtiofsd/fuse_lowlevel.c:2565:
+^I}$
ERROR: code indent should never use tabs
#2589: FILE: tools/virtiofsd/fuse_lowlevel.c:2567:
+^Iif (se->debug) {$
ERROR: code indent should never use tabs
#2590: FILE: tools/virtiofsd/fuse_lowlevel.c:2568:
+^I^Ifuse_log(FUSE_LOG_DEBUG,$
ERROR: code indent should never use tabs
#2591: FILE: tools/virtiofsd/fuse_lowlevel.c:2569:
+^I^I^I"unique: %llu, opcode: %s (%i), nodeid: %llu, insize: %zu, pid: %u\n",$
ERROR: code indent should never use tabs
#2592: FILE: tools/virtiofsd/fuse_lowlevel.c:2570:
+^I^I^I(unsigned long long) in->unique,$
ERROR: code indent should never use tabs
#2593: FILE: tools/virtiofsd/fuse_lowlevel.c:2571:
+^I^I^Iopname((enum fuse_opcode) in->opcode), in->opcode,$
ERROR: code indent should never use tabs
#2594: FILE: tools/virtiofsd/fuse_lowlevel.c:2572:
+^I^I^I(unsigned long long) in->nodeid, buf->size, in->pid);$
ERROR: code indent should never use tabs
#2595: FILE: tools/virtiofsd/fuse_lowlevel.c:2573:
+^I}$
ERROR: code indent should never use tabs
#2597: FILE: tools/virtiofsd/fuse_lowlevel.c:2575:
+^Ireq = fuse_ll_alloc_req(se);$
ERROR: code indent should never use tabs
#2598: FILE: tools/virtiofsd/fuse_lowlevel.c:2576:
+^Iif (req == NULL) {$
ERROR: code indent should never use tabs
#2599: FILE: tools/virtiofsd/fuse_lowlevel.c:2577:
+^I^Istruct fuse_out_header out = {$
ERROR: code indent should never use tabs
#2600: FILE: tools/virtiofsd/fuse_lowlevel.c:2578:
+^I^I^I.unique = in->unique,$
ERROR: code indent should never use tabs
#2601: FILE: tools/virtiofsd/fuse_lowlevel.c:2579:
+^I^I^I.error = -ENOMEM,$
ERROR: code indent should never use tabs
#2602: FILE: tools/virtiofsd/fuse_lowlevel.c:2580:
+^I^I};$
ERROR: code indent should never use tabs
#2603: FILE: tools/virtiofsd/fuse_lowlevel.c:2581:
+^I^Istruct iovec iov = {$
ERROR: code indent should never use tabs
#2604: FILE: tools/virtiofsd/fuse_lowlevel.c:2582:
+^I^I^I.iov_base = &out,$
ERROR: code indent should never use tabs
#2605: FILE: tools/virtiofsd/fuse_lowlevel.c:2583:
+^I^I^I.iov_len = sizeof(struct fuse_out_header),$
ERROR: code indent should never use tabs
#2606: FILE: tools/virtiofsd/fuse_lowlevel.c:2584:
+^I^I};$
ERROR: code indent should never use tabs
#2608: FILE: tools/virtiofsd/fuse_lowlevel.c:2586:
+^I^Ifuse_send_msg(se, ch, &iov, 1);$
ERROR: code indent should never use tabs
#2609: FILE: tools/virtiofsd/fuse_lowlevel.c:2587:
+^I^Igoto clear_pipe;$
ERROR: code indent should never use tabs
#2610: FILE: tools/virtiofsd/fuse_lowlevel.c:2588:
+^I}$
ERROR: code indent should never use tabs
#2612: FILE: tools/virtiofsd/fuse_lowlevel.c:2590:
+^Ireq->unique = in->unique;$
ERROR: code indent should never use tabs
#2613: FILE: tools/virtiofsd/fuse_lowlevel.c:2591:
+^Ireq->ctx.uid = in->uid;$
ERROR: code indent should never use tabs
#2614: FILE: tools/virtiofsd/fuse_lowlevel.c:2592:
+^Ireq->ctx.gid = in->gid;$
ERROR: code indent should never use tabs
#2615: FILE: tools/virtiofsd/fuse_lowlevel.c:2593:
+^Ireq->ctx.pid = in->pid;$
ERROR: code indent should never use tabs
#2616: FILE: tools/virtiofsd/fuse_lowlevel.c:2594:
+^Ireq->ch = ch ? fuse_chan_get(ch) : NULL;$
ERROR: code indent should never use tabs
#2618: FILE: tools/virtiofsd/fuse_lowlevel.c:2596:
+^Ierr = EIO;$
ERROR: code indent should never use tabs
#2619: FILE: tools/virtiofsd/fuse_lowlevel.c:2597:
+^Iif (!se->got_init) {$
ERROR: code indent should never use tabs
#2620: FILE: tools/virtiofsd/fuse_lowlevel.c:2598:
+^I^Ienum fuse_opcode expected;$
ERROR: code indent should never use tabs
#2622: FILE: tools/virtiofsd/fuse_lowlevel.c:2600:
+^I^Iexpected = se->cuse_data ? CUSE_INIT : FUSE_INIT;$
ERROR: code indent should never use tabs
#2623: FILE: tools/virtiofsd/fuse_lowlevel.c:2601:
+^I^Iif (in->opcode != expected)$
ERROR: braces {} are necessary for all arms of this statement
#2623: FILE: tools/virtiofsd/fuse_lowlevel.c:2601:
+ if (in->opcode != expected)
[...]
ERROR: code indent should never use tabs
#2624: FILE: tools/virtiofsd/fuse_lowlevel.c:2602:
+^I^I^Igoto reply_err;$
ERROR: code indent should never use tabs
#2625: FILE: tools/virtiofsd/fuse_lowlevel.c:2603:
+^I} else if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT)$
ERROR: braces {} are necessary for all arms of this statement
#2625: FILE: tools/virtiofsd/fuse_lowlevel.c:2603:
+ } else if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT)
[...]
ERROR: code indent should never use tabs
#2626: FILE: tools/virtiofsd/fuse_lowlevel.c:2604:
+^I^Igoto reply_err;$
ERROR: code indent should never use tabs
#2628: FILE: tools/virtiofsd/fuse_lowlevel.c:2606:
+^Ierr = EACCES;$
ERROR: code indent should never use tabs
#2629: FILE: tools/virtiofsd/fuse_lowlevel.c:2607:
+^I/* Implement -o allow_root */$
ERROR: code indent should never use tabs
#2630: FILE: tools/virtiofsd/fuse_lowlevel.c:2608:
+^Iif (se->deny_others && in->uid != se->owner && in->uid != 0 &&$
ERROR: code indent should never use tabs
#2631: FILE: tools/virtiofsd/fuse_lowlevel.c:2609:
+^I^I in->opcode != FUSE_INIT && in->opcode != FUSE_READ &&$
ERROR: code indent should never use tabs
#2632: FILE: tools/virtiofsd/fuse_lowlevel.c:2610:
+^I^I in->opcode != FUSE_WRITE && in->opcode != FUSE_FSYNC &&$
ERROR: code indent should never use tabs
#2633: FILE: tools/virtiofsd/fuse_lowlevel.c:2611:
+^I^I in->opcode != FUSE_RELEASE && in->opcode != FUSE_READDIR &&$
ERROR: code indent should never use tabs
#2634: FILE: tools/virtiofsd/fuse_lowlevel.c:2612:
+^I^I in->opcode != FUSE_FSYNCDIR && in->opcode != FUSE_RELEASEDIR &&$
ERROR: code indent should never use tabs
#2635: FILE: tools/virtiofsd/fuse_lowlevel.c:2613:
+^I^I in->opcode != FUSE_NOTIFY_REPLY &&$
ERROR: code indent should never use tabs
#2636: FILE: tools/virtiofsd/fuse_lowlevel.c:2614:
+^I^I in->opcode != FUSE_READDIRPLUS)$
ERROR: code indent should never use tabs
#2637: FILE: tools/virtiofsd/fuse_lowlevel.c:2615:
+^I^Igoto reply_err;$
ERROR: code indent should never use tabs
#2639: FILE: tools/virtiofsd/fuse_lowlevel.c:2617:
+^Ierr = ENOSYS;$
ERROR: code indent should never use tabs
#2640: FILE: tools/virtiofsd/fuse_lowlevel.c:2618:
+^Iif (in->opcode >= FUSE_MAXOP || !fuse_ll_ops[in->opcode].func)$
ERROR: braces {} are necessary for all arms of this statement
#2640: FILE: tools/virtiofsd/fuse_lowlevel.c:2618:
+ if (in->opcode >= FUSE_MAXOP || !fuse_ll_ops[in->opcode].func)
[...]
ERROR: code indent should never use tabs
#2641: FILE: tools/virtiofsd/fuse_lowlevel.c:2619:
+^I^Igoto reply_err;$
ERROR: code indent should never use tabs
#2642: FILE: tools/virtiofsd/fuse_lowlevel.c:2620:
+^Iif (in->opcode != FUSE_INTERRUPT) {$
ERROR: code indent should never use tabs
#2643: FILE: tools/virtiofsd/fuse_lowlevel.c:2621:
+^I^Istruct fuse_req *intr;$
ERROR: code indent should never use tabs
#2644: FILE: tools/virtiofsd/fuse_lowlevel.c:2622:
+^I^Ipthread_mutex_lock(&se->lock);$
ERROR: code indent should never use tabs
#2645: FILE: tools/virtiofsd/fuse_lowlevel.c:2623:
+^I^Iintr = check_interrupt(se, req);$
ERROR: code indent should never use tabs
#2646: FILE: tools/virtiofsd/fuse_lowlevel.c:2624:
+^I^Ilist_add_req(req, &se->list);$
ERROR: code indent should never use tabs
#2647: FILE: tools/virtiofsd/fuse_lowlevel.c:2625:
+^I^Ipthread_mutex_unlock(&se->lock);$
ERROR: code indent should never use tabs
#2648: FILE: tools/virtiofsd/fuse_lowlevel.c:2626:
+^I^Iif (intr)$
ERROR: braces {} are necessary for all arms of this statement
#2648: FILE: tools/virtiofsd/fuse_lowlevel.c:2626:
+ if (intr)
[...]
ERROR: code indent should never use tabs
#2649: FILE: tools/virtiofsd/fuse_lowlevel.c:2627:
+^I^I^Ifuse_reply_err(intr, EAGAIN);$
ERROR: code indent should never use tabs
#2650: FILE: tools/virtiofsd/fuse_lowlevel.c:2628:
+^I}$
ERROR: code indent should never use tabs
#2652: FILE: tools/virtiofsd/fuse_lowlevel.c:2630:
+^Iif ((buf->flags & FUSE_BUF_IS_FD) && write_header_size < buf->size &&$
ERROR: code indent should never use tabs
#2653: FILE: tools/virtiofsd/fuse_lowlevel.c:2631:
+^I (in->opcode != FUSE_WRITE || !se->op.write_buf) &&$
ERROR: code indent should never use tabs
#2654: FILE: tools/virtiofsd/fuse_lowlevel.c:2632:
+^I in->opcode != FUSE_NOTIFY_REPLY) {$
ERROR: code indent should never use tabs
#2655: FILE: tools/virtiofsd/fuse_lowlevel.c:2633:
+^I^Ivoid *newmbuf;$
ERROR: code indent should never use tabs
#2657: FILE: tools/virtiofsd/fuse_lowlevel.c:2635:
+^I^Ierr = ENOMEM;$
ERROR: code indent should never use tabs
#2658: FILE: tools/virtiofsd/fuse_lowlevel.c:2636:
+^I^Inewmbuf = realloc(mbuf, buf->size);$
ERROR: code indent should never use tabs
#2659: FILE: tools/virtiofsd/fuse_lowlevel.c:2637:
+^I^Iif (newmbuf == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#2659: FILE: tools/virtiofsd/fuse_lowlevel.c:2637:
+ if (newmbuf == NULL)
[...]
ERROR: code indent should never use tabs
#2660: FILE: tools/virtiofsd/fuse_lowlevel.c:2638:
+^I^I^Igoto reply_err;$
ERROR: code indent should never use tabs
#2661: FILE: tools/virtiofsd/fuse_lowlevel.c:2639:
+^I^Imbuf = newmbuf;$
ERROR: code indent should never use tabs
#2663: FILE: tools/virtiofsd/fuse_lowlevel.c:2641:
+^I^Itmpbuf = FUSE_BUFVEC_INIT(buf->size - write_header_size);$
ERROR: code indent should never use tabs
#2664: FILE: tools/virtiofsd/fuse_lowlevel.c:2642:
+^I^Itmpbuf.buf[0].mem = (char *)mbuf + write_header_size;$
ERROR: code indent should never use tabs
#2666: FILE: tools/virtiofsd/fuse_lowlevel.c:2644:
+^I^Ires = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);$
ERROR: code indent should never use tabs
#2667: FILE: tools/virtiofsd/fuse_lowlevel.c:2645:
+^I^Ierr = -res;$
ERROR: code indent should never use tabs
#2668: FILE: tools/virtiofsd/fuse_lowlevel.c:2646:
+^I^Iif (res < 0)$
ERROR: braces {} are necessary for all arms of this statement
#2668: FILE: tools/virtiofsd/fuse_lowlevel.c:2646:
+ if (res < 0)
[...]
ERROR: code indent should never use tabs
#2669: FILE: tools/virtiofsd/fuse_lowlevel.c:2647:
+^I^I^Igoto reply_err;$
ERROR: code indent should never use tabs
#2671: FILE: tools/virtiofsd/fuse_lowlevel.c:2649:
+^I^Iin = mbuf;$
ERROR: code indent should never use tabs
#2672: FILE: tools/virtiofsd/fuse_lowlevel.c:2650:
+^I}$
ERROR: code indent should never use tabs
#2674: FILE: tools/virtiofsd/fuse_lowlevel.c:2652:
+^Iinarg = (void *) &in[1];$
ERROR: code indent should never use tabs
#2675: FILE: tools/virtiofsd/fuse_lowlevel.c:2653:
+^Iif (in->opcode == FUSE_WRITE && se->op.write_buf)$
ERROR: braces {} are necessary for all arms of this statement
#2675: FILE: tools/virtiofsd/fuse_lowlevel.c:2653:
+ if (in->opcode == FUSE_WRITE && se->op.write_buf)
[...]
+ else if (in->opcode == FUSE_NOTIFY_REPLY)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#2676: FILE: tools/virtiofsd/fuse_lowlevel.c:2654:
+^I^Ido_write_buf(req, in->nodeid, inarg, buf);$
ERROR: code indent should never use tabs
#2677: FILE: tools/virtiofsd/fuse_lowlevel.c:2655:
+^Ielse if (in->opcode == FUSE_NOTIFY_REPLY)$
ERROR: braces {} are necessary for all arms of this statement
#2677: FILE: tools/virtiofsd/fuse_lowlevel.c:2655:
+ else if (in->opcode == FUSE_NOTIFY_REPLY)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#2678: FILE: tools/virtiofsd/fuse_lowlevel.c:2656:
+^I^Ido_notify_reply(req, in->nodeid, inarg, buf);$
ERROR: code indent should never use tabs
#2679: FILE: tools/virtiofsd/fuse_lowlevel.c:2657:
+^Ielse$
ERROR: code indent should never use tabs
#2680: FILE: tools/virtiofsd/fuse_lowlevel.c:2658:
+^I^Ifuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);$
ERROR: code indent should never use tabs
#2683: FILE: tools/virtiofsd/fuse_lowlevel.c:2661:
+^Ifree(mbuf);$
ERROR: code indent should never use tabs
#2684: FILE: tools/virtiofsd/fuse_lowlevel.c:2662:
+^Ireturn;$
ERROR: code indent should never use tabs
#2687: FILE: tools/virtiofsd/fuse_lowlevel.c:2665:
+^Ifuse_reply_err(req, err);$
ERROR: code indent should never use tabs
#2689: FILE: tools/virtiofsd/fuse_lowlevel.c:2667:
+^Iif (buf->flags & FUSE_BUF_IS_FD)$
ERROR: braces {} are necessary for all arms of this statement
#2689: FILE: tools/virtiofsd/fuse_lowlevel.c:2667:
+ if (buf->flags & FUSE_BUF_IS_FD)
[...]
ERROR: code indent should never use tabs
#2690: FILE: tools/virtiofsd/fuse_lowlevel.c:2668:
+^I^Ifuse_ll_clear_pipe(se);$
ERROR: code indent should never use tabs
#2691: FILE: tools/virtiofsd/fuse_lowlevel.c:2669:
+^Igoto out_free;$
ERROR: space required after that ',' (ctx:VxV)
#2694: FILE: tools/virtiofsd/fuse_lowlevel.c:2672:
+#define LL_OPTION(n,o,v) \
^
ERROR: space required after that ',' (ctx:VxV)
#2694: FILE: tools/virtiofsd/fuse_lowlevel.c:2672:
+#define LL_OPTION(n,o,v) \
^
ERROR: code indent should never use tabs
#2695: FILE: tools/virtiofsd/fuse_lowlevel.c:2673:
+^I{ n, offsetof(struct fuse_session, o), v }$
ERROR: code indent should never use tabs
#2698: FILE: tools/virtiofsd/fuse_lowlevel.c:2676:
+^ILL_OPTION("debug", debug, 1),$
ERROR: code indent should never use tabs
#2699: FILE: tools/virtiofsd/fuse_lowlevel.c:2677:
+^ILL_OPTION("-d", debug, 1),$
ERROR: code indent should never use tabs
#2700: FILE: tools/virtiofsd/fuse_lowlevel.c:2678:
+^ILL_OPTION("--debug", debug, 1),$
ERROR: code indent should never use tabs
#2701: FILE: tools/virtiofsd/fuse_lowlevel.c:2679:
+^ILL_OPTION("allow_root", deny_others, 1),$
ERROR: code indent should never use tabs
#2702: FILE: tools/virtiofsd/fuse_lowlevel.c:2680:
+^IFUSE_OPT_END$
ERROR: code indent should never use tabs
#2707: FILE: tools/virtiofsd/fuse_lowlevel.c:2685:
+^Iprintf("using FUSE kernel interface version %i.%i\n",$
ERROR: code indent should never use tabs
#2708: FILE: tools/virtiofsd/fuse_lowlevel.c:2686:
+^I FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);$
ERROR: code indent should never use tabs
#2709: FILE: tools/virtiofsd/fuse_lowlevel.c:2687:
+^Ifuse_mount_version();$
ERROR: code indent should never use tabs
#2714: FILE: tools/virtiofsd/fuse_lowlevel.c:2692:
+^I/* These are not all options, but the ones that are$
WARNING: Block comments use a leading /* on a separate line
#2714: FILE: tools/virtiofsd/fuse_lowlevel.c:2692:
+ /* These are not all options, but the ones that are
ERROR: code indent should never use tabs
#2715: FILE: tools/virtiofsd/fuse_lowlevel.c:2693:
+^I potentially of interest to an end-user */$
WARNING: Block comments use * on subsequent lines
#2715: FILE: tools/virtiofsd/fuse_lowlevel.c:2693:
+ /* These are not all options, but the ones that are
+ potentially of interest to an end-user */
WARNING: Block comments use a trailing */ on a separate line
#2715: FILE: tools/virtiofsd/fuse_lowlevel.c:2693:
+ potentially of interest to an end-user */
ERROR: code indent should never use tabs
#2716: FILE: tools/virtiofsd/fuse_lowlevel.c:2694:
+^Iprintf($
ERROR: code indent should never use tabs
#2724: FILE: tools/virtiofsd/fuse_lowlevel.c:2702:
+^Istruct fuse_ll_pipe *llp;$
ERROR: code indent should never use tabs
#2726: FILE: tools/virtiofsd/fuse_lowlevel.c:2704:
+^Iif (se->got_init && !se->got_destroy) {$
ERROR: code indent should never use tabs
#2727: FILE: tools/virtiofsd/fuse_lowlevel.c:2705:
+^I^Iif (se->op.destroy)$
ERROR: braces {} are necessary for all arms of this statement
#2727: FILE: tools/virtiofsd/fuse_lowlevel.c:2705:
+ if (se->op.destroy)
[...]
ERROR: code indent should never use tabs
#2728: FILE: tools/virtiofsd/fuse_lowlevel.c:2706:
+^I^I^Ise->op.destroy(se->userdata);$
ERROR: code indent should never use tabs
#2729: FILE: tools/virtiofsd/fuse_lowlevel.c:2707:
+^I}$
ERROR: code indent should never use tabs
#2730: FILE: tools/virtiofsd/fuse_lowlevel.c:2708:
+^Illp = pthread_getspecific(se->pipe_key);$
ERROR: code indent should never use tabs
#2731: FILE: tools/virtiofsd/fuse_lowlevel.c:2709:
+^Iif (llp != NULL)$
ERROR: braces {} are necessary for all arms of this statement
#2731: FILE: tools/virtiofsd/fuse_lowlevel.c:2709:
+ if (llp != NULL)
[...]
ERROR: code indent should never use tabs
#2732: FILE: tools/virtiofsd/fuse_lowlevel.c:2710:
+^I^Ifuse_ll_pipe_free(llp);$
ERROR: code indent should never use tabs
#2733: FILE: tools/virtiofsd/fuse_lowlevel.c:2711:
+^Ipthread_key_delete(se->pipe_key);$
ERROR: code indent should never use tabs
#2734: FILE: tools/virtiofsd/fuse_lowlevel.c:2712:
+^Ipthread_mutex_destroy(&se->lock);$
ERROR: code indent should never use tabs
#2735: FILE: tools/virtiofsd/fuse_lowlevel.c:2713:
+^Ifree(se->cuse_data);$
ERROR: code indent should never use tabs
#2736: FILE: tools/virtiofsd/fuse_lowlevel.c:2714:
+^Iif (se->fd != -1)$
ERROR: braces {} are necessary for all arms of this statement
#2736: FILE: tools/virtiofsd/fuse_lowlevel.c:2714:
+ if (se->fd != -1)
[...]
ERROR: code indent should never use tabs
#2737: FILE: tools/virtiofsd/fuse_lowlevel.c:2715:
+^I^Iclose(se->fd);$
ERROR: code indent should never use tabs
#2738: FILE: tools/virtiofsd/fuse_lowlevel.c:2716:
+^Idestroy_mount_opts(se->mo);$
ERROR: code indent should never use tabs
#2739: FILE: tools/virtiofsd/fuse_lowlevel.c:2717:
+^Ifree(se);$
ERROR: code indent should never use tabs
#2745: FILE: tools/virtiofsd/fuse_lowlevel.c:2723:
+^Istruct fuse_ll_pipe *llp = data;$
ERROR: code indent should never use tabs
#2746: FILE: tools/virtiofsd/fuse_lowlevel.c:2724:
+^Ifuse_ll_pipe_free(llp);$
ERROR: code indent should never use tabs
#2751: FILE: tools/virtiofsd/fuse_lowlevel.c:2729:
+^Ireturn fuse_session_receive_buf_int(se, buf, NULL);$
ERROR: code indent should never use tabs
#2755: FILE: tools/virtiofsd/fuse_lowlevel.c:2733:
+^I^I^I^I struct fuse_chan *ch)$
ERROR: code indent should never use tabs
#2757: FILE: tools/virtiofsd/fuse_lowlevel.c:2735:
+^Iint err;$
ERROR: code indent should never use tabs
#2758: FILE: tools/virtiofsd/fuse_lowlevel.c:2736:
+^Issize_t res;$
ERROR: code indent should never use tabs
#2760: FILE: tools/virtiofsd/fuse_lowlevel.c:2738:
+^Isize_t bufsize = se->bufsize;$
ERROR: code indent should never use tabs
#2761: FILE: tools/virtiofsd/fuse_lowlevel.c:2739:
+^Istruct fuse_ll_pipe *llp;$
ERROR: code indent should never use tabs
#2762: FILE: tools/virtiofsd/fuse_lowlevel.c:2740:
+^Istruct fuse_buf tmpbuf;$
WARNING: line over 80 characters
#2764: FILE: tools/virtiofsd/fuse_lowlevel.c:2742:
+ if (se->conn.proto_minor < 14 || !(se->conn.want & FUSE_CAP_SPLICE_READ))
ERROR: code indent should never use tabs
#2764: FILE: tools/virtiofsd/fuse_lowlevel.c:2742:
+^Iif (se->conn.proto_minor < 14 || !(se->conn.want & FUSE_CAP_SPLICE_READ))$
ERROR: braces {} are necessary for all arms of this statement
#2764: FILE: tools/virtiofsd/fuse_lowlevel.c:2742:
+ if (se->conn.proto_minor < 14 || !(se->conn.want & FUSE_CAP_SPLICE_READ))
[...]
ERROR: code indent should never use tabs
#2765: FILE: tools/virtiofsd/fuse_lowlevel.c:2743:
+^I^Igoto fallback;$
ERROR: code indent should never use tabs
#2767: FILE: tools/virtiofsd/fuse_lowlevel.c:2745:
+^Illp = fuse_ll_get_pipe(se);$
ERROR: code indent should never use tabs
#2768: FILE: tools/virtiofsd/fuse_lowlevel.c:2746:
+^Iif (llp == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#2768: FILE: tools/virtiofsd/fuse_lowlevel.c:2746:
+ if (llp == NULL)
[...]
ERROR: code indent should never use tabs
#2769: FILE: tools/virtiofsd/fuse_lowlevel.c:2747:
+^I^Igoto fallback;$
ERROR: code indent should never use tabs
#2771: FILE: tools/virtiofsd/fuse_lowlevel.c:2749:
+^Iif (llp->size < bufsize) {$
ERROR: code indent should never use tabs
#2772: FILE: tools/virtiofsd/fuse_lowlevel.c:2750:
+^I^Iif (llp->can_grow) {$
ERROR: code indent should never use tabs
#2773: FILE: tools/virtiofsd/fuse_lowlevel.c:2751:
+^I^I^Ires = fcntl(llp->pipe[0], F_SETPIPE_SZ, bufsize);$
ERROR: code indent should never use tabs
#2774: FILE: tools/virtiofsd/fuse_lowlevel.c:2752:
+^I^I^Iif (res == -1) {$
ERROR: code indent should never use tabs
#2775: FILE: tools/virtiofsd/fuse_lowlevel.c:2753:
+^I^I^I^Illp->can_grow = 0;$
ERROR: code indent should never use tabs
#2776: FILE: tools/virtiofsd/fuse_lowlevel.c:2754:
+^I^I^I^Ires = grow_pipe_to_max(llp->pipe[0]);$
ERROR: code indent should never use tabs
#2777: FILE: tools/virtiofsd/fuse_lowlevel.c:2755:
+^I^I^I^Iif (res > 0)$
ERROR: braces {} are necessary for all arms of this statement
#2777: FILE: tools/virtiofsd/fuse_lowlevel.c:2755:
+ if (res > 0)
[...]
ERROR: code indent should never use tabs
#2778: FILE: tools/virtiofsd/fuse_lowlevel.c:2756:
+^I^I^I^I^Illp->size = res;$
ERROR: code indent should never use tabs
#2779: FILE: tools/virtiofsd/fuse_lowlevel.c:2757:
+^I^I^I^Igoto fallback;$
ERROR: code indent should never use tabs
#2780: FILE: tools/virtiofsd/fuse_lowlevel.c:2758:
+^I^I^I}$
ERROR: code indent should never use tabs
#2781: FILE: tools/virtiofsd/fuse_lowlevel.c:2759:
+^I^I^Illp->size = res;$
ERROR: code indent should never use tabs
#2782: FILE: tools/virtiofsd/fuse_lowlevel.c:2760:
+^I^I}$
ERROR: code indent should never use tabs
#2783: FILE: tools/virtiofsd/fuse_lowlevel.c:2761:
+^I^Iif (llp->size < bufsize)$
ERROR: braces {} are necessary for all arms of this statement
#2783: FILE: tools/virtiofsd/fuse_lowlevel.c:2761:
+ if (llp->size < bufsize)
[...]
ERROR: code indent should never use tabs
#2784: FILE: tools/virtiofsd/fuse_lowlevel.c:2762:
+^I^I^Igoto fallback;$
ERROR: code indent should never use tabs
#2785: FILE: tools/virtiofsd/fuse_lowlevel.c:2763:
+^I}$
ERROR: code indent should never use tabs
#2787: FILE: tools/virtiofsd/fuse_lowlevel.c:2765:
+^Ires = splice(ch ? ch->fd : se->fd,$
ERROR: code indent should never use tabs
#2788: FILE: tools/virtiofsd/fuse_lowlevel.c:2766:
+^I^I NULL, llp->pipe[1], NULL, bufsize, 0);$
ERROR: code indent should never use tabs
#2789: FILE: tools/virtiofsd/fuse_lowlevel.c:2767:
+^Ierr = errno;$
ERROR: code indent should never use tabs
#2791: FILE: tools/virtiofsd/fuse_lowlevel.c:2769:
+^Iif (fuse_session_exited(se))$
ERROR: braces {} are necessary for all arms of this statement
#2791: FILE: tools/virtiofsd/fuse_lowlevel.c:2769:
+ if (fuse_session_exited(se))
[...]
ERROR: code indent should never use tabs
#2792: FILE: tools/virtiofsd/fuse_lowlevel.c:2770:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#2794: FILE: tools/virtiofsd/fuse_lowlevel.c:2772:
+^Iif (res == -1) {$
ERROR: code indent should never use tabs
#2795: FILE: tools/virtiofsd/fuse_lowlevel.c:2773:
+^I^Iif (err == ENODEV) {$
ERROR: code indent should never use tabs
#2796: FILE: tools/virtiofsd/fuse_lowlevel.c:2774:
+^I^I^I/* Filesystem was unmounted, or connection was aborted$
WARNING: Block comments use a leading /* on a separate line
#2796: FILE: tools/virtiofsd/fuse_lowlevel.c:2774:
+ /* Filesystem was unmounted, or connection was aborted
ERROR: code indent should never use tabs
#2797: FILE: tools/virtiofsd/fuse_lowlevel.c:2775:
+^I^I^I via /sys/fs/fuse/connections */$
WARNING: Block comments use * on subsequent lines
#2797: FILE: tools/virtiofsd/fuse_lowlevel.c:2775:
+ /* Filesystem was unmounted, or connection was aborted
+ via /sys/fs/fuse/connections */
WARNING: Block comments use a trailing */ on a separate line
#2797: FILE: tools/virtiofsd/fuse_lowlevel.c:2775:
+ via /sys/fs/fuse/connections */
ERROR: code indent should never use tabs
#2798: FILE: tools/virtiofsd/fuse_lowlevel.c:2776:
+^I^I^Ifuse_session_exit(se);$
ERROR: code indent should never use tabs
#2799: FILE: tools/virtiofsd/fuse_lowlevel.c:2777:
+^I^I^Ireturn 0;$
ERROR: code indent should never use tabs
#2800: FILE: tools/virtiofsd/fuse_lowlevel.c:2778:
+^I^I}$
ERROR: code indent should never use tabs
#2801: FILE: tools/virtiofsd/fuse_lowlevel.c:2779:
+^I^Iif (err != EINTR && err != EAGAIN)$
ERROR: braces {} are necessary for all arms of this statement
#2801: FILE: tools/virtiofsd/fuse_lowlevel.c:2779:
+ if (err != EINTR && err != EAGAIN)
[...]
ERROR: code indent should never use tabs
#2802: FILE: tools/virtiofsd/fuse_lowlevel.c:2780:
+^I^I^Iperror("fuse: splice from device");$
ERROR: code indent should never use tabs
#2803: FILE: tools/virtiofsd/fuse_lowlevel.c:2781:
+^I^Ireturn -err;$
ERROR: code indent should never use tabs
#2804: FILE: tools/virtiofsd/fuse_lowlevel.c:2782:
+^I}$
ERROR: code indent should never use tabs
#2806: FILE: tools/virtiofsd/fuse_lowlevel.c:2784:
+^Iif (res < sizeof(struct fuse_in_header)) {$
ERROR: code indent should never use tabs
#2807: FILE: tools/virtiofsd/fuse_lowlevel.c:2785:
+^I^Ifuse_log(FUSE_LOG_ERR, "short splice from fuse device\n");$
ERROR: code indent should never use tabs
#2808: FILE: tools/virtiofsd/fuse_lowlevel.c:2786:
+^I^Ireturn -EIO;$
ERROR: code indent should never use tabs
#2809: FILE: tools/virtiofsd/fuse_lowlevel.c:2787:
+^I}$
ERROR: code indent should never use tabs
#2811: FILE: tools/virtiofsd/fuse_lowlevel.c:2789:
+^Itmpbuf = (struct fuse_buf) {$
ERROR: code indent should never use tabs
#2812: FILE: tools/virtiofsd/fuse_lowlevel.c:2790:
+^I^I.size = res,$
ERROR: code indent should never use tabs
#2813: FILE: tools/virtiofsd/fuse_lowlevel.c:2791:
+^I^I.flags = FUSE_BUF_IS_FD,$
ERROR: code indent should never use tabs
#2814: FILE: tools/virtiofsd/fuse_lowlevel.c:2792:
+^I^I.fd = llp->pipe[0],$
ERROR: code indent should never use tabs
#2815: FILE: tools/virtiofsd/fuse_lowlevel.c:2793:
+^I};$
ERROR: code indent should never use tabs
#2817: FILE: tools/virtiofsd/fuse_lowlevel.c:2795:
+^I/*$
ERROR: code indent should never use tabs
#2818: FILE: tools/virtiofsd/fuse_lowlevel.c:2796:
+^I * Don't bother with zero copy for small requests.$
ERROR: code indent should never use tabs
#2819: FILE: tools/virtiofsd/fuse_lowlevel.c:2797:
+^I * fuse_loop_mt() needs to check for FORGET so this more than$
ERROR: code indent should never use tabs
#2820: FILE: tools/virtiofsd/fuse_lowlevel.c:2798:
+^I * just an optimization.$
ERROR: code indent should never use tabs
#2821: FILE: tools/virtiofsd/fuse_lowlevel.c:2799:
+^I */$
ERROR: code indent should never use tabs
#2822: FILE: tools/virtiofsd/fuse_lowlevel.c:2800:
+^Iif (res < sizeof(struct fuse_in_header) +$
ERROR: code indent should never use tabs
#2823: FILE: tools/virtiofsd/fuse_lowlevel.c:2801:
+^I sizeof(struct fuse_write_in) + pagesize) {$
ERROR: code indent should never use tabs
#2824: FILE: tools/virtiofsd/fuse_lowlevel.c:2802:
+^I^Istruct fuse_bufvec src = { .buf[0] = tmpbuf, .count = 1 };$
ERROR: code indent should never use tabs
#2825: FILE: tools/virtiofsd/fuse_lowlevel.c:2803:
+^I^Istruct fuse_bufvec dst = { .count = 1 };$
ERROR: code indent should never use tabs
#2827: FILE: tools/virtiofsd/fuse_lowlevel.c:2805:
+^I^Iif (!buf->mem) {$
ERROR: code indent should never use tabs
#2828: FILE: tools/virtiofsd/fuse_lowlevel.c:2806:
+^I^I^Ibuf->mem = malloc(se->bufsize);$
ERROR: code indent should never use tabs
#2829: FILE: tools/virtiofsd/fuse_lowlevel.c:2807:
+^I^I^Iif (!buf->mem) {$
ERROR: code indent should never use tabs
#2830: FILE: tools/virtiofsd/fuse_lowlevel.c:2808:
+^I^I^I^Ifuse_log(FUSE_LOG_ERR,$
ERROR: code indent should never use tabs
#2831: FILE: tools/virtiofsd/fuse_lowlevel.c:2809:
+^I^I^I^I^I"fuse: failed to allocate read buffer\n");$
ERROR: code indent should never use tabs
#2832: FILE: tools/virtiofsd/fuse_lowlevel.c:2810:
+^I^I^I^Ireturn -ENOMEM;$
ERROR: code indent should never use tabs
#2833: FILE: tools/virtiofsd/fuse_lowlevel.c:2811:
+^I^I^I}$
ERROR: code indent should never use tabs
#2834: FILE: tools/virtiofsd/fuse_lowlevel.c:2812:
+^I^I}$
ERROR: code indent should never use tabs
#2835: FILE: tools/virtiofsd/fuse_lowlevel.c:2813:
+^I^Ibuf->size = se->bufsize;$
ERROR: code indent should never use tabs
#2836: FILE: tools/virtiofsd/fuse_lowlevel.c:2814:
+^I^Ibuf->flags = 0;$
ERROR: code indent should never use tabs
#2837: FILE: tools/virtiofsd/fuse_lowlevel.c:2815:
+^I^Idst.buf[0] = *buf;$
ERROR: code indent should never use tabs
#2839: FILE: tools/virtiofsd/fuse_lowlevel.c:2817:
+^I^Ires = fuse_buf_copy(&dst, &src, 0);$
ERROR: code indent should never use tabs
#2840: FILE: tools/virtiofsd/fuse_lowlevel.c:2818:
+^I^Iif (res < 0) {$
ERROR: code indent should never use tabs
#2841: FILE: tools/virtiofsd/fuse_lowlevel.c:2819:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: %s\n",$
ERROR: code indent should never use tabs
#2842: FILE: tools/virtiofsd/fuse_lowlevel.c:2820:
+^I^I^I^Istrerror(-res));$
ERROR: code indent should never use tabs
#2843: FILE: tools/virtiofsd/fuse_lowlevel.c:2821:
+^I^I^Ifuse_ll_clear_pipe(se);$
ERROR: code indent should never use tabs
#2844: FILE: tools/virtiofsd/fuse_lowlevel.c:2822:
+^I^I^Ireturn res;$
ERROR: code indent should never use tabs
#2845: FILE: tools/virtiofsd/fuse_lowlevel.c:2823:
+^I^I}$
ERROR: code indent should never use tabs
#2846: FILE: tools/virtiofsd/fuse_lowlevel.c:2824:
+^I^Iif (res < tmpbuf.size) {$
WARNING: line over 80 characters
#2847: FILE: tools/virtiofsd/fuse_lowlevel.c:2825:
+ fuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: short read\n");
ERROR: code indent should never use tabs
#2847: FILE: tools/virtiofsd/fuse_lowlevel.c:2825:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "fuse: copy from pipe: short read\n");$
ERROR: code indent should never use tabs
#2848: FILE: tools/virtiofsd/fuse_lowlevel.c:2826:
+^I^I^Ifuse_ll_clear_pipe(se);$
ERROR: code indent should never use tabs
#2849: FILE: tools/virtiofsd/fuse_lowlevel.c:2827:
+^I^I^Ireturn -EIO;$
ERROR: code indent should never use tabs
#2850: FILE: tools/virtiofsd/fuse_lowlevel.c:2828:
+^I^I}$
ERROR: code indent should never use tabs
#2851: FILE: tools/virtiofsd/fuse_lowlevel.c:2829:
+^I^Iassert(res == tmpbuf.size);$
ERROR: code indent should never use tabs
#2853: FILE: tools/virtiofsd/fuse_lowlevel.c:2831:
+^I} else {$
ERROR: code indent should never use tabs
#2854: FILE: tools/virtiofsd/fuse_lowlevel.c:2832:
+^I^I/* Don't overwrite buf->mem, as that would cause a leak */$
ERROR: code indent should never use tabs
#2855: FILE: tools/virtiofsd/fuse_lowlevel.c:2833:
+^I^Ibuf->fd = tmpbuf.fd;$
ERROR: code indent should never use tabs
#2856: FILE: tools/virtiofsd/fuse_lowlevel.c:2834:
+^I^Ibuf->flags = tmpbuf.flags;$
ERROR: code indent should never use tabs
#2857: FILE: tools/virtiofsd/fuse_lowlevel.c:2835:
+^I}$
ERROR: code indent should never use tabs
#2858: FILE: tools/virtiofsd/fuse_lowlevel.c:2836:
+^Ibuf->size = tmpbuf.size;$
ERROR: code indent should never use tabs
#2860: FILE: tools/virtiofsd/fuse_lowlevel.c:2838:
+^Ireturn res;$
ERROR: code indent should never use tabs
#2864: FILE: tools/virtiofsd/fuse_lowlevel.c:2842:
+^Iif (!buf->mem) {$
ERROR: code indent should never use tabs
#2865: FILE: tools/virtiofsd/fuse_lowlevel.c:2843:
+^I^Ibuf->mem = malloc(se->bufsize);$
ERROR: code indent should never use tabs
#2866: FILE: tools/virtiofsd/fuse_lowlevel.c:2844:
+^I^Iif (!buf->mem) {$
ERROR: code indent should never use tabs
#2867: FILE: tools/virtiofsd/fuse_lowlevel.c:2845:
+^I^I^Ifuse_log(FUSE_LOG_ERR,$
ERROR: code indent should never use tabs
#2868: FILE: tools/virtiofsd/fuse_lowlevel.c:2846:
+^I^I^I^I"fuse: failed to allocate read buffer\n");$
ERROR: code indent should never use tabs
#2869: FILE: tools/virtiofsd/fuse_lowlevel.c:2847:
+^I^I^Ireturn -ENOMEM;$
ERROR: code indent should never use tabs
#2870: FILE: tools/virtiofsd/fuse_lowlevel.c:2848:
+^I^I}$
ERROR: code indent should never use tabs
#2871: FILE: tools/virtiofsd/fuse_lowlevel.c:2849:
+^I}$
ERROR: code indent should never use tabs
#2874: FILE: tools/virtiofsd/fuse_lowlevel.c:2852:
+^Ires = read(ch ? ch->fd : se->fd, buf->mem, se->bufsize);$
ERROR: code indent should never use tabs
#2875: FILE: tools/virtiofsd/fuse_lowlevel.c:2853:
+^Ierr = errno;$
ERROR: code indent should never use tabs
#2877: FILE: tools/virtiofsd/fuse_lowlevel.c:2855:
+^Iif (fuse_session_exited(se))$
ERROR: braces {} are necessary for all arms of this statement
#2877: FILE: tools/virtiofsd/fuse_lowlevel.c:2855:
+ if (fuse_session_exited(se))
[...]
ERROR: code indent should never use tabs
#2878: FILE: tools/virtiofsd/fuse_lowlevel.c:2856:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#2879: FILE: tools/virtiofsd/fuse_lowlevel.c:2857:
+^Iif (res == -1) {$
ERROR: code indent should never use tabs
#2880: FILE: tools/virtiofsd/fuse_lowlevel.c:2858:
+^I^I/* ENOENT means the operation was interrupted, it's safe$
WARNING: Block comments use a leading /* on a separate line
#2880: FILE: tools/virtiofsd/fuse_lowlevel.c:2858:
+ /* ENOENT means the operation was interrupted, it's safe
ERROR: code indent should never use tabs
#2881: FILE: tools/virtiofsd/fuse_lowlevel.c:2859:
+^I^I to restart */$
WARNING: Block comments use * on subsequent lines
#2881: FILE: tools/virtiofsd/fuse_lowlevel.c:2859:
+ /* ENOENT means the operation was interrupted, it's safe
+ to restart */
WARNING: Block comments use a trailing */ on a separate line
#2881: FILE: tools/virtiofsd/fuse_lowlevel.c:2859:
+ to restart */
ERROR: code indent should never use tabs
#2882: FILE: tools/virtiofsd/fuse_lowlevel.c:2860:
+^I^Iif (err == ENOENT)$
ERROR: braces {} are necessary for all arms of this statement
#2882: FILE: tools/virtiofsd/fuse_lowlevel.c:2860:
+ if (err == ENOENT)
[...]
ERROR: code indent should never use tabs
#2883: FILE: tools/virtiofsd/fuse_lowlevel.c:2861:
+^I^I^Igoto restart;$
ERROR: code indent should never use tabs
#2885: FILE: tools/virtiofsd/fuse_lowlevel.c:2863:
+^I^Iif (err == ENODEV) {$
ERROR: code indent should never use tabs
#2886: FILE: tools/virtiofsd/fuse_lowlevel.c:2864:
+^I^I^I/* Filesystem was unmounted, or connection was aborted$
WARNING: Block comments use a leading /* on a separate line
#2886: FILE: tools/virtiofsd/fuse_lowlevel.c:2864:
+ /* Filesystem was unmounted, or connection was aborted
ERROR: code indent should never use tabs
#2887: FILE: tools/virtiofsd/fuse_lowlevel.c:2865:
+^I^I^I via /sys/fs/fuse/connections */$
WARNING: Block comments use * on subsequent lines
#2887: FILE: tools/virtiofsd/fuse_lowlevel.c:2865:
+ /* Filesystem was unmounted, or connection was aborted
+ via /sys/fs/fuse/connections */
WARNING: Block comments use a trailing */ on a separate line
#2887: FILE: tools/virtiofsd/fuse_lowlevel.c:2865:
+ via /sys/fs/fuse/connections */
ERROR: code indent should never use tabs
#2888: FILE: tools/virtiofsd/fuse_lowlevel.c:2866:
+^I^I^Ifuse_session_exit(se);$
ERROR: code indent should never use tabs
#2889: FILE: tools/virtiofsd/fuse_lowlevel.c:2867:
+^I^I^Ireturn 0;$
ERROR: code indent should never use tabs
#2890: FILE: tools/virtiofsd/fuse_lowlevel.c:2868:
+^I^I}$
ERROR: code indent should never use tabs
#2891: FILE: tools/virtiofsd/fuse_lowlevel.c:2869:
+^I^I/* Errors occurring during normal operation: EINTR (read$
WARNING: Block comments use a leading /* on a separate line
#2891: FILE: tools/virtiofsd/fuse_lowlevel.c:2869:
+ /* Errors occurring during normal operation: EINTR (read
ERROR: code indent should never use tabs
#2892: FILE: tools/virtiofsd/fuse_lowlevel.c:2870:
+^I^I interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem$
WARNING: Block comments use * on subsequent lines
#2892: FILE: tools/virtiofsd/fuse_lowlevel.c:2870:
+ /* Errors occurring during normal operation: EINTR (read
+ interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem
ERROR: code indent should never use tabs
#2893: FILE: tools/virtiofsd/fuse_lowlevel.c:2871:
+^I^I umounted) */$
WARNING: Block comments use a trailing */ on a separate line
#2893: FILE: tools/virtiofsd/fuse_lowlevel.c:2871:
+ umounted) */
ERROR: code indent should never use tabs
#2894: FILE: tools/virtiofsd/fuse_lowlevel.c:2872:
+^I^Iif (err != EINTR && err != EAGAIN)$
ERROR: braces {} are necessary for all arms of this statement
#2894: FILE: tools/virtiofsd/fuse_lowlevel.c:2872:
+ if (err != EINTR && err != EAGAIN)
[...]
ERROR: code indent should never use tabs
#2895: FILE: tools/virtiofsd/fuse_lowlevel.c:2873:
+^I^I^Iperror("fuse: reading device");$
ERROR: code indent should never use tabs
#2896: FILE: tools/virtiofsd/fuse_lowlevel.c:2874:
+^I^Ireturn -err;$
ERROR: code indent should never use tabs
#2897: FILE: tools/virtiofsd/fuse_lowlevel.c:2875:
+^I}$
ERROR: code indent should never use tabs
#2898: FILE: tools/virtiofsd/fuse_lowlevel.c:2876:
+^Iif ((size_t) res < sizeof(struct fuse_in_header)) {$
ERROR: code indent should never use tabs
#2899: FILE: tools/virtiofsd/fuse_lowlevel.c:2877:
+^I^Ifuse_log(FUSE_LOG_ERR, "short read on fuse device\n");$
ERROR: code indent should never use tabs
#2900: FILE: tools/virtiofsd/fuse_lowlevel.c:2878:
+^I^Ireturn -EIO;$
ERROR: code indent should never use tabs
#2901: FILE: tools/virtiofsd/fuse_lowlevel.c:2879:
+^I}$
ERROR: code indent should never use tabs
#2903: FILE: tools/virtiofsd/fuse_lowlevel.c:2881:
+^Ibuf->size = res;$
ERROR: code indent should never use tabs
#2905: FILE: tools/virtiofsd/fuse_lowlevel.c:2883:
+^Ireturn res;$
ERROR: code indent should never use tabs
#2909: FILE: tools/virtiofsd/fuse_lowlevel.c:2887:
+^I^I^I^I const struct fuse_lowlevel_ops *op,$
ERROR: code indent should never use tabs
#2910: FILE: tools/virtiofsd/fuse_lowlevel.c:2888:
+^I^I^I^I size_t op_size, void *userdata)$
ERROR: code indent should never use tabs
#2912: FILE: tools/virtiofsd/fuse_lowlevel.c:2890:
+^Iint err;$
ERROR: code indent should never use tabs
#2913: FILE: tools/virtiofsd/fuse_lowlevel.c:2891:
+^Istruct fuse_session *se;$
ERROR: code indent should never use tabs
#2914: FILE: tools/virtiofsd/fuse_lowlevel.c:2892:
+^Istruct mount_opts *mo;$
ERROR: code indent should never use tabs
#2916: FILE: tools/virtiofsd/fuse_lowlevel.c:2894:
+^Iif (sizeof(struct fuse_lowlevel_ops) < op_size) {$
ERROR: line over 90 characters
#2917: FILE: tools/virtiofsd/fuse_lowlevel.c:2895:
+ fuse_log(FUSE_LOG_ERR, "fuse: warning: library too old, some operations may not work\n");
ERROR: code indent should never use tabs
#2917: FILE: tools/virtiofsd/fuse_lowlevel.c:2895:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: warning: library too old, some operations may not work\n");$
ERROR: code indent should never use tabs
#2918: FILE: tools/virtiofsd/fuse_lowlevel.c:2896:
+^I^Iop_size = sizeof(struct fuse_lowlevel_ops);$
ERROR: code indent should never use tabs
#2919: FILE: tools/virtiofsd/fuse_lowlevel.c:2897:
+^I}$
ERROR: code indent should never use tabs
#2921: FILE: tools/virtiofsd/fuse_lowlevel.c:2899:
+^Iif (args->argc == 0) {$
ERROR: line over 90 characters
#2922: FILE: tools/virtiofsd/fuse_lowlevel.c:2900:
+ fuse_log(FUSE_LOG_ERR, "fuse: empty argv passed to fuse_session_new().\n");
ERROR: code indent should never use tabs
#2922: FILE: tools/virtiofsd/fuse_lowlevel.c:2900:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: empty argv passed to fuse_session_new().\n");$
ERROR: code indent should never use tabs
#2923: FILE: tools/virtiofsd/fuse_lowlevel.c:2901:
+^I^Ireturn NULL;$
ERROR: code indent should never use tabs
#2924: FILE: tools/virtiofsd/fuse_lowlevel.c:2902:
+^I}$
ERROR: code indent should never use tabs
#2926: FILE: tools/virtiofsd/fuse_lowlevel.c:2904:
+^Ise = (struct fuse_session *) calloc(1, sizeof(struct fuse_session));$
ERROR: code indent should never use tabs
#2927: FILE: tools/virtiofsd/fuse_lowlevel.c:2905:
+^Iif (se == NULL) {$
WARNING: line over 80 characters
#2928: FILE: tools/virtiofsd/fuse_lowlevel.c:2906:
+ fuse_log(FUSE_LOG_ERR, "fuse: failed to allocate fuse object\n");
ERROR: code indent should never use tabs
#2928: FILE: tools/virtiofsd/fuse_lowlevel.c:2906:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: failed to allocate fuse object\n");$
ERROR: code indent should never use tabs
#2929: FILE: tools/virtiofsd/fuse_lowlevel.c:2907:
+^I^Igoto out1;$
ERROR: code indent should never use tabs
#2930: FILE: tools/virtiofsd/fuse_lowlevel.c:2908:
+^I}$
ERROR: code indent should never use tabs
#2931: FILE: tools/virtiofsd/fuse_lowlevel.c:2909:
+^Ise->fd = -1;$
ERROR: code indent should never use tabs
#2932: FILE: tools/virtiofsd/fuse_lowlevel.c:2910:
+^Ise->conn.max_write = UINT_MAX;$
ERROR: code indent should never use tabs
#2933: FILE: tools/virtiofsd/fuse_lowlevel.c:2911:
+^Ise->conn.max_readahead = UINT_MAX;$
ERROR: code indent should never use tabs
#2935: FILE: tools/virtiofsd/fuse_lowlevel.c:2913:
+^I/* Parse options */$
ERROR: code indent should never use tabs
#2936: FILE: tools/virtiofsd/fuse_lowlevel.c:2914:
+^Iif(fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1)$
ERROR: space required before the open parenthesis '('
#2936: FILE: tools/virtiofsd/fuse_lowlevel.c:2914:
+ if(fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1)
ERROR: braces {} are necessary for all arms of this statement
#2936: FILE: tools/virtiofsd/fuse_lowlevel.c:2914:
+ if(fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1)
[...]
ERROR: code indent should never use tabs
#2937: FILE: tools/virtiofsd/fuse_lowlevel.c:2915:
+^I^Igoto out2;$
ERROR: code indent should never use tabs
#2938: FILE: tools/virtiofsd/fuse_lowlevel.c:2916:
+^Iif(se->deny_others) {$
ERROR: space required before the open parenthesis '('
#2938: FILE: tools/virtiofsd/fuse_lowlevel.c:2916:
+ if(se->deny_others) {
ERROR: code indent should never use tabs
#2939: FILE: tools/virtiofsd/fuse_lowlevel.c:2917:
+^I^I/* Allowing access only by root is done by instructing$
WARNING: Block comments use a leading /* on a separate line
#2939: FILE: tools/virtiofsd/fuse_lowlevel.c:2917:
+ /* Allowing access only by root is done by instructing
ERROR: code indent should never use tabs
#2940: FILE: tools/virtiofsd/fuse_lowlevel.c:2918:
+^I^I * kernel to allow access by everyone, and then restricting$
ERROR: code indent should never use tabs
#2941: FILE: tools/virtiofsd/fuse_lowlevel.c:2919:
+^I^I * access to root and mountpoint owner in libfuse.$
ERROR: code indent should never use tabs
#2942: FILE: tools/virtiofsd/fuse_lowlevel.c:2920:
+^I^I */$
ERROR: code indent should never use tabs
#2943: FILE: tools/virtiofsd/fuse_lowlevel.c:2921:
+^I^I// We may be adding the option a second time, but$
ERROR: do not use C99 // comments
#2943: FILE: tools/virtiofsd/fuse_lowlevel.c:2921:
+ // We may be adding the option a second time, but
ERROR: code indent should never use tabs
#2944: FILE: tools/virtiofsd/fuse_lowlevel.c:2922:
+^I^I// that doesn't hurt.$
ERROR: do not use C99 // comments
#2944: FILE: tools/virtiofsd/fuse_lowlevel.c:2922:
+ // that doesn't hurt.
ERROR: code indent should never use tabs
#2945: FILE: tools/virtiofsd/fuse_lowlevel.c:2923:
+^I^Iif(fuse_opt_add_arg(args, "-oallow_other") == -1)$
ERROR: space required before the open parenthesis '('
#2945: FILE: tools/virtiofsd/fuse_lowlevel.c:2923:
+ if(fuse_opt_add_arg(args, "-oallow_other") == -1)
ERROR: braces {} are necessary for all arms of this statement
#2945: FILE: tools/virtiofsd/fuse_lowlevel.c:2923:
+ if(fuse_opt_add_arg(args, "-oallow_other") == -1)
[...]
ERROR: code indent should never use tabs
#2946: FILE: tools/virtiofsd/fuse_lowlevel.c:2924:
+^I^I^Igoto out2;$
ERROR: code indent should never use tabs
#2947: FILE: tools/virtiofsd/fuse_lowlevel.c:2925:
+^I}$
ERROR: code indent should never use tabs
#2948: FILE: tools/virtiofsd/fuse_lowlevel.c:2926:
+^Imo = parse_mount_opts(args);$
ERROR: code indent should never use tabs
#2949: FILE: tools/virtiofsd/fuse_lowlevel.c:2927:
+^Iif (mo == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#2949: FILE: tools/virtiofsd/fuse_lowlevel.c:2927:
+ if (mo == NULL)
[...]
ERROR: code indent should never use tabs
#2950: FILE: tools/virtiofsd/fuse_lowlevel.c:2928:
+^I^Igoto out3;$
ERROR: code indent should never use tabs
#2952: FILE: tools/virtiofsd/fuse_lowlevel.c:2930:
+^Iif(args->argc == 1 &&$
ERROR: space required before the open parenthesis '('
#2952: FILE: tools/virtiofsd/fuse_lowlevel.c:2930:
+ if(args->argc == 1 &&
ERROR: code indent should never use tabs
#2953: FILE: tools/virtiofsd/fuse_lowlevel.c:2931:
+^I args->argv[0][0] == '-') {$
WARNING: line over 80 characters
#2954: FILE: tools/virtiofsd/fuse_lowlevel.c:2932:
+ fuse_log(FUSE_LOG_ERR, "fuse: warning: argv[0] looks like an option, but "
ERROR: code indent should never use tabs
#2954: FILE: tools/virtiofsd/fuse_lowlevel.c:2932:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: warning: argv[0] looks like an option, but "$
ERROR: code indent should never use tabs
#2955: FILE: tools/virtiofsd/fuse_lowlevel.c:2933:
+^I^I^I"will be ignored\n");$
ERROR: code indent should never use tabs
#2956: FILE: tools/virtiofsd/fuse_lowlevel.c:2934:
+^I} else if (args->argc != 1) {$
ERROR: code indent should never use tabs
#2957: FILE: tools/virtiofsd/fuse_lowlevel.c:2935:
+^I^Iint i;$
ERROR: code indent should never use tabs
#2958: FILE: tools/virtiofsd/fuse_lowlevel.c:2936:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: unknown option(s): `");$
ERROR: code indent should never use tabs
#2959: FILE: tools/virtiofsd/fuse_lowlevel.c:2937:
+^I^Ifor(i = 1; i < args->argc-1; i++)$
ERROR: spaces required around that '-' (ctx:VxV)
#2959: FILE: tools/virtiofsd/fuse_lowlevel.c:2937:
+ for(i = 1; i < args->argc-1; i++)
^
ERROR: space required before the open parenthesis '('
#2959: FILE: tools/virtiofsd/fuse_lowlevel.c:2937:
+ for(i = 1; i < args->argc-1; i++)
ERROR: braces {} are necessary for all arms of this statement
#2959: FILE: tools/virtiofsd/fuse_lowlevel.c:2937:
+ for(i = 1; i < args->argc-1; i++)
[...]
ERROR: code indent should never use tabs
#2960: FILE: tools/virtiofsd/fuse_lowlevel.c:2938:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "%s ", args->argv[i]);$
ERROR: code indent should never use tabs
#2961: FILE: tools/virtiofsd/fuse_lowlevel.c:2939:
+^I^Ifuse_log(FUSE_LOG_ERR, "%s'\n", args->argv[i]);$
ERROR: code indent should never use tabs
#2962: FILE: tools/virtiofsd/fuse_lowlevel.c:2940:
+^I^Igoto out4;$
ERROR: code indent should never use tabs
#2963: FILE: tools/virtiofsd/fuse_lowlevel.c:2941:
+^I}$
ERROR: code indent should never use tabs
#2965: FILE: tools/virtiofsd/fuse_lowlevel.c:2943:
+^Iif (se->debug)$
ERROR: braces {} are necessary for all arms of this statement
#2965: FILE: tools/virtiofsd/fuse_lowlevel.c:2943:
+ if (se->debug)
[...]
WARNING: line over 80 characters
#2966: FILE: tools/virtiofsd/fuse_lowlevel.c:2944:
+ fuse_log(FUSE_LOG_DEBUG, "FUSE library version: %s\n", PACKAGE_VERSION);
ERROR: code indent should never use tabs
#2966: FILE: tools/virtiofsd/fuse_lowlevel.c:2944:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "FUSE library version: %s\n", PACKAGE_VERSION);$
ERROR: code indent should never use tabs
#2968: FILE: tools/virtiofsd/fuse_lowlevel.c:2946:
+^Ise->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() +$
ERROR: use qemu_real_host_page_size instead of getpagesize()
#2968: FILE: tools/virtiofsd/fuse_lowlevel.c:2946:
+ se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() +
ERROR: code indent should never use tabs
#2969: FILE: tools/virtiofsd/fuse_lowlevel.c:2947:
+^I^IFUSE_BUFFER_HEADER_SIZE;$
ERROR: code indent should never use tabs
#2971: FILE: tools/virtiofsd/fuse_lowlevel.c:2949:
+^Ilist_init_req(&se->list);$
ERROR: code indent should never use tabs
#2972: FILE: tools/virtiofsd/fuse_lowlevel.c:2950:
+^Ilist_init_req(&se->interrupts);$
ERROR: code indent should never use tabs
#2973: FILE: tools/virtiofsd/fuse_lowlevel.c:2951:
+^Ilist_init_nreq(&se->notify_list);$
ERROR: code indent should never use tabs
#2974: FILE: tools/virtiofsd/fuse_lowlevel.c:2952:
+^Ise->notify_ctr = 1;$
ERROR: code indent should never use tabs
#2975: FILE: tools/virtiofsd/fuse_lowlevel.c:2953:
+^Ifuse_mutex_init(&se->lock);$
ERROR: code indent should never use tabs
#2977: FILE: tools/virtiofsd/fuse_lowlevel.c:2955:
+^Ierr = pthread_key_create(&se->pipe_key, fuse_ll_pipe_destructor);$
ERROR: code indent should never use tabs
#2978: FILE: tools/virtiofsd/fuse_lowlevel.c:2956:
+^Iif (err) {$
WARNING: line over 80 characters
#2979: FILE: tools/virtiofsd/fuse_lowlevel.c:2957:
+ fuse_log(FUSE_LOG_ERR, "fuse: failed to create thread specific key: %s\n",
ERROR: code indent should never use tabs
#2979: FILE: tools/virtiofsd/fuse_lowlevel.c:2957:
+^I^Ifuse_log(FUSE_LOG_ERR, "fuse: failed to create thread specific key: %s\n",$
ERROR: code indent should never use tabs
#2980: FILE: tools/virtiofsd/fuse_lowlevel.c:2958:
+^I^I^Istrerror(err));$
ERROR: code indent should never use tabs
#2981: FILE: tools/virtiofsd/fuse_lowlevel.c:2959:
+^I^Igoto out5;$
ERROR: code indent should never use tabs
#2982: FILE: tools/virtiofsd/fuse_lowlevel.c:2960:
+^I}$
ERROR: code indent should never use tabs
#2984: FILE: tools/virtiofsd/fuse_lowlevel.c:2962:
+^Imemcpy(&se->op, op, op_size);$
ERROR: code indent should never use tabs
#2985: FILE: tools/virtiofsd/fuse_lowlevel.c:2963:
+^Ise->owner = getuid();$
ERROR: code indent should never use tabs
#2986: FILE: tools/virtiofsd/fuse_lowlevel.c:2964:
+^Ise->userdata = userdata;$
ERROR: code indent should never use tabs
#2988: FILE: tools/virtiofsd/fuse_lowlevel.c:2966:
+^Ise->mo = mo;$
ERROR: code indent should never use tabs
#2989: FILE: tools/virtiofsd/fuse_lowlevel.c:2967:
+^Ireturn se;$
ERROR: code indent should never use tabs
#2992: FILE: tools/virtiofsd/fuse_lowlevel.c:2970:
+^Ipthread_mutex_destroy(&se->lock);$
ERROR: code indent should never use tabs
#2994: FILE: tools/virtiofsd/fuse_lowlevel.c:2972:
+^Ifuse_opt_free_args(args);$
ERROR: code indent should never use tabs
#2996: FILE: tools/virtiofsd/fuse_lowlevel.c:2974:
+^Ifree(mo);$
ERROR: code indent should never use tabs
#2998: FILE: tools/virtiofsd/fuse_lowlevel.c:2976:
+^Ifree(se);$
ERROR: code indent should never use tabs
#3000: FILE: tools/virtiofsd/fuse_lowlevel.c:2978:
+^Ireturn NULL;$
ERROR: code indent should never use tabs
#3005: FILE: tools/virtiofsd/fuse_lowlevel.c:2983:
+^Iint fd;$
ERROR: code indent should never use tabs
#3007: FILE: tools/virtiofsd/fuse_lowlevel.c:2985:
+^I/*$
ERROR: code indent should never use tabs
#3008: FILE: tools/virtiofsd/fuse_lowlevel.c:2986:
+^I * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos$
ERROR: code indent should never use tabs
#3009: FILE: tools/virtiofsd/fuse_lowlevel.c:2987:
+^I * would ensue.$
ERROR: code indent should never use tabs
#3010: FILE: tools/virtiofsd/fuse_lowlevel.c:2988:
+^I */$
ERROR: code indent should never use tabs
#3011: FILE: tools/virtiofsd/fuse_lowlevel.c:2989:
+^Ido {$
ERROR: code indent should never use tabs
#3012: FILE: tools/virtiofsd/fuse_lowlevel.c:2990:
+^I^Ifd = open("/dev/null", O_RDWR);$
ERROR: code indent should never use tabs
#3013: FILE: tools/virtiofsd/fuse_lowlevel.c:2991:
+^I^Iif (fd > 2)$
ERROR: braces {} are necessary for all arms of this statement
#3013: FILE: tools/virtiofsd/fuse_lowlevel.c:2991:
+ if (fd > 2)
[...]
ERROR: code indent should never use tabs
#3014: FILE: tools/virtiofsd/fuse_lowlevel.c:2992:
+^I^I^Iclose(fd);$
ERROR: code indent should never use tabs
#3015: FILE: tools/virtiofsd/fuse_lowlevel.c:2993:
+^I} while (fd >= 0 && fd <= 2);$
ERROR: code indent should never use tabs
#3017: FILE: tools/virtiofsd/fuse_lowlevel.c:2995:
+^I/*$
ERROR: code indent should never use tabs
#3018: FILE: tools/virtiofsd/fuse_lowlevel.c:2996:
+^I * To allow FUSE daemons to run without privileges, the caller may open$
ERROR: code indent should never use tabs
#3019: FILE: tools/virtiofsd/fuse_lowlevel.c:2997:
+^I * /dev/fuse before launching the file system and pass on the file$
ERROR: code indent should never use tabs
#3020: FILE: tools/virtiofsd/fuse_lowlevel.c:2998:
+^I * descriptor by specifying /dev/fd/N as the mount point. Note that the$
ERROR: code indent should never use tabs
#3021: FILE: tools/virtiofsd/fuse_lowlevel.c:2999:
+^I * parent process takes care of performing the mount in this case.$
ERROR: code indent should never use tabs
#3022: FILE: tools/virtiofsd/fuse_lowlevel.c:3000:
+^I */$
ERROR: code indent should never use tabs
#3023: FILE: tools/virtiofsd/fuse_lowlevel.c:3001:
+^Ifd = fuse_mnt_parse_fuse_fd(mountpoint);$
ERROR: code indent should never use tabs
#3024: FILE: tools/virtiofsd/fuse_lowlevel.c:3002:
+^Iif (fd != -1) {$
ERROR: code indent should never use tabs
#3025: FILE: tools/virtiofsd/fuse_lowlevel.c:3003:
+^I^Iif (fcntl(fd, F_GETFD) == -1) {$
ERROR: code indent should never use tabs
#3026: FILE: tools/virtiofsd/fuse_lowlevel.c:3004:
+^I^I^Ifuse_log(FUSE_LOG_ERR,$
ERROR: code indent should never use tabs
#3027: FILE: tools/virtiofsd/fuse_lowlevel.c:3005:
+^I^I^I^I"fuse: Invalid file descriptor /dev/fd/%u\n",$
ERROR: code indent should never use tabs
#3028: FILE: tools/virtiofsd/fuse_lowlevel.c:3006:
+^I^I^I^Ifd);$
ERROR: code indent should never use tabs
#3029: FILE: tools/virtiofsd/fuse_lowlevel.c:3007:
+^I^I^Ireturn -1;$
ERROR: code indent should never use tabs
#3030: FILE: tools/virtiofsd/fuse_lowlevel.c:3008:
+^I^I}$
ERROR: code indent should never use tabs
#3031: FILE: tools/virtiofsd/fuse_lowlevel.c:3009:
+^I^Ise->fd = fd;$
ERROR: code indent should never use tabs
#3032: FILE: tools/virtiofsd/fuse_lowlevel.c:3010:
+^I^Ireturn 0;$
ERROR: code indent should never use tabs
#3033: FILE: tools/virtiofsd/fuse_lowlevel.c:3011:
+^I}$
ERROR: code indent should never use tabs
#3035: FILE: tools/virtiofsd/fuse_lowlevel.c:3013:
+^I/* Open channel */$
ERROR: code indent should never use tabs
#3036: FILE: tools/virtiofsd/fuse_lowlevel.c:3014:
+^Ifd = fuse_kern_mount(mountpoint, se->mo);$
ERROR: code indent should never use tabs
#3037: FILE: tools/virtiofsd/fuse_lowlevel.c:3015:
+^Iif (fd == -1)$
ERROR: braces {} are necessary for all arms of this statement
#3037: FILE: tools/virtiofsd/fuse_lowlevel.c:3015:
+ if (fd == -1)
[...]
ERROR: code indent should never use tabs
#3038: FILE: tools/virtiofsd/fuse_lowlevel.c:3016:
+^I^Ireturn -1;$
ERROR: code indent should never use tabs
#3039: FILE: tools/virtiofsd/fuse_lowlevel.c:3017:
+^Ise->fd = fd;$
ERROR: code indent should never use tabs
#3041: FILE: tools/virtiofsd/fuse_lowlevel.c:3019:
+^I/* Save mountpoint */$
ERROR: code indent should never use tabs
#3042: FILE: tools/virtiofsd/fuse_lowlevel.c:3020:
+^Ise->mountpoint = strdup(mountpoint);$
ERROR: code indent should never use tabs
#3043: FILE: tools/virtiofsd/fuse_lowlevel.c:3021:
+^Iif (se->mountpoint == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#3043: FILE: tools/virtiofsd/fuse_lowlevel.c:3021:
+ if (se->mountpoint == NULL)
[...]
ERROR: code indent should never use tabs
#3044: FILE: tools/virtiofsd/fuse_lowlevel.c:3022:
+^I^Igoto error_out;$
ERROR: code indent should never use tabs
#3046: FILE: tools/virtiofsd/fuse_lowlevel.c:3024:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#3049: FILE: tools/virtiofsd/fuse_lowlevel.c:3027:
+^Ifuse_kern_unmount(mountpoint, fd);$
ERROR: code indent should never use tabs
#3050: FILE: tools/virtiofsd/fuse_lowlevel.c:3028:
+^Ireturn -1;$
ERROR: code indent should never use tabs
#3055: FILE: tools/virtiofsd/fuse_lowlevel.c:3033:
+^Ireturn se->fd;$
ERROR: code indent should never use tabs
#3060: FILE: tools/virtiofsd/fuse_lowlevel.c:3038:
+^Iif (se->mountpoint != NULL) {$
ERROR: code indent should never use tabs
#3061: FILE: tools/virtiofsd/fuse_lowlevel.c:3039:
+^I^Ifuse_kern_unmount(se->mountpoint, se->fd);$
ERROR: code indent should never use tabs
#3062: FILE: tools/virtiofsd/fuse_lowlevel.c:3040:
+^I^Ifree(se->mountpoint);$
ERROR: code indent should never use tabs
#3063: FILE: tools/virtiofsd/fuse_lowlevel.c:3041:
+^I^Ise->mountpoint = NULL;$
ERROR: code indent should never use tabs
#3064: FILE: tools/virtiofsd/fuse_lowlevel.c:3042:
+^I}$
ERROR: code indent should never use tabs
#3070: FILE: tools/virtiofsd/fuse_lowlevel.c:3048:
+^Ichar *buf;$
ERROR: code indent should never use tabs
#3071: FILE: tools/virtiofsd/fuse_lowlevel.c:3049:
+^Isize_t bufsize = 1024;$
ERROR: code indent should never use tabs
#3072: FILE: tools/virtiofsd/fuse_lowlevel.c:3050:
+^Ichar path[128];$
ERROR: code indent should never use tabs
#3073: FILE: tools/virtiofsd/fuse_lowlevel.c:3051:
+^Iint ret;$
ERROR: code indent should never use tabs
#3074: FILE: tools/virtiofsd/fuse_lowlevel.c:3052:
+^Iint fd;$
ERROR: code indent should never use tabs
#3075: FILE: tools/virtiofsd/fuse_lowlevel.c:3053:
+^Iunsigned long pid = req->ctx.pid;$
ERROR: code indent should never use tabs
#3076: FILE: tools/virtiofsd/fuse_lowlevel.c:3054:
+^Ichar *s;$
ERROR: code indent should never use tabs
#3078: FILE: tools/virtiofsd/fuse_lowlevel.c:3056:
+^Isprintf(path, "/proc/%lu/task/%lu/status", pid, pid);$
ERROR: code indent should never use tabs
#3081: FILE: tools/virtiofsd/fuse_lowlevel.c:3059:
+^Ibuf = malloc(bufsize);$
ERROR: code indent should never use tabs
#3082: FILE: tools/virtiofsd/fuse_lowlevel.c:3060:
+^Iif (buf == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#3082: FILE: tools/virtiofsd/fuse_lowlevel.c:3060:
+ if (buf == NULL)
[...]
ERROR: code indent should never use tabs
#3083: FILE: tools/virtiofsd/fuse_lowlevel.c:3061:
+^I^Ireturn -ENOMEM;$
ERROR: code indent should never use tabs
#3085: FILE: tools/virtiofsd/fuse_lowlevel.c:3063:
+^Iret = -EIO;$
ERROR: code indent should never use tabs
#3086: FILE: tools/virtiofsd/fuse_lowlevel.c:3064:
+^Ifd = open(path, O_RDONLY);$
ERROR: code indent should never use tabs
#3087: FILE: tools/virtiofsd/fuse_lowlevel.c:3065:
+^Iif (fd == -1)$
ERROR: braces {} are necessary for all arms of this statement
#3087: FILE: tools/virtiofsd/fuse_lowlevel.c:3065:
+ if (fd == -1)
[...]
ERROR: code indent should never use tabs
#3088: FILE: tools/virtiofsd/fuse_lowlevel.c:3066:
+^I^Igoto out_free;$
ERROR: code indent should never use tabs
#3090: FILE: tools/virtiofsd/fuse_lowlevel.c:3068:
+^Iret = read(fd, buf, bufsize);$
ERROR: code indent should never use tabs
#3091: FILE: tools/virtiofsd/fuse_lowlevel.c:3069:
+^Iclose(fd);$
ERROR: code indent should never use tabs
#3092: FILE: tools/virtiofsd/fuse_lowlevel.c:3070:
+^Iif (ret < 0) {$
ERROR: code indent should never use tabs
#3093: FILE: tools/virtiofsd/fuse_lowlevel.c:3071:
+^I^Iret = -EIO;$
ERROR: code indent should never use tabs
#3094: FILE: tools/virtiofsd/fuse_lowlevel.c:3072:
+^I^Igoto out_free;$
ERROR: code indent should never use tabs
#3095: FILE: tools/virtiofsd/fuse_lowlevel.c:3073:
+^I}$
ERROR: code indent should never use tabs
#3097: FILE: tools/virtiofsd/fuse_lowlevel.c:3075:
+^Iif ((size_t)ret == bufsize) {$
ERROR: code indent should never use tabs
#3098: FILE: tools/virtiofsd/fuse_lowlevel.c:3076:
+^I^Ifree(buf);$
ERROR: code indent should never use tabs
#3099: FILE: tools/virtiofsd/fuse_lowlevel.c:3077:
+^I^Ibufsize *= 4;$
ERROR: code indent should never use tabs
#3100: FILE: tools/virtiofsd/fuse_lowlevel.c:3078:
+^I^Igoto retry;$
ERROR: code indent should never use tabs
#3101: FILE: tools/virtiofsd/fuse_lowlevel.c:3079:
+^I}$
ERROR: code indent should never use tabs
#3103: FILE: tools/virtiofsd/fuse_lowlevel.c:3081:
+^Iret = -EIO;$
ERROR: code indent should never use tabs
#3104: FILE: tools/virtiofsd/fuse_lowlevel.c:3082:
+^Is = strstr(buf, "\nGroups:");$
ERROR: code indent should never use tabs
#3105: FILE: tools/virtiofsd/fuse_lowlevel.c:3083:
+^Iif (s == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#3105: FILE: tools/virtiofsd/fuse_lowlevel.c:3083:
+ if (s == NULL)
[...]
ERROR: code indent should never use tabs
#3106: FILE: tools/virtiofsd/fuse_lowlevel.c:3084:
+^I^Igoto out_free;$
ERROR: code indent should never use tabs
#3108: FILE: tools/virtiofsd/fuse_lowlevel.c:3086:
+^Is += 8;$
ERROR: code indent should never use tabs
#3109: FILE: tools/virtiofsd/fuse_lowlevel.c:3087:
+^Iret = 0;$
ERROR: code indent should never use tabs
#3110: FILE: tools/virtiofsd/fuse_lowlevel.c:3088:
+^Iwhile (1) {$
ERROR: code indent should never use tabs
#3111: FILE: tools/virtiofsd/fuse_lowlevel.c:3089:
+^I^Ichar *end;$
ERROR: code indent should never use tabs
#3112: FILE: tools/virtiofsd/fuse_lowlevel.c:3090:
+^I^Iunsigned long val = strtoul(s, &end, 0);$
ERROR: consider using qemu_strtoul in preference to strtoul
#3112: FILE: tools/virtiofsd/fuse_lowlevel.c:3090:
+ unsigned long val = strtoul(s, &end, 0);
ERROR: code indent should never use tabs
#3113: FILE: tools/virtiofsd/fuse_lowlevel.c:3091:
+^I^Iif (end == s)$
ERROR: braces {} are necessary for all arms of this statement
#3113: FILE: tools/virtiofsd/fuse_lowlevel.c:3091:
+ if (end == s)
[...]
ERROR: code indent should never use tabs
#3114: FILE: tools/virtiofsd/fuse_lowlevel.c:3092:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#3116: FILE: tools/virtiofsd/fuse_lowlevel.c:3094:
+^I^Is = end;$
ERROR: code indent should never use tabs
#3117: FILE: tools/virtiofsd/fuse_lowlevel.c:3095:
+^I^Iif (ret < size)$
ERROR: braces {} are necessary for all arms of this statement
#3117: FILE: tools/virtiofsd/fuse_lowlevel.c:3095:
+ if (ret < size)
[...]
ERROR: code indent should never use tabs
#3118: FILE: tools/virtiofsd/fuse_lowlevel.c:3096:
+^I^I^Ilist[ret] = val;$
ERROR: code indent should never use tabs
#3119: FILE: tools/virtiofsd/fuse_lowlevel.c:3097:
+^I^Iret++;$
ERROR: code indent should never use tabs
#3120: FILE: tools/virtiofsd/fuse_lowlevel.c:3098:
+^I}$
ERROR: code indent should never use tabs
#3123: FILE: tools/virtiofsd/fuse_lowlevel.c:3101:
+^Ifree(buf);$
ERROR: code indent should never use tabs
#3124: FILE: tools/virtiofsd/fuse_lowlevel.c:3102:
+^Ireturn ret;$
ERROR: code indent should never use tabs
#3132: FILE: tools/virtiofsd/fuse_lowlevel.c:3110:
+^I(void) req; (void) size; (void) list;$
ERROR: code indent should never use tabs
#3133: FILE: tools/virtiofsd/fuse_lowlevel.c:3111:
+^Ireturn -ENOSYS;$
ERROR: code indent should never use tabs
#3139: FILE: tools/virtiofsd/fuse_lowlevel.c:3117:
+^Ise->exited = 1;$
ERROR: code indent should never use tabs
#3144: FILE: tools/virtiofsd/fuse_lowlevel.c:3122:
+^Ise->exited = 0;$
ERROR: code indent should never use tabs
#3145: FILE: tools/virtiofsd/fuse_lowlevel.c:3123:
+^Ise->error = 0;$
ERROR: code indent should never use tabs
#3150: FILE: tools/virtiofsd/fuse_lowlevel.c:3128:
+^Ireturn se->exited;$
total: 2338 errors, 57 warnings, 3129 lines checked
Patch 4/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
5/108 Checking commit b0e96343f9cf (virtiofsd: Add passthrough_ll)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#23:
new file mode 100644
WARNING: Block comments use * on subsequent lines
#29: FILE: tools/virtiofsd/passthrough_ll.c:2:
+/*
+ FUSE: Filesystem in Userspace
WARNING: Block comments use a leading /* on a separate line
#36: FILE: tools/virtiofsd/passthrough_ll.c:9:
+/** @file
WARNING: line over 80 characters
#58: FILE: tools/virtiofsd/passthrough_ll.c:31:
+ * gcc -Wall passthrough_ll.c `pkg-config fuse3 --cflags --libs` -o passthrough_ll
WARNING: Block comments use a leading /* on a separate line
#87: FILE: tools/virtiofsd/passthrough_ll.c:60:
+/* We are re-using pointers to our `struct lo_inode` and `struct
WARNING: Block comments use * on subsequent lines
#88: FILE: tools/virtiofsd/passthrough_ll.c:61:
+/* We are re-using pointers to our `struct lo_inode` and `struct
+ lo_dirp` elements as inodes. This means that we must be able to
WARNING: Block comments use a trailing */ on a separate line
#90: FILE: tools/virtiofsd/passthrough_ll.c:63:
+ incantation checks this condition at compile time. */
ERROR: line over 90 characters
#91: FILE: tools/virtiofsd/passthrough_ll.c:64:
+#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
WARNING: architecture specific defines should be avoided
#91: FILE: tools/virtiofsd/passthrough_ll.c:64:
+#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
ERROR: code indent should never use tabs
#93: FILE: tools/virtiofsd/passthrough_ll.c:66:
+^I "fuse_ino_t too small to hold uintptr_t values!");$
ERROR: code indent should never use tabs
#96: FILE: tools/virtiofsd/passthrough_ll.c:69:
+^I{ unsigned _uintptr_to_must_hold_fuse_ino_t:$
ERROR: code indent should never use tabs
#97: FILE: tools/virtiofsd/passthrough_ll.c:70:
+^I^I^I((sizeof(fuse_ino_t) >= sizeof(uintptr_t)) ? 1 : -1); };$
ERROR: code indent should never use tabs
#101: FILE: tools/virtiofsd/passthrough_ll.c:74:
+^Istruct lo_inode *next; /* protected by lo->mutex */$
ERROR: code indent should never use tabs
#102: FILE: tools/virtiofsd/passthrough_ll.c:75:
+^Istruct lo_inode *prev; /* protected by lo->mutex */$
ERROR: code indent should never use tabs
#103: FILE: tools/virtiofsd/passthrough_ll.c:76:
+^Iint fd;$
ERROR: code indent should never use tabs
#104: FILE: tools/virtiofsd/passthrough_ll.c:77:
+^Ibool is_symlink;$
ERROR: code indent should never use tabs
#105: FILE: tools/virtiofsd/passthrough_ll.c:78:
+^Iino_t ino;$
ERROR: code indent should never use tabs
#106: FILE: tools/virtiofsd/passthrough_ll.c:79:
+^Idev_t dev;$
ERROR: code indent should never use tabs
#107: FILE: tools/virtiofsd/passthrough_ll.c:80:
+^Iuint64_t refcount; /* protected by lo->mutex */$
ERROR: code indent should never use tabs
#111: FILE: tools/virtiofsd/passthrough_ll.c:84:
+^ICACHE_NEVER,$
ERROR: code indent should never use tabs
#112: FILE: tools/virtiofsd/passthrough_ll.c:85:
+^ICACHE_NORMAL,$
ERROR: code indent should never use tabs
#113: FILE: tools/virtiofsd/passthrough_ll.c:86:
+^ICACHE_ALWAYS,$
ERROR: code indent should never use tabs
#117: FILE: tools/virtiofsd/passthrough_ll.c:90:
+^Ipthread_mutex_t mutex;$
ERROR: code indent should never use tabs
#118: FILE: tools/virtiofsd/passthrough_ll.c:91:
+^Iint debug;$
ERROR: code indent should never use tabs
#119: FILE: tools/virtiofsd/passthrough_ll.c:92:
+^Iint writeback;$
ERROR: code indent should never use tabs
#120: FILE: tools/virtiofsd/passthrough_ll.c:93:
+^Iint flock;$
ERROR: code indent should never use tabs
#121: FILE: tools/virtiofsd/passthrough_ll.c:94:
+^Iint xattr;$
ERROR: code indent should never use tabs
#122: FILE: tools/virtiofsd/passthrough_ll.c:95:
+^Iconst char *source;$
ERROR: code indent should never use tabs
#123: FILE: tools/virtiofsd/passthrough_ll.c:96:
+^Idouble timeout;$
ERROR: code indent should never use tabs
#124: FILE: tools/virtiofsd/passthrough_ll.c:97:
+^Iint cache;$
ERROR: code indent should never use tabs
#125: FILE: tools/virtiofsd/passthrough_ll.c:98:
+^Iint timeout_set;$
ERROR: code indent should never use tabs
#126: FILE: tools/virtiofsd/passthrough_ll.c:99:
+^Istruct lo_inode root; /* protected by lo->mutex */$
ERROR: code indent should never use tabs
#130: FILE: tools/virtiofsd/passthrough_ll.c:103:
+^I{ "writeback",$
ERROR: code indent should never use tabs
#131: FILE: tools/virtiofsd/passthrough_ll.c:104:
+^I offsetof(struct lo_data, writeback), 1 },$
ERROR: code indent should never use tabs
#132: FILE: tools/virtiofsd/passthrough_ll.c:105:
+^I{ "no_writeback",$
ERROR: code indent should never use tabs
#133: FILE: tools/virtiofsd/passthrough_ll.c:106:
+^I offsetof(struct lo_data, writeback), 0 },$
ERROR: code indent should never use tabs
#134: FILE: tools/virtiofsd/passthrough_ll.c:107:
+^I{ "source=%s",$
ERROR: code indent should never use tabs
#135: FILE: tools/virtiofsd/passthrough_ll.c:108:
+^I offsetof(struct lo_data, source), 0 },$
ERROR: code indent should never use tabs
#136: FILE: tools/virtiofsd/passthrough_ll.c:109:
+^I{ "flock",$
ERROR: code indent should never use tabs
#137: FILE: tools/virtiofsd/passthrough_ll.c:110:
+^I offsetof(struct lo_data, flock), 1 },$
ERROR: code indent should never use tabs
#138: FILE: tools/virtiofsd/passthrough_ll.c:111:
+^I{ "no_flock",$
ERROR: code indent should never use tabs
#139: FILE: tools/virtiofsd/passthrough_ll.c:112:
+^I offsetof(struct lo_data, flock), 0 },$
ERROR: code indent should never use tabs
#140: FILE: tools/virtiofsd/passthrough_ll.c:113:
+^I{ "xattr",$
ERROR: code indent should never use tabs
#141: FILE: tools/virtiofsd/passthrough_ll.c:114:
+^I offsetof(struct lo_data, xattr), 1 },$
ERROR: code indent should never use tabs
#142: FILE: tools/virtiofsd/passthrough_ll.c:115:
+^I{ "no_xattr",$
ERROR: code indent should never use tabs
#143: FILE: tools/virtiofsd/passthrough_ll.c:116:
+^I offsetof(struct lo_data, xattr), 0 },$
ERROR: code indent should never use tabs
#144: FILE: tools/virtiofsd/passthrough_ll.c:117:
+^I{ "timeout=%lf",$
ERROR: code indent should never use tabs
#145: FILE: tools/virtiofsd/passthrough_ll.c:118:
+^I offsetof(struct lo_data, timeout), 0 },$
ERROR: code indent should never use tabs
#146: FILE: tools/virtiofsd/passthrough_ll.c:119:
+^I{ "timeout=",$
ERROR: code indent should never use tabs
#147: FILE: tools/virtiofsd/passthrough_ll.c:120:
+^I offsetof(struct lo_data, timeout_set), 1 },$
ERROR: code indent should never use tabs
#148: FILE: tools/virtiofsd/passthrough_ll.c:121:
+^I{ "cache=never",$
ERROR: code indent should never use tabs
#149: FILE: tools/virtiofsd/passthrough_ll.c:122:
+^I offsetof(struct lo_data, cache), CACHE_NEVER },$
ERROR: code indent should never use tabs
#150: FILE: tools/virtiofsd/passthrough_ll.c:123:
+^I{ "cache=auto",$
ERROR: code indent should never use tabs
#151: FILE: tools/virtiofsd/passthrough_ll.c:124:
+^I offsetof(struct lo_data, cache), CACHE_NORMAL },$
ERROR: code indent should never use tabs
#152: FILE: tools/virtiofsd/passthrough_ll.c:125:
+^I{ "cache=always",$
ERROR: code indent should never use tabs
#153: FILE: tools/virtiofsd/passthrough_ll.c:126:
+^I offsetof(struct lo_data, cache), CACHE_ALWAYS },$
ERROR: code indent should never use tabs
#155: FILE: tools/virtiofsd/passthrough_ll.c:128:
+^IFUSE_OPT_END$
ERROR: code indent should never use tabs
#160: FILE: tools/virtiofsd/passthrough_ll.c:133:
+^Ireturn (struct lo_data *) fuse_req_userdata(req);$
ERROR: code indent should never use tabs
#165: FILE: tools/virtiofsd/passthrough_ll.c:138:
+^Iif (ino == FUSE_ROOT_ID)$
ERROR: braces {} are necessary for all arms of this statement
#165: FILE: tools/virtiofsd/passthrough_ll.c:138:
+ if (ino == FUSE_ROOT_ID)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#166: FILE: tools/virtiofsd/passthrough_ll.c:139:
+^I^Ireturn &lo_data(req)->root;$
ERROR: code indent should never use tabs
#167: FILE: tools/virtiofsd/passthrough_ll.c:140:
+^Ielse$
ERROR: code indent should never use tabs
#168: FILE: tools/virtiofsd/passthrough_ll.c:141:
+^I^Ireturn (struct lo_inode *) (uintptr_t) ino;$
ERROR: code indent should never use tabs
#173: FILE: tools/virtiofsd/passthrough_ll.c:146:
+^Ireturn lo_inode(req, ino)->fd;$
ERROR: code indent should never use tabs
#178: FILE: tools/virtiofsd/passthrough_ll.c:151:
+^Ireturn lo_data(req)->debug != 0;$
ERROR: code indent should never use tabs
#182: FILE: tools/virtiofsd/passthrough_ll.c:155:
+^I^I struct fuse_conn_info *conn)$
ERROR: code indent should never use tabs
#184: FILE: tools/virtiofsd/passthrough_ll.c:157:
+^Istruct lo_data *lo = (struct lo_data*) userdata;$
ERROR: "(foo*)" should be "(foo *)"
#184: FILE: tools/virtiofsd/passthrough_ll.c:157:
+ struct lo_data *lo = (struct lo_data*) userdata;
ERROR: code indent should never use tabs
#186: FILE: tools/virtiofsd/passthrough_ll.c:159:
+^Iif(conn->capable & FUSE_CAP_EXPORT_SUPPORT)$
ERROR: space required before the open parenthesis '('
#186: FILE: tools/virtiofsd/passthrough_ll.c:159:
+ if(conn->capable & FUSE_CAP_EXPORT_SUPPORT)
ERROR: braces {} are necessary for all arms of this statement
#186: FILE: tools/virtiofsd/passthrough_ll.c:159:
+ if(conn->capable & FUSE_CAP_EXPORT_SUPPORT)
[...]
ERROR: code indent should never use tabs
#187: FILE: tools/virtiofsd/passthrough_ll.c:160:
+^I^Iconn->want |= FUSE_CAP_EXPORT_SUPPORT;$
ERROR: code indent should never use tabs
#189: FILE: tools/virtiofsd/passthrough_ll.c:162:
+^Iif (lo->writeback &&$
ERROR: code indent should never use tabs
#190: FILE: tools/virtiofsd/passthrough_ll.c:163:
+^I conn->capable & FUSE_CAP_WRITEBACK_CACHE) {$
ERROR: code indent should never use tabs
#191: FILE: tools/virtiofsd/passthrough_ll.c:164:
+^I^Iif (lo->debug)$
ERROR: braces {} are necessary for all arms of this statement
#191: FILE: tools/virtiofsd/passthrough_ll.c:164:
+ if (lo->debug)
[...]
WARNING: line over 80 characters
#192: FILE: tools/virtiofsd/passthrough_ll.c:165:
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating writeback\n");
ERROR: code indent should never use tabs
#192: FILE: tools/virtiofsd/passthrough_ll.c:165:
+^I^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_init: activating writeback\n");$
ERROR: code indent should never use tabs
#193: FILE: tools/virtiofsd/passthrough_ll.c:166:
+^I^Iconn->want |= FUSE_CAP_WRITEBACK_CACHE;$
ERROR: code indent should never use tabs
#194: FILE: tools/virtiofsd/passthrough_ll.c:167:
+^I}$
ERROR: code indent should never use tabs
#195: FILE: tools/virtiofsd/passthrough_ll.c:168:
+^Iif (lo->flock && conn->capable & FUSE_CAP_FLOCK_LOCKS) {$
ERROR: code indent should never use tabs
#196: FILE: tools/virtiofsd/passthrough_ll.c:169:
+^I^Iif (lo->debug)$
ERROR: braces {} are necessary for all arms of this statement
#196: FILE: tools/virtiofsd/passthrough_ll.c:169:
+ if (lo->debug)
[...]
WARNING: line over 80 characters
#197: FILE: tools/virtiofsd/passthrough_ll.c:170:
+ fuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");
ERROR: code indent should never use tabs
#197: FILE: tools/virtiofsd/passthrough_ll.c:170:
+^I^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_init: activating flock locks\n");$
ERROR: code indent should never use tabs
#198: FILE: tools/virtiofsd/passthrough_ll.c:171:
+^I^Iconn->want |= FUSE_CAP_FLOCK_LOCKS;$
ERROR: code indent should never use tabs
#199: FILE: tools/virtiofsd/passthrough_ll.c:172:
+^I}$
ERROR: code indent should never use tabs
#203: FILE: tools/virtiofsd/passthrough_ll.c:176:
+^I^I^I struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#205: FILE: tools/virtiofsd/passthrough_ll.c:178:
+^Iint res;$
ERROR: code indent should never use tabs
#206: FILE: tools/virtiofsd/passthrough_ll.c:179:
+^Istruct stat buf;$
ERROR: code indent should never use tabs
#207: FILE: tools/virtiofsd/passthrough_ll.c:180:
+^Istruct lo_data *lo = lo_data(req);$
ERROR: code indent should never use tabs
#209: FILE: tools/virtiofsd/passthrough_ll.c:182:
+^I(void) fi;$
WARNING: line over 80 characters
#211: FILE: tools/virtiofsd/passthrough_ll.c:184:
+ res = fstatat(lo_fd(req, ino), "", &buf, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
ERROR: code indent should never use tabs
#211: FILE: tools/virtiofsd/passthrough_ll.c:184:
+^Ires = fstatat(lo_fd(req, ino), "", &buf, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);$
ERROR: code indent should never use tabs
#212: FILE: tools/virtiofsd/passthrough_ll.c:185:
+^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#212: FILE: tools/virtiofsd/passthrough_ll.c:185:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#213: FILE: tools/virtiofsd/passthrough_ll.c:186:
+^I^Ireturn (void) fuse_reply_err(req, errno);$
ERROR: code indent should never use tabs
#215: FILE: tools/virtiofsd/passthrough_ll.c:188:
+^Ifuse_reply_attr(req, &buf, lo->timeout);$
ERROR: code indent should never use tabs
#219: FILE: tools/virtiofsd/passthrough_ll.c:192:
+^I^I^I^I const struct timespec *tv)$
ERROR: code indent should never use tabs
#221: FILE: tools/virtiofsd/passthrough_ll.c:194:
+^Iint res;$
ERROR: code indent should never use tabs
#222: FILE: tools/virtiofsd/passthrough_ll.c:195:
+^Ichar procname[64];$
ERROR: code indent should never use tabs
#224: FILE: tools/virtiofsd/passthrough_ll.c:197:
+^Iif (inode->is_symlink) {$
ERROR: code indent should never use tabs
#225: FILE: tools/virtiofsd/passthrough_ll.c:198:
+^I^Ires = utimensat(inode->fd, "", tv,$
ERROR: code indent should never use tabs
#226: FILE: tools/virtiofsd/passthrough_ll.c:199:
+^I^I^I^IAT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);$
ERROR: code indent should never use tabs
#227: FILE: tools/virtiofsd/passthrough_ll.c:200:
+^I^Iif (res == -1 && errno == EINVAL) {$
ERROR: code indent should never use tabs
#228: FILE: tools/virtiofsd/passthrough_ll.c:201:
+^I^I^I/* Sorry, no race free way to set times on symlink. */$
ERROR: code indent should never use tabs
#229: FILE: tools/virtiofsd/passthrough_ll.c:202:
+^I^I^Ierrno = EPERM;$
ERROR: code indent should never use tabs
#230: FILE: tools/virtiofsd/passthrough_ll.c:203:
+^I^I}$
ERROR: code indent should never use tabs
#231: FILE: tools/virtiofsd/passthrough_ll.c:204:
+^I^Ireturn res;$
ERROR: code indent should never use tabs
#232: FILE: tools/virtiofsd/passthrough_ll.c:205:
+^I}$
ERROR: code indent should never use tabs
#233: FILE: tools/virtiofsd/passthrough_ll.c:206:
+^Isprintf(procname, "/proc/self/fd/%i", inode->fd);$
ERROR: code indent should never use tabs
#235: FILE: tools/virtiofsd/passthrough_ll.c:208:
+^Ireturn utimensat(AT_FDCWD, procname, tv, 0);$
ERROR: code indent should never use tabs
#239: FILE: tools/virtiofsd/passthrough_ll.c:212:
+^I^I int valid, struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#241: FILE: tools/virtiofsd/passthrough_ll.c:214:
+^Iint saverr;$
ERROR: code indent should never use tabs
#242: FILE: tools/virtiofsd/passthrough_ll.c:215:
+^Ichar procname[64];$
ERROR: code indent should never use tabs
#243: FILE: tools/virtiofsd/passthrough_ll.c:216:
+^Istruct lo_inode *inode = lo_inode(req, ino);$
ERROR: code indent should never use tabs
#244: FILE: tools/virtiofsd/passthrough_ll.c:217:
+^Iint ifd = inode->fd;$
ERROR: code indent should never use tabs
#245: FILE: tools/virtiofsd/passthrough_ll.c:218:
+^Iint res;$
ERROR: code indent should never use tabs
#247: FILE: tools/virtiofsd/passthrough_ll.c:220:
+^Iif (valid & FUSE_SET_ATTR_MODE) {$
ERROR: code indent should never use tabs
#248: FILE: tools/virtiofsd/passthrough_ll.c:221:
+^I^Iif (fi) {$
ERROR: code indent should never use tabs
#249: FILE: tools/virtiofsd/passthrough_ll.c:222:
+^I^I^Ires = fchmod(fi->fh, attr->st_mode);$
ERROR: code indent should never use tabs
#250: FILE: tools/virtiofsd/passthrough_ll.c:223:
+^I^I} else {$
ERROR: code indent should never use tabs
#251: FILE: tools/virtiofsd/passthrough_ll.c:224:
+^I^I^Isprintf(procname, "/proc/self/fd/%i", ifd);$
ERROR: code indent should never use tabs
#252: FILE: tools/virtiofsd/passthrough_ll.c:225:
+^I^I^Ires = chmod(procname, attr->st_mode);$
ERROR: code indent should never use tabs
#253: FILE: tools/virtiofsd/passthrough_ll.c:226:
+^I^I}$
ERROR: code indent should never use tabs
#254: FILE: tools/virtiofsd/passthrough_ll.c:227:
+^I^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#254: FILE: tools/virtiofsd/passthrough_ll.c:227:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#255: FILE: tools/virtiofsd/passthrough_ll.c:228:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#256: FILE: tools/virtiofsd/passthrough_ll.c:229:
+^I}$
ERROR: code indent should never use tabs
#257: FILE: tools/virtiofsd/passthrough_ll.c:230:
+^Iif (valid & (FUSE_SET_ATTR_UID | FUSE_SET_ATTR_GID)) {$
ERROR: code indent should never use tabs
#258: FILE: tools/virtiofsd/passthrough_ll.c:231:
+^I^Iuid_t uid = (valid & FUSE_SET_ATTR_UID) ?$
ERROR: code indent should never use tabs
#259: FILE: tools/virtiofsd/passthrough_ll.c:232:
+^I^I^Iattr->st_uid : (uid_t) -1;$
ERROR: code indent should never use tabs
#260: FILE: tools/virtiofsd/passthrough_ll.c:233:
+^I^Igid_t gid = (valid & FUSE_SET_ATTR_GID) ?$
ERROR: code indent should never use tabs
#261: FILE: tools/virtiofsd/passthrough_ll.c:234:
+^I^I^Iattr->st_gid : (gid_t) -1;$
ERROR: code indent should never use tabs
#263: FILE: tools/virtiofsd/passthrough_ll.c:236:
+^I^Ires = fchownat(ifd, "", uid, gid,$
ERROR: code indent should never use tabs
#264: FILE: tools/virtiofsd/passthrough_ll.c:237:
+^I^I^I AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);$
ERROR: code indent should never use tabs
#265: FILE: tools/virtiofsd/passthrough_ll.c:238:
+^I^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#265: FILE: tools/virtiofsd/passthrough_ll.c:238:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#266: FILE: tools/virtiofsd/passthrough_ll.c:239:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#267: FILE: tools/virtiofsd/passthrough_ll.c:240:
+^I}$
ERROR: code indent should never use tabs
#268: FILE: tools/virtiofsd/passthrough_ll.c:241:
+^Iif (valid & FUSE_SET_ATTR_SIZE) {$
ERROR: code indent should never use tabs
#269: FILE: tools/virtiofsd/passthrough_ll.c:242:
+^I^Iif (fi) {$
ERROR: code indent should never use tabs
#270: FILE: tools/virtiofsd/passthrough_ll.c:243:
+^I^I^Ires = ftruncate(fi->fh, attr->st_size);$
ERROR: code indent should never use tabs
#271: FILE: tools/virtiofsd/passthrough_ll.c:244:
+^I^I} else {$
ERROR: code indent should never use tabs
#272: FILE: tools/virtiofsd/passthrough_ll.c:245:
+^I^I^Isprintf(procname, "/proc/self/fd/%i", ifd);$
ERROR: code indent should never use tabs
#273: FILE: tools/virtiofsd/passthrough_ll.c:246:
+^I^I^Ires = truncate(procname, attr->st_size);$
ERROR: code indent should never use tabs
#274: FILE: tools/virtiofsd/passthrough_ll.c:247:
+^I^I}$
ERROR: code indent should never use tabs
#275: FILE: tools/virtiofsd/passthrough_ll.c:248:
+^I^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#275: FILE: tools/virtiofsd/passthrough_ll.c:248:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#276: FILE: tools/virtiofsd/passthrough_ll.c:249:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#277: FILE: tools/virtiofsd/passthrough_ll.c:250:
+^I}$
ERROR: code indent should never use tabs
#278: FILE: tools/virtiofsd/passthrough_ll.c:251:
+^Iif (valid & (FUSE_SET_ATTR_ATIME | FUSE_SET_ATTR_MTIME)) {$
ERROR: code indent should never use tabs
#279: FILE: tools/virtiofsd/passthrough_ll.c:252:
+^I^Istruct timespec tv[2];$
ERROR: code indent should never use tabs
#281: FILE: tools/virtiofsd/passthrough_ll.c:254:
+^I^Itv[0].tv_sec = 0;$
ERROR: code indent should never use tabs
#282: FILE: tools/virtiofsd/passthrough_ll.c:255:
+^I^Itv[1].tv_sec = 0;$
ERROR: code indent should never use tabs
#283: FILE: tools/virtiofsd/passthrough_ll.c:256:
+^I^Itv[0].tv_nsec = UTIME_OMIT;$
ERROR: code indent should never use tabs
#284: FILE: tools/virtiofsd/passthrough_ll.c:257:
+^I^Itv[1].tv_nsec = UTIME_OMIT;$
ERROR: code indent should never use tabs
#286: FILE: tools/virtiofsd/passthrough_ll.c:259:
+^I^Iif (valid & FUSE_SET_ATTR_ATIME_NOW)$
ERROR: braces {} are necessary for all arms of this statement
#286: FILE: tools/virtiofsd/passthrough_ll.c:259:
+ if (valid & FUSE_SET_ATTR_ATIME_NOW)
[...]
+ else if (valid & FUSE_SET_ATTR_ATIME)
[...]
ERROR: code indent should never use tabs
#287: FILE: tools/virtiofsd/passthrough_ll.c:260:
+^I^I^Itv[0].tv_nsec = UTIME_NOW;$
ERROR: code indent should never use tabs
#288: FILE: tools/virtiofsd/passthrough_ll.c:261:
+^I^Ielse if (valid & FUSE_SET_ATTR_ATIME)$
ERROR: braces {} are necessary for all arms of this statement
#288: FILE: tools/virtiofsd/passthrough_ll.c:261:
+ else if (valid & FUSE_SET_ATTR_ATIME)
[...]
ERROR: code indent should never use tabs
#289: FILE: tools/virtiofsd/passthrough_ll.c:262:
+^I^I^Itv[0] = attr->st_atim;$
ERROR: code indent should never use tabs
#291: FILE: tools/virtiofsd/passthrough_ll.c:264:
+^I^Iif (valid & FUSE_SET_ATTR_MTIME_NOW)$
ERROR: braces {} are necessary for all arms of this statement
#291: FILE: tools/virtiofsd/passthrough_ll.c:264:
+ if (valid & FUSE_SET_ATTR_MTIME_NOW)
[...]
+ else if (valid & FUSE_SET_ATTR_MTIME)
[...]
ERROR: code indent should never use tabs
#292: FILE: tools/virtiofsd/passthrough_ll.c:265:
+^I^I^Itv[1].tv_nsec = UTIME_NOW;$
ERROR: code indent should never use tabs
#293: FILE: tools/virtiofsd/passthrough_ll.c:266:
+^I^Ielse if (valid & FUSE_SET_ATTR_MTIME)$
ERROR: braces {} are necessary for all arms of this statement
#293: FILE: tools/virtiofsd/passthrough_ll.c:266:
+ else if (valid & FUSE_SET_ATTR_MTIME)
[...]
ERROR: code indent should never use tabs
#294: FILE: tools/virtiofsd/passthrough_ll.c:267:
+^I^I^Itv[1] = attr->st_mtim;$
ERROR: code indent should never use tabs
#296: FILE: tools/virtiofsd/passthrough_ll.c:269:
+^I^Iif (fi)$
ERROR: braces {} are necessary for all arms of this statement
#296: FILE: tools/virtiofsd/passthrough_ll.c:269:
+ if (fi)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#297: FILE: tools/virtiofsd/passthrough_ll.c:270:
+^I^I^Ires = futimens(fi->fh, tv);$
ERROR: code indent should never use tabs
#298: FILE: tools/virtiofsd/passthrough_ll.c:271:
+^I^Ielse$
ERROR: code indent should never use tabs
#299: FILE: tools/virtiofsd/passthrough_ll.c:272:
+^I^I^Ires = utimensat_empty_nofollow(inode, tv);$
ERROR: code indent should never use tabs
#300: FILE: tools/virtiofsd/passthrough_ll.c:273:
+^I^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#300: FILE: tools/virtiofsd/passthrough_ll.c:273:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#301: FILE: tools/virtiofsd/passthrough_ll.c:274:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#302: FILE: tools/virtiofsd/passthrough_ll.c:275:
+^I}$
ERROR: code indent should never use tabs
#304: FILE: tools/virtiofsd/passthrough_ll.c:277:
+^Ireturn lo_getattr(req, ino, fi);$
ERROR: code indent should never use tabs
#307: FILE: tools/virtiofsd/passthrough_ll.c:280:
+^Isaverr = errno;$
ERROR: code indent should never use tabs
#308: FILE: tools/virtiofsd/passthrough_ll.c:281:
+^Ifuse_reply_err(req, saverr);$
ERROR: code indent should never use tabs
#313: FILE: tools/virtiofsd/passthrough_ll.c:286:
+^Istruct lo_inode *p;$
ERROR: code indent should never use tabs
#314: FILE: tools/virtiofsd/passthrough_ll.c:287:
+^Istruct lo_inode *ret = NULL;$
ERROR: code indent should never use tabs
#316: FILE: tools/virtiofsd/passthrough_ll.c:289:
+^Ipthread_mutex_lock(&lo->mutex);$
ERROR: code indent should never use tabs
#317: FILE: tools/virtiofsd/passthrough_ll.c:290:
+^Ifor (p = lo->root.next; p != &lo->root; p = p->next) {$
ERROR: code indent should never use tabs
#318: FILE: tools/virtiofsd/passthrough_ll.c:291:
+^I^Iif (p->ino == st->st_ino && p->dev == st->st_dev) {$
ERROR: code indent should never use tabs
#319: FILE: tools/virtiofsd/passthrough_ll.c:292:
+^I^I^Iassert(p->refcount > 0);$
ERROR: code indent should never use tabs
#320: FILE: tools/virtiofsd/passthrough_ll.c:293:
+^I^I^Iret = p;$
ERROR: code indent should never use tabs
#321: FILE: tools/virtiofsd/passthrough_ll.c:294:
+^I^I^Iret->refcount++;$
ERROR: code indent should never use tabs
#322: FILE: tools/virtiofsd/passthrough_ll.c:295:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#323: FILE: tools/virtiofsd/passthrough_ll.c:296:
+^I^I}$
ERROR: code indent should never use tabs
#324: FILE: tools/virtiofsd/passthrough_ll.c:297:
+^I}$
ERROR: code indent should never use tabs
#325: FILE: tools/virtiofsd/passthrough_ll.c:298:
+^Ipthread_mutex_unlock(&lo->mutex);$
ERROR: code indent should never use tabs
#326: FILE: tools/virtiofsd/passthrough_ll.c:299:
+^Ireturn ret;$
ERROR: code indent should never use tabs
#330: FILE: tools/virtiofsd/passthrough_ll.c:303:
+^I^I^I struct fuse_entry_param *e)$
ERROR: code indent should never use tabs
#332: FILE: tools/virtiofsd/passthrough_ll.c:305:
+^Iint newfd;$
ERROR: code indent should never use tabs
#333: FILE: tools/virtiofsd/passthrough_ll.c:306:
+^Iint res;$
ERROR: code indent should never use tabs
#334: FILE: tools/virtiofsd/passthrough_ll.c:307:
+^Iint saverr;$
ERROR: code indent should never use tabs
#335: FILE: tools/virtiofsd/passthrough_ll.c:308:
+^Istruct lo_data *lo = lo_data(req);$
ERROR: code indent should never use tabs
#336: FILE: tools/virtiofsd/passthrough_ll.c:309:
+^Istruct lo_inode *inode;$
ERROR: code indent should never use tabs
#338: FILE: tools/virtiofsd/passthrough_ll.c:311:
+^Imemset(e, 0, sizeof(*e));$
ERROR: code indent should never use tabs
#339: FILE: tools/virtiofsd/passthrough_ll.c:312:
+^Ie->attr_timeout = lo->timeout;$
ERROR: code indent should never use tabs
#340: FILE: tools/virtiofsd/passthrough_ll.c:313:
+^Ie->entry_timeout = lo->timeout;$
ERROR: code indent should never use tabs
#342: FILE: tools/virtiofsd/passthrough_ll.c:315:
+^Inewfd = openat(lo_fd(req, parent), name, O_PATH | O_NOFOLLOW);$
ERROR: code indent should never use tabs
#343: FILE: tools/virtiofsd/passthrough_ll.c:316:
+^Iif (newfd == -1)$
ERROR: braces {} are necessary for all arms of this statement
#343: FILE: tools/virtiofsd/passthrough_ll.c:316:
+ if (newfd == -1)
[...]
ERROR: code indent should never use tabs
#344: FILE: tools/virtiofsd/passthrough_ll.c:317:
+^I^Igoto out_err;$
ERROR: code indent should never use tabs
#346: FILE: tools/virtiofsd/passthrough_ll.c:319:
+^Ires = fstatat(newfd, "", &e->attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);$
ERROR: code indent should never use tabs
#347: FILE: tools/virtiofsd/passthrough_ll.c:320:
+^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#347: FILE: tools/virtiofsd/passthrough_ll.c:320:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#348: FILE: tools/virtiofsd/passthrough_ll.c:321:
+^I^Igoto out_err;$
ERROR: code indent should never use tabs
#350: FILE: tools/virtiofsd/passthrough_ll.c:323:
+^Iinode = lo_find(lo_data(req), &e->attr);$
ERROR: code indent should never use tabs
#351: FILE: tools/virtiofsd/passthrough_ll.c:324:
+^Iif (inode) {$
ERROR: code indent should never use tabs
#352: FILE: tools/virtiofsd/passthrough_ll.c:325:
+^I^Iclose(newfd);$
ERROR: code indent should never use tabs
#353: FILE: tools/virtiofsd/passthrough_ll.c:326:
+^I^Inewfd = -1;$
ERROR: code indent should never use tabs
#354: FILE: tools/virtiofsd/passthrough_ll.c:327:
+^I} else {$
ERROR: code indent should never use tabs
#355: FILE: tools/virtiofsd/passthrough_ll.c:328:
+^I^Istruct lo_inode *prev, *next;$
ERROR: code indent should never use tabs
#357: FILE: tools/virtiofsd/passthrough_ll.c:330:
+^I^Isaverr = ENOMEM;$
ERROR: code indent should never use tabs
#358: FILE: tools/virtiofsd/passthrough_ll.c:331:
+^I^Iinode = calloc(1, sizeof(struct lo_inode));$
ERROR: code indent should never use tabs
#359: FILE: tools/virtiofsd/passthrough_ll.c:332:
+^I^Iif (!inode)$
ERROR: braces {} are necessary for all arms of this statement
#359: FILE: tools/virtiofsd/passthrough_ll.c:332:
+ if (!inode)
[...]
ERROR: code indent should never use tabs
#360: FILE: tools/virtiofsd/passthrough_ll.c:333:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#362: FILE: tools/virtiofsd/passthrough_ll.c:335:
+^I^Iinode->is_symlink = S_ISLNK(e->attr.st_mode);$
ERROR: code indent should never use tabs
#363: FILE: tools/virtiofsd/passthrough_ll.c:336:
+^I^Iinode->refcount = 1;$
ERROR: code indent should never use tabs
#364: FILE: tools/virtiofsd/passthrough_ll.c:337:
+^I^Iinode->fd = newfd;$
ERROR: code indent should never use tabs
#365: FILE: tools/virtiofsd/passthrough_ll.c:338:
+^I^Iinode->ino = e->attr.st_ino;$
ERROR: code indent should never use tabs
#366: FILE: tools/virtiofsd/passthrough_ll.c:339:
+^I^Iinode->dev = e->attr.st_dev;$
ERROR: code indent should never use tabs
#368: FILE: tools/virtiofsd/passthrough_ll.c:341:
+^I^Ipthread_mutex_lock(&lo->mutex);$
ERROR: code indent should never use tabs
#369: FILE: tools/virtiofsd/passthrough_ll.c:342:
+^I^Iprev = &lo->root;$
ERROR: code indent should never use tabs
#370: FILE: tools/virtiofsd/passthrough_ll.c:343:
+^I^Inext = prev->next;$
ERROR: code indent should never use tabs
#371: FILE: tools/virtiofsd/passthrough_ll.c:344:
+^I^Inext->prev = inode;$
ERROR: code indent should never use tabs
#372: FILE: tools/virtiofsd/passthrough_ll.c:345:
+^I^Iinode->next = next;$
ERROR: code indent should never use tabs
#373: FILE: tools/virtiofsd/passthrough_ll.c:346:
+^I^Iinode->prev = prev;$
ERROR: code indent should never use tabs
#374: FILE: tools/virtiofsd/passthrough_ll.c:347:
+^I^Iprev->next = inode;$
ERROR: code indent should never use tabs
#375: FILE: tools/virtiofsd/passthrough_ll.c:348:
+^I^Ipthread_mutex_unlock(&lo->mutex);$
ERROR: code indent should never use tabs
#376: FILE: tools/virtiofsd/passthrough_ll.c:349:
+^I}$
ERROR: code indent should never use tabs
#377: FILE: tools/virtiofsd/passthrough_ll.c:350:
+^Ie->ino = (uintptr_t) inode;$
ERROR: code indent should never use tabs
#379: FILE: tools/virtiofsd/passthrough_ll.c:352:
+^Iif (lo_debug(req))$
ERROR: code indent should never use tabs
#380: FILE: tools/virtiofsd/passthrough_ll.c:353:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",$
WARNING: line over 80 characters
#381: FILE: tools/virtiofsd/passthrough_ll.c:354:
+ (unsigned long long) parent, name, (unsigned long long) e->ino);
ERROR: code indent should never use tabs
#381: FILE: tools/virtiofsd/passthrough_ll.c:354:
+^I^I^I(unsigned long long) parent, name, (unsigned long long) e->ino);$
ERROR: code indent should never use tabs
#383: FILE: tools/virtiofsd/passthrough_ll.c:356:
+^Ireturn 0;$
ERROR: code indent should never use tabs
#386: FILE: tools/virtiofsd/passthrough_ll.c:359:
+^Isaverr = errno;$
ERROR: code indent should never use tabs
#387: FILE: tools/virtiofsd/passthrough_ll.c:360:
+^Iif (newfd != -1)$
ERROR: braces {} are necessary for all arms of this statement
#387: FILE: tools/virtiofsd/passthrough_ll.c:360:
+ if (newfd != -1)
[...]
ERROR: code indent should never use tabs
#388: FILE: tools/virtiofsd/passthrough_ll.c:361:
+^I^Iclose(newfd);$
ERROR: code indent should never use tabs
#389: FILE: tools/virtiofsd/passthrough_ll.c:362:
+^Ireturn saverr;$
ERROR: code indent should never use tabs
#394: FILE: tools/virtiofsd/passthrough_ll.c:367:
+^Istruct fuse_entry_param e;$
ERROR: code indent should never use tabs
#395: FILE: tools/virtiofsd/passthrough_ll.c:368:
+^Iint err;$
ERROR: code indent should never use tabs
#397: FILE: tools/virtiofsd/passthrough_ll.c:370:
+^Iif (lo_debug(req))$
WARNING: line over 80 characters
#398: FILE: tools/virtiofsd/passthrough_ll.c:371:
+ fuse_log(FUSE_LOG_DEBUG, "lo_lookup(parent=%" PRIu64 ", name=%s)\n",
ERROR: code indent should never use tabs
#398: FILE: tools/virtiofsd/passthrough_ll.c:371:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_lookup(parent=%" PRIu64 ", name=%s)\n",$
ERROR: code indent should never use tabs
#399: FILE: tools/virtiofsd/passthrough_ll.c:372:
+^I^I^Iparent, name);$
ERROR: code indent should never use tabs
#401: FILE: tools/virtiofsd/passthrough_ll.c:374:
+^Ierr = lo_do_lookup(req, parent, name, &e);$
ERROR: code indent should never use tabs
#402: FILE: tools/virtiofsd/passthrough_ll.c:375:
+^Iif (err)$
ERROR: braces {} are necessary for all arms of this statement
#402: FILE: tools/virtiofsd/passthrough_ll.c:375:
+ if (err)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#403: FILE: tools/virtiofsd/passthrough_ll.c:376:
+^I^Ifuse_reply_err(req, err);$
ERROR: code indent should never use tabs
#404: FILE: tools/virtiofsd/passthrough_ll.c:377:
+^Ielse$
ERROR: code indent should never use tabs
#405: FILE: tools/virtiofsd/passthrough_ll.c:378:
+^I^Ifuse_reply_entry(req, &e);$
ERROR: code indent should never use tabs
#409: FILE: tools/virtiofsd/passthrough_ll.c:382:
+^I^I^I const char *name, mode_t mode, dev_t rdev,$
ERROR: code indent should never use tabs
#410: FILE: tools/virtiofsd/passthrough_ll.c:383:
+^I^I^I const char *link)$
ERROR: code indent should never use tabs
#412: FILE: tools/virtiofsd/passthrough_ll.c:385:
+^Iint res;$
ERROR: code indent should never use tabs
#413: FILE: tools/virtiofsd/passthrough_ll.c:386:
+^Iint saverr;$
ERROR: code indent should never use tabs
#414: FILE: tools/virtiofsd/passthrough_ll.c:387:
+^Istruct lo_inode *dir = lo_inode(req, parent);$
ERROR: code indent should never use tabs
#415: FILE: tools/virtiofsd/passthrough_ll.c:388:
+^Istruct fuse_entry_param e;$
ERROR: code indent should never use tabs
#417: FILE: tools/virtiofsd/passthrough_ll.c:390:
+^Isaverr = ENOMEM;$
ERROR: code indent should never use tabs
#419: FILE: tools/virtiofsd/passthrough_ll.c:392:
+^Ires = mknod_wrapper(dir->fd, name, link, mode, rdev);$
ERROR: code indent should never use tabs
#421: FILE: tools/virtiofsd/passthrough_ll.c:394:
+^Isaverr = errno;$
ERROR: code indent should never use tabs
#422: FILE: tools/virtiofsd/passthrough_ll.c:395:
+^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#422: FILE: tools/virtiofsd/passthrough_ll.c:395:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#423: FILE: tools/virtiofsd/passthrough_ll.c:396:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#425: FILE: tools/virtiofsd/passthrough_ll.c:398:
+^Isaverr = lo_do_lookup(req, parent, name, &e);$
ERROR: code indent should never use tabs
#426: FILE: tools/virtiofsd/passthrough_ll.c:399:
+^Iif (saverr)$
ERROR: braces {} are necessary for all arms of this statement
#426: FILE: tools/virtiofsd/passthrough_ll.c:399:
+ if (saverr)
[...]
ERROR: code indent should never use tabs
#427: FILE: tools/virtiofsd/passthrough_ll.c:400:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#429: FILE: tools/virtiofsd/passthrough_ll.c:402:
+^Iif (lo_debug(req))$
ERROR: code indent should never use tabs
#430: FILE: tools/virtiofsd/passthrough_ll.c:403:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",$
WARNING: line over 80 characters
#431: FILE: tools/virtiofsd/passthrough_ll.c:404:
+ (unsigned long long) parent, name, (unsigned long long) e.ino);
ERROR: code indent should never use tabs
#431: FILE: tools/virtiofsd/passthrough_ll.c:404:
+^I^I^I(unsigned long long) parent, name, (unsigned long long) e.ino);$
ERROR: code indent should never use tabs
#433: FILE: tools/virtiofsd/passthrough_ll.c:406:
+^Ifuse_reply_entry(req, &e);$
ERROR: code indent should never use tabs
#434: FILE: tools/virtiofsd/passthrough_ll.c:407:
+^Ireturn;$
ERROR: code indent should never use tabs
#437: FILE: tools/virtiofsd/passthrough_ll.c:410:
+^Ifuse_reply_err(req, saverr);$
ERROR: code indent should never use tabs
#441: FILE: tools/virtiofsd/passthrough_ll.c:414:
+^I^I const char *name, mode_t mode, dev_t rdev)$
ERROR: code indent should never use tabs
#443: FILE: tools/virtiofsd/passthrough_ll.c:416:
+^Ilo_mknod_symlink(req, parent, name, mode, rdev, NULL);$
ERROR: code indent should never use tabs
#447: FILE: tools/virtiofsd/passthrough_ll.c:420:
+^I^I mode_t mode)$
ERROR: code indent should never use tabs
#449: FILE: tools/virtiofsd/passthrough_ll.c:422:
+^Ilo_mknod_symlink(req, parent, name, S_IFDIR | mode, 0, NULL);$
ERROR: code indent should never use tabs
#453: FILE: tools/virtiofsd/passthrough_ll.c:426:
+^I^I fuse_ino_t parent, const char *name)$
ERROR: code indent should never use tabs
#455: FILE: tools/virtiofsd/passthrough_ll.c:428:
+^Ilo_mknod_symlink(req, parent, name, S_IFLNK, 0, link);$
ERROR: code indent should never use tabs
#459: FILE: tools/virtiofsd/passthrough_ll.c:432:
+^I^I^I^I const char *name)$
ERROR: code indent should never use tabs
#461: FILE: tools/virtiofsd/passthrough_ll.c:434:
+^Iint res;$
ERROR: code indent should never use tabs
#462: FILE: tools/virtiofsd/passthrough_ll.c:435:
+^Ichar procname[64];$
ERROR: code indent should never use tabs
#464: FILE: tools/virtiofsd/passthrough_ll.c:437:
+^Iif (inode->is_symlink) {$
ERROR: code indent should never use tabs
#465: FILE: tools/virtiofsd/passthrough_ll.c:438:
+^I^Ires = linkat(inode->fd, "", dfd, name, AT_EMPTY_PATH);$
ERROR: code indent should never use tabs
#466: FILE: tools/virtiofsd/passthrough_ll.c:439:
+^I^Iif (res == -1 && (errno == ENOENT || errno == EINVAL)) {$
ERROR: code indent should never use tabs
#467: FILE: tools/virtiofsd/passthrough_ll.c:440:
+^I^I^I/* Sorry, no race free way to hard-link a symlink. */$
ERROR: code indent should never use tabs
#468: FILE: tools/virtiofsd/passthrough_ll.c:441:
+^I^I^Ierrno = EPERM;$
ERROR: code indent should never use tabs
#469: FILE: tools/virtiofsd/passthrough_ll.c:442:
+^I^I}$
ERROR: code indent should never use tabs
#470: FILE: tools/virtiofsd/passthrough_ll.c:443:
+^I^Ireturn res;$
ERROR: code indent should never use tabs
#471: FILE: tools/virtiofsd/passthrough_ll.c:444:
+^I}$
ERROR: code indent should never use tabs
#473: FILE: tools/virtiofsd/passthrough_ll.c:446:
+^Isprintf(procname, "/proc/self/fd/%i", inode->fd);$
ERROR: code indent should never use tabs
#475: FILE: tools/virtiofsd/passthrough_ll.c:448:
+^Ireturn linkat(AT_FDCWD, procname, dfd, name, AT_SYMLINK_FOLLOW);$
ERROR: code indent should never use tabs
#479: FILE: tools/virtiofsd/passthrough_ll.c:452:
+^I^I const char *name)$
ERROR: code indent should never use tabs
#481: FILE: tools/virtiofsd/passthrough_ll.c:454:
+^Iint res;$
ERROR: code indent should never use tabs
#482: FILE: tools/virtiofsd/passthrough_ll.c:455:
+^Istruct lo_data *lo = lo_data(req);$
ERROR: code indent should never use tabs
#483: FILE: tools/virtiofsd/passthrough_ll.c:456:
+^Istruct lo_inode *inode = lo_inode(req, ino);$
ERROR: code indent should never use tabs
#484: FILE: tools/virtiofsd/passthrough_ll.c:457:
+^Istruct fuse_entry_param e;$
ERROR: code indent should never use tabs
#485: FILE: tools/virtiofsd/passthrough_ll.c:458:
+^Iint saverr;$
ERROR: code indent should never use tabs
#487: FILE: tools/virtiofsd/passthrough_ll.c:460:
+^Imemset(&e, 0, sizeof(struct fuse_entry_param));$
ERROR: code indent should never use tabs
#488: FILE: tools/virtiofsd/passthrough_ll.c:461:
+^Ie.attr_timeout = lo->timeout;$
ERROR: code indent should never use tabs
#489: FILE: tools/virtiofsd/passthrough_ll.c:462:
+^Ie.entry_timeout = lo->timeout;$
ERROR: code indent should never use tabs
#491: FILE: tools/virtiofsd/passthrough_ll.c:464:
+^Ires = linkat_empty_nofollow(inode, lo_fd(req, parent), name);$
ERROR: code indent should never use tabs
#492: FILE: tools/virtiofsd/passthrough_ll.c:465:
+^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#492: FILE: tools/virtiofsd/passthrough_ll.c:465:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#493: FILE: tools/virtiofsd/passthrough_ll.c:466:
+^I^Igoto out_err;$
WARNING: line over 80 characters
#495: FILE: tools/virtiofsd/passthrough_ll.c:468:
+ res = fstatat(inode->fd, "", &e.attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);
ERROR: code indent should never use tabs
#495: FILE: tools/virtiofsd/passthrough_ll.c:468:
+^Ires = fstatat(inode->fd, "", &e.attr, AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW);$
ERROR: code indent should never use tabs
#496: FILE: tools/virtiofsd/passthrough_ll.c:469:
+^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#496: FILE: tools/virtiofsd/passthrough_ll.c:469:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#497: FILE: tools/virtiofsd/passthrough_ll.c:470:
+^I^Igoto out_err;$
ERROR: code indent should never use tabs
#499: FILE: tools/virtiofsd/passthrough_ll.c:472:
+^Ipthread_mutex_lock(&lo->mutex);$
ERROR: code indent should never use tabs
#500: FILE: tools/virtiofsd/passthrough_ll.c:473:
+^Iinode->refcount++;$
ERROR: code indent should never use tabs
#501: FILE: tools/virtiofsd/passthrough_ll.c:474:
+^Ipthread_mutex_unlock(&lo->mutex);$
ERROR: code indent should never use tabs
#502: FILE: tools/virtiofsd/passthrough_ll.c:475:
+^Ie.ino = (uintptr_t) inode;$
ERROR: code indent should never use tabs
#504: FILE: tools/virtiofsd/passthrough_ll.c:477:
+^Iif (lo_debug(req))$
ERROR: code indent should never use tabs
#505: FILE: tools/virtiofsd/passthrough_ll.c:478:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",$
ERROR: code indent should never use tabs
#506: FILE: tools/virtiofsd/passthrough_ll.c:479:
+^I^I^I(unsigned long long) parent, name,$
ERROR: code indent should never use tabs
#507: FILE: tools/virtiofsd/passthrough_ll.c:480:
+^I^I^I(unsigned long long) e.ino);$
ERROR: code indent should never use tabs
#509: FILE: tools/virtiofsd/passthrough_ll.c:482:
+^Ifuse_reply_entry(req, &e);$
ERROR: code indent should never use tabs
#510: FILE: tools/virtiofsd/passthrough_ll.c:483:
+^Ireturn;$
ERROR: code indent should never use tabs
#513: FILE: tools/virtiofsd/passthrough_ll.c:486:
+^Isaverr = errno;$
ERROR: code indent should never use tabs
#514: FILE: tools/virtiofsd/passthrough_ll.c:487:
+^Ifuse_reply_err(req, saverr);$
ERROR: code indent should never use tabs
#519: FILE: tools/virtiofsd/passthrough_ll.c:492:
+^Iint res;$
ERROR: code indent should never use tabs
#521: FILE: tools/virtiofsd/passthrough_ll.c:494:
+^Ires = unlinkat(lo_fd(req, parent), name, AT_REMOVEDIR);$
ERROR: code indent should never use tabs
#523: FILE: tools/virtiofsd/passthrough_ll.c:496:
+^Ifuse_reply_err(req, res == -1 ? errno : 0);$
ERROR: code indent should never use tabs
#527: FILE: tools/virtiofsd/passthrough_ll.c:500:
+^I^I fuse_ino_t newparent, const char *newname,$
ERROR: code indent should never use tabs
#528: FILE: tools/virtiofsd/passthrough_ll.c:501:
+^I^I unsigned int flags)$
ERROR: code indent should never use tabs
#530: FILE: tools/virtiofsd/passthrough_ll.c:503:
+^Iint res;$
ERROR: code indent should never use tabs
#532: FILE: tools/virtiofsd/passthrough_ll.c:505:
+^Iif (flags) {$
ERROR: code indent should never use tabs
#533: FILE: tools/virtiofsd/passthrough_ll.c:506:
+^I^Ifuse_reply_err(req, EINVAL);$
ERROR: code indent should never use tabs
#534: FILE: tools/virtiofsd/passthrough_ll.c:507:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#535: FILE: tools/virtiofsd/passthrough_ll.c:508:
+^I}$
ERROR: code indent should never use tabs
#537: FILE: tools/virtiofsd/passthrough_ll.c:510:
+^Ires = renameat(lo_fd(req, parent), name,$
ERROR: code indent should never use tabs
#538: FILE: tools/virtiofsd/passthrough_ll.c:511:
+^I^I^Ilo_fd(req, newparent), newname);$
ERROR: code indent should never use tabs
#540: FILE: tools/virtiofsd/passthrough_ll.c:513:
+^Ifuse_reply_err(req, res == -1 ? errno : 0);$
ERROR: code indent should never use tabs
#545: FILE: tools/virtiofsd/passthrough_ll.c:518:
+^Iint res;$
ERROR: code indent should never use tabs
#547: FILE: tools/virtiofsd/passthrough_ll.c:520:
+^Ires = unlinkat(lo_fd(req, parent), name, 0);$
ERROR: code indent should never use tabs
#549: FILE: tools/virtiofsd/passthrough_ll.c:522:
+^Ifuse_reply_err(req, res == -1 ? errno : 0);$
ERROR: code indent should never use tabs
#554: FILE: tools/virtiofsd/passthrough_ll.c:527:
+^Iif (!inode)$
ERROR: braces {} are necessary for all arms of this statement
#554: FILE: tools/virtiofsd/passthrough_ll.c:527:
+ if (!inode)
[...]
ERROR: code indent should never use tabs
#555: FILE: tools/virtiofsd/passthrough_ll.c:528:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#557: FILE: tools/virtiofsd/passthrough_ll.c:530:
+^Ipthread_mutex_lock(&lo->mutex);$
ERROR: code indent should never use tabs
#558: FILE: tools/virtiofsd/passthrough_ll.c:531:
+^Iassert(inode->refcount >= n);$
ERROR: code indent should never use tabs
#559: FILE: tools/virtiofsd/passthrough_ll.c:532:
+^Iinode->refcount -= n;$
ERROR: code indent should never use tabs
#560: FILE: tools/virtiofsd/passthrough_ll.c:533:
+^Iif (!inode->refcount) {$
ERROR: code indent should never use tabs
#561: FILE: tools/virtiofsd/passthrough_ll.c:534:
+^I^Istruct lo_inode *prev, *next;$
ERROR: code indent should never use tabs
#563: FILE: tools/virtiofsd/passthrough_ll.c:536:
+^I^Iprev = inode->prev;$
ERROR: code indent should never use tabs
#564: FILE: tools/virtiofsd/passthrough_ll.c:537:
+^I^Inext = inode->next;$
ERROR: code indent should never use tabs
#565: FILE: tools/virtiofsd/passthrough_ll.c:538:
+^I^Inext->prev = prev;$
ERROR: code indent should never use tabs
#566: FILE: tools/virtiofsd/passthrough_ll.c:539:
+^I^Iprev->next = next;$
ERROR: code indent should never use tabs
#568: FILE: tools/virtiofsd/passthrough_ll.c:541:
+^I^Ipthread_mutex_unlock(&lo->mutex);$
ERROR: code indent should never use tabs
#569: FILE: tools/virtiofsd/passthrough_ll.c:542:
+^I^Iclose(inode->fd);$
ERROR: code indent should never use tabs
#570: FILE: tools/virtiofsd/passthrough_ll.c:543:
+^I^Ifree(inode);$
ERROR: code indent should never use tabs
#572: FILE: tools/virtiofsd/passthrough_ll.c:545:
+^I} else {$
ERROR: code indent should never use tabs
#573: FILE: tools/virtiofsd/passthrough_ll.c:546:
+^I^Ipthread_mutex_unlock(&lo->mutex);$
ERROR: code indent should never use tabs
#574: FILE: tools/virtiofsd/passthrough_ll.c:547:
+^I}$
ERROR: code indent should never use tabs
#579: FILE: tools/virtiofsd/passthrough_ll.c:552:
+^Istruct lo_data *lo = lo_data(req);$
ERROR: code indent should never use tabs
#580: FILE: tools/virtiofsd/passthrough_ll.c:553:
+^Istruct lo_inode *inode = lo_inode(req, ino);$
ERROR: code indent should never use tabs
#582: FILE: tools/virtiofsd/passthrough_ll.c:555:
+^Iif (lo_debug(req)) {$
ERROR: code indent should never use tabs
#583: FILE: tools/virtiofsd/passthrough_ll.c:556:
+^I^Ifuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",$
ERROR: code indent should never use tabs
#584: FILE: tools/virtiofsd/passthrough_ll.c:557:
+^I^I^I(unsigned long long) ino,$
ERROR: code indent should never use tabs
#585: FILE: tools/virtiofsd/passthrough_ll.c:558:
+^I^I^I(unsigned long long) inode->refcount,$
ERROR: code indent should never use tabs
#586: FILE: tools/virtiofsd/passthrough_ll.c:559:
+^I^I^I(unsigned long long) nlookup);$
ERROR: code indent should never use tabs
#587: FILE: tools/virtiofsd/passthrough_ll.c:560:
+^I}$
ERROR: code indent should never use tabs
#589: FILE: tools/virtiofsd/passthrough_ll.c:562:
+^Iunref_inode(lo, inode, nlookup);$
ERROR: code indent should never use tabs
#594: FILE: tools/virtiofsd/passthrough_ll.c:567:
+^Ilo_forget_one(req, ino, nlookup);$
ERROR: code indent should never use tabs
#595: FILE: tools/virtiofsd/passthrough_ll.c:568:
+^Ifuse_reply_none(req);$
ERROR: code indent should never use tabs
#599: FILE: tools/virtiofsd/passthrough_ll.c:572:
+^I^I^I^Istruct fuse_forget_data *forgets)$
ERROR: code indent should never use tabs
#601: FILE: tools/virtiofsd/passthrough_ll.c:574:
+^Iint i;$
ERROR: code indent should never use tabs
#603: FILE: tools/virtiofsd/passthrough_ll.c:576:
+^Ifor (i = 0; i < count; i++)$
ERROR: braces {} are necessary for all arms of this statement
#603: FILE: tools/virtiofsd/passthrough_ll.c:576:
+ for (i = 0; i < count; i++)
[...]
ERROR: code indent should never use tabs
#604: FILE: tools/virtiofsd/passthrough_ll.c:577:
+^I^Ilo_forget_one(req, forgets[i].ino, forgets[i].nlookup);$
ERROR: code indent should never use tabs
#605: FILE: tools/virtiofsd/passthrough_ll.c:578:
+^Ifuse_reply_none(req);$
ERROR: code indent should never use tabs
#610: FILE: tools/virtiofsd/passthrough_ll.c:583:
+^Ichar buf[PATH_MAX + 1];$
ERROR: code indent should never use tabs
#611: FILE: tools/virtiofsd/passthrough_ll.c:584:
+^Iint res;$
ERROR: code indent should never use tabs
#613: FILE: tools/virtiofsd/passthrough_ll.c:586:
+^Ires = readlinkat(lo_fd(req, ino), "", buf, sizeof(buf));$
ERROR: code indent should never use tabs
#614: FILE: tools/virtiofsd/passthrough_ll.c:587:
+^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#614: FILE: tools/virtiofsd/passthrough_ll.c:587:
+ if (res == -1)
[...]
ERROR: code indent should never use tabs
#615: FILE: tools/virtiofsd/passthrough_ll.c:588:
+^I^Ireturn (void) fuse_reply_err(req, errno);$
ERROR: code indent should never use tabs
#617: FILE: tools/virtiofsd/passthrough_ll.c:590:
+^Iif (res == sizeof(buf))$
ERROR: braces {} are necessary for all arms of this statement
#617: FILE: tools/virtiofsd/passthrough_ll.c:590:
+ if (res == sizeof(buf))
[...]
ERROR: code indent should never use tabs
#618: FILE: tools/virtiofsd/passthrough_ll.c:591:
+^I^Ireturn (void) fuse_reply_err(req, ENAMETOOLONG);$
ERROR: code indent should never use tabs
#620: FILE: tools/virtiofsd/passthrough_ll.c:593:
+^Ibuf[res] = '\0';$
ERROR: code indent should never use tabs
#622: FILE: tools/virtiofsd/passthrough_ll.c:595:
+^Ifuse_reply_readlink(req, buf);$
ERROR: code indent should never use tabs
#626: FILE: tools/virtiofsd/passthrough_ll.c:599:
+^IDIR *dp;$
ERROR: code indent should never use tabs
#627: FILE: tools/virtiofsd/passthrough_ll.c:600:
+^Istruct dirent *entry;$
ERROR: code indent should never use tabs
#628: FILE: tools/virtiofsd/passthrough_ll.c:601:
+^Ioff_t offset;$
ERROR: code indent should never use tabs
#633: FILE: tools/virtiofsd/passthrough_ll.c:606:
+^Ireturn (struct lo_dirp *) (uintptr_t) fi->fh;$
WARNING: line over 80 characters
#636: FILE: tools/virtiofsd/passthrough_ll.c:609:
+static void lo_opendir(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
ERROR: code indent should never use tabs
#638: FILE: tools/virtiofsd/passthrough_ll.c:611:
+^Iint error = ENOMEM;$
ERROR: code indent should never use tabs
#639: FILE: tools/virtiofsd/passthrough_ll.c:612:
+^Istruct lo_data *lo = lo_data(req);$
ERROR: code indent should never use tabs
#640: FILE: tools/virtiofsd/passthrough_ll.c:613:
+^Istruct lo_dirp *d;$
ERROR: code indent should never use tabs
#641: FILE: tools/virtiofsd/passthrough_ll.c:614:
+^Iint fd;$
ERROR: code indent should never use tabs
#643: FILE: tools/virtiofsd/passthrough_ll.c:616:
+^Id = calloc(1, sizeof(struct lo_dirp));$
ERROR: code indent should never use tabs
#644: FILE: tools/virtiofsd/passthrough_ll.c:617:
+^Iif (d == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#644: FILE: tools/virtiofsd/passthrough_ll.c:617:
+ if (d == NULL)
[...]
ERROR: code indent should never use tabs
#645: FILE: tools/virtiofsd/passthrough_ll.c:618:
+^I^Igoto out_err;$
ERROR: code indent should never use tabs
#647: FILE: tools/virtiofsd/passthrough_ll.c:620:
+^Ifd = openat(lo_fd(req, ino), ".", O_RDONLY);$
ERROR: code indent should never use tabs
#648: FILE: tools/virtiofsd/passthrough_ll.c:621:
+^Iif (fd == -1)$
ERROR: braces {} are necessary for all arms of this statement
#648: FILE: tools/virtiofsd/passthrough_ll.c:621:
+ if (fd == -1)
[...]
ERROR: code indent should never use tabs
#649: FILE: tools/virtiofsd/passthrough_ll.c:622:
+^I^Igoto out_errno;$
ERROR: code indent should never use tabs
#651: FILE: tools/virtiofsd/passthrough_ll.c:624:
+^Id->dp = fdopendir(fd);$
ERROR: code indent should never use tabs
#652: FILE: tools/virtiofsd/passthrough_ll.c:625:
+^Iif (d->dp == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#652: FILE: tools/virtiofsd/passthrough_ll.c:625:
+ if (d->dp == NULL)
[...]
ERROR: code indent should never use tabs
#653: FILE: tools/virtiofsd/passthrough_ll.c:626:
+^I^Igoto out_errno;$
ERROR: code indent should never use tabs
#655: FILE: tools/virtiofsd/passthrough_ll.c:628:
+^Id->offset = 0;$
ERROR: code indent should never use tabs
#656: FILE: tools/virtiofsd/passthrough_ll.c:629:
+^Id->entry = NULL;$
ERROR: code indent should never use tabs
#658: FILE: tools/virtiofsd/passthrough_ll.c:631:
+^Ifi->fh = (uintptr_t) d;$
ERROR: code indent should never use tabs
#659: FILE: tools/virtiofsd/passthrough_ll.c:632:
+^Iif (lo->cache == CACHE_ALWAYS)$
ERROR: braces {} are necessary for all arms of this statement
#659: FILE: tools/virtiofsd/passthrough_ll.c:632:
+ if (lo->cache == CACHE_ALWAYS)
[...]
ERROR: code indent should never use tabs
#660: FILE: tools/virtiofsd/passthrough_ll.c:633:
+^I^Ifi->keep_cache = 1;$
ERROR: code indent should never use tabs
#661: FILE: tools/virtiofsd/passthrough_ll.c:634:
+^Ifuse_reply_open(req, fi);$
ERROR: code indent should never use tabs
#662: FILE: tools/virtiofsd/passthrough_ll.c:635:
+^Ireturn;$
ERROR: code indent should never use tabs
#665: FILE: tools/virtiofsd/passthrough_ll.c:638:
+^Ierror = errno;$
ERROR: code indent should never use tabs
#667: FILE: tools/virtiofsd/passthrough_ll.c:640:
+^Iif (d) {$
ERROR: code indent should never use tabs
#668: FILE: tools/virtiofsd/passthrough_ll.c:641:
+^I^Iif (fd != -1)$
ERROR: braces {} are necessary for all arms of this statement
#668: FILE: tools/virtiofsd/passthrough_ll.c:641:
+ if (fd != -1)
[...]
ERROR: code indent should never use tabs
#669: FILE: tools/virtiofsd/passthrough_ll.c:642:
+^I^I^Iclose(fd);$
ERROR: code indent should never use tabs
#670: FILE: tools/virtiofsd/passthrough_ll.c:643:
+^I^Ifree(d);$
ERROR: code indent should never use tabs
#671: FILE: tools/virtiofsd/passthrough_ll.c:644:
+^I}$
ERROR: code indent should never use tabs
#672: FILE: tools/virtiofsd/passthrough_ll.c:645:
+^Ifuse_reply_err(req, error);$
ERROR: code indent should never use tabs
#677: FILE: tools/virtiofsd/passthrough_ll.c:650:
+^Ireturn name[0] == '.' && (name[1] == '\0' ||$
ERROR: code indent should never use tabs
#678: FILE: tools/virtiofsd/passthrough_ll.c:651:
+^I^I^I^I (name[1] == '.' && name[2] == '\0'));$
ERROR: code indent should never use tabs
#682: FILE: tools/virtiofsd/passthrough_ll.c:655:
+^I^I^I off_t offset, struct fuse_file_info *fi, int plus)$
ERROR: code indent should never use tabs
#684: FILE: tools/virtiofsd/passthrough_ll.c:657:
+^Istruct lo_dirp *d = lo_dirp(fi);$
ERROR: code indent should never use tabs
#685: FILE: tools/virtiofsd/passthrough_ll.c:658:
+^Ichar *buf;$
ERROR: code indent should never use tabs
#686: FILE: tools/virtiofsd/passthrough_ll.c:659:
+^Ichar *p;$
ERROR: code indent should never use tabs
#687: FILE: tools/virtiofsd/passthrough_ll.c:660:
+^Isize_t rem = size;$
ERROR: code indent should never use tabs
#688: FILE: tools/virtiofsd/passthrough_ll.c:661:
+^Iint err;$
ERROR: code indent should never use tabs
#690: FILE: tools/virtiofsd/passthrough_ll.c:663:
+^I(void) ino;$
ERROR: code indent should never use tabs
#692: FILE: tools/virtiofsd/passthrough_ll.c:665:
+^Ibuf = calloc(1, size);$
ERROR: code indent should never use tabs
#693: FILE: tools/virtiofsd/passthrough_ll.c:666:
+^Iif (!buf) {$
ERROR: code indent should never use tabs
#694: FILE: tools/virtiofsd/passthrough_ll.c:667:
+^I^Ierr = ENOMEM;$
ERROR: code indent should never use tabs
#695: FILE: tools/virtiofsd/passthrough_ll.c:668:
+^I^Igoto error;$
ERROR: code indent should never use tabs
#696: FILE: tools/virtiofsd/passthrough_ll.c:669:
+^I}$
ERROR: code indent should never use tabs
#697: FILE: tools/virtiofsd/passthrough_ll.c:670:
+^Ip = buf;$
ERROR: code indent should never use tabs
#699: FILE: tools/virtiofsd/passthrough_ll.c:672:
+^Iif (offset != d->offset) {$
ERROR: code indent should never use tabs
#700: FILE: tools/virtiofsd/passthrough_ll.c:673:
+^I^Iseekdir(d->dp, offset);$
ERROR: code indent should never use tabs
#701: FILE: tools/virtiofsd/passthrough_ll.c:674:
+^I^Id->entry = NULL;$
ERROR: code indent should never use tabs
#702: FILE: tools/virtiofsd/passthrough_ll.c:675:
+^I^Id->offset = offset;$
ERROR: code indent should never use tabs
#703: FILE: tools/virtiofsd/passthrough_ll.c:676:
+^I}$
ERROR: code indent should never use tabs
#704: FILE: tools/virtiofsd/passthrough_ll.c:677:
+^Iwhile (1) {$
ERROR: code indent should never use tabs
#705: FILE: tools/virtiofsd/passthrough_ll.c:678:
+^I^Isize_t entsize;$
ERROR: code indent should never use tabs
#706: FILE: tools/virtiofsd/passthrough_ll.c:679:
+^I^Ioff_t nextoff;$
ERROR: code indent should never use tabs
#707: FILE: tools/virtiofsd/passthrough_ll.c:680:
+^I^Iconst char *name;$
ERROR: code indent should never use tabs
#709: FILE: tools/virtiofsd/passthrough_ll.c:682:
+^I^Iif (!d->entry) {$
ERROR: code indent should never use tabs
#710: FILE: tools/virtiofsd/passthrough_ll.c:683:
+^I^I^Ierrno = 0;$
ERROR: code indent should never use tabs
#711: FILE: tools/virtiofsd/passthrough_ll.c:684:
+^I^I^Id->entry = readdir(d->dp);$
ERROR: code indent should never use tabs
#712: FILE: tools/virtiofsd/passthrough_ll.c:685:
+^I^I^Iif (!d->entry) {$
ERROR: code indent should never use tabs
#713: FILE: tools/virtiofsd/passthrough_ll.c:686:
+^I^I^I^Iif (errno) { // Error$
ERROR: do not use C99 // comments
#713: FILE: tools/virtiofsd/passthrough_ll.c:686:
+ if (errno) { // Error
ERROR: trailing statements should be on next line
#713: FILE: tools/virtiofsd/passthrough_ll.c:686:
+ if (errno) { // Error
ERROR: code indent should never use tabs
#714: FILE: tools/virtiofsd/passthrough_ll.c:687:
+^I^I^I^I^Ierr = errno;$
ERROR: code indent should never use tabs
#715: FILE: tools/virtiofsd/passthrough_ll.c:688:
+^I^I^I^I^Igoto error;$
ERROR: code indent should never use tabs
#716: FILE: tools/virtiofsd/passthrough_ll.c:689:
+^I^I^I^I} else { // End of stream$
ERROR: do not use C99 // comments
#716: FILE: tools/virtiofsd/passthrough_ll.c:689:
+ } else { // End of stream
ERROR: trailing whitespace
#717: FILE: tools/virtiofsd/passthrough_ll.c:690:
+^I^I^I^I^Ibreak; $
ERROR: code indent should never use tabs
#717: FILE: tools/virtiofsd/passthrough_ll.c:690:
+^I^I^I^I^Ibreak; $
ERROR: code indent should never use tabs
#718: FILE: tools/virtiofsd/passthrough_ll.c:691:
+^I^I^I^I}$
ERROR: code indent should never use tabs
#719: FILE: tools/virtiofsd/passthrough_ll.c:692:
+^I^I^I}$
ERROR: code indent should never use tabs
#720: FILE: tools/virtiofsd/passthrough_ll.c:693:
+^I^I}$
ERROR: code indent should never use tabs
#721: FILE: tools/virtiofsd/passthrough_ll.c:694:
+^I^Inextoff = d->entry->d_off;$
ERROR: code indent should never use tabs
#722: FILE: tools/virtiofsd/passthrough_ll.c:695:
+^I^Iname = d->entry->d_name;$
ERROR: code indent should never use tabs
#723: FILE: tools/virtiofsd/passthrough_ll.c:696:
+^I^Ifuse_ino_t entry_ino = 0;$
ERROR: code indent should never use tabs
#724: FILE: tools/virtiofsd/passthrough_ll.c:697:
+^I^Iif (plus) {$
ERROR: code indent should never use tabs
#725: FILE: tools/virtiofsd/passthrough_ll.c:698:
+^I^I^Istruct fuse_entry_param e;$
ERROR: code indent should never use tabs
#726: FILE: tools/virtiofsd/passthrough_ll.c:699:
+^I^I^Iif (is_dot_or_dotdot(name)) {$
ERROR: code indent should never use tabs
#727: FILE: tools/virtiofsd/passthrough_ll.c:700:
+^I^I^I^Ie = (struct fuse_entry_param) {$
ERROR: code indent should never use tabs
#728: FILE: tools/virtiofsd/passthrough_ll.c:701:
+^I^I^I^I^I.attr.st_ino = d->entry->d_ino,$
ERROR: code indent should never use tabs
#729: FILE: tools/virtiofsd/passthrough_ll.c:702:
+^I^I^I^I^I.attr.st_mode = d->entry->d_type << 12,$
ERROR: code indent should never use tabs
#730: FILE: tools/virtiofsd/passthrough_ll.c:703:
+^I^I^I^I};$
ERROR: code indent should never use tabs
#731: FILE: tools/virtiofsd/passthrough_ll.c:704:
+^I^I^I} else {$
ERROR: code indent should never use tabs
#732: FILE: tools/virtiofsd/passthrough_ll.c:705:
+^I^I^I^Ierr = lo_do_lookup(req, ino, name, &e);$
ERROR: code indent should never use tabs
#733: FILE: tools/virtiofsd/passthrough_ll.c:706:
+^I^I^I^Iif (err)$
ERROR: braces {} are necessary for all arms of this statement
#733: FILE: tools/virtiofsd/passthrough_ll.c:706:
+ if (err)
[...]
ERROR: code indent should never use tabs
#734: FILE: tools/virtiofsd/passthrough_ll.c:707:
+^I^I^I^I^Igoto error;$
ERROR: code indent should never use tabs
#735: FILE: tools/virtiofsd/passthrough_ll.c:708:
+^I^I^I^Ientry_ino = e.ino;$
ERROR: code indent should never use tabs
#736: FILE: tools/virtiofsd/passthrough_ll.c:709:
+^I^I^I}$
ERROR: code indent should never use tabs
#738: FILE: tools/virtiofsd/passthrough_ll.c:711:
+^I^I^Ientsize = fuse_add_direntry_plus(req, p, rem, name,$
ERROR: code indent should never use tabs
#739: FILE: tools/virtiofsd/passthrough_ll.c:712:
+^I^I^I^I^I^I^I &e, nextoff);$
ERROR: code indent should never use tabs
#740: FILE: tools/virtiofsd/passthrough_ll.c:713:
+^I^I} else {$
ERROR: code indent should never use tabs
#741: FILE: tools/virtiofsd/passthrough_ll.c:714:
+^I^I^Istruct stat st = {$
ERROR: code indent should never use tabs
#742: FILE: tools/virtiofsd/passthrough_ll.c:715:
+^I^I^I^I.st_ino = d->entry->d_ino,$
ERROR: code indent should never use tabs
#743: FILE: tools/virtiofsd/passthrough_ll.c:716:
+^I^I^I^I.st_mode = d->entry->d_type << 12,$
ERROR: code indent should never use tabs
#744: FILE: tools/virtiofsd/passthrough_ll.c:717:
+^I^I^I};$
ERROR: code indent should never use tabs
#745: FILE: tools/virtiofsd/passthrough_ll.c:718:
+^I^I^Ientsize = fuse_add_direntry(req, p, rem, name,$
ERROR: code indent should never use tabs
#746: FILE: tools/virtiofsd/passthrough_ll.c:719:
+^I^I^I^I^I^I &st, nextoff);$
ERROR: code indent should never use tabs
#747: FILE: tools/virtiofsd/passthrough_ll.c:720:
+^I^I}$
ERROR: code indent should never use tabs
#748: FILE: tools/virtiofsd/passthrough_ll.c:721:
+^I^Iif (entsize > rem) {$
ERROR: trailing whitespace
#749: FILE: tools/virtiofsd/passthrough_ll.c:722:
+^I^I^Iif (entry_ino != 0) $
ERROR: code indent should never use tabs
#749: FILE: tools/virtiofsd/passthrough_ll.c:722:
+^I^I^Iif (entry_ino != 0) $
ERROR: braces {} are necessary for all arms of this statement
#749: FILE: tools/virtiofsd/passthrough_ll.c:722:
+ if (entry_ino != 0)
[...]
ERROR: code indent should never use tabs
#750: FILE: tools/virtiofsd/passthrough_ll.c:723:
+^I^I^I^Ilo_forget_one(req, entry_ino, 1);$
ERROR: code indent should never use tabs
#751: FILE: tools/virtiofsd/passthrough_ll.c:724:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#752: FILE: tools/virtiofsd/passthrough_ll.c:725:
+^I^I}$
ERROR: trailing whitespace
#753: FILE: tools/virtiofsd/passthrough_ll.c:726:
+^I^I$
ERROR: code indent should never use tabs
#753: FILE: tools/virtiofsd/passthrough_ll.c:726:
+^I^I$
ERROR: code indent should never use tabs
#754: FILE: tools/virtiofsd/passthrough_ll.c:727:
+^I^Ip += entsize;$
ERROR: code indent should never use tabs
#755: FILE: tools/virtiofsd/passthrough_ll.c:728:
+^I^Irem -= entsize;$
ERROR: code indent should never use tabs
#757: FILE: tools/virtiofsd/passthrough_ll.c:730:
+^I^Id->entry = NULL;$
ERROR: code indent should never use tabs
#758: FILE: tools/virtiofsd/passthrough_ll.c:731:
+^I^Id->offset = nextoff;$
ERROR: code indent should never use tabs
#759: FILE: tools/virtiofsd/passthrough_ll.c:732:
+^I}$
ERROR: do not use C99 // comments
#763: FILE: tools/virtiofsd/passthrough_ll.c:736:
+ // If there's an error, we can only signal it if we haven't stored
ERROR: do not use C99 // comments
#764: FILE: tools/virtiofsd/passthrough_ll.c:737:
+ // any entries yet - otherwise we'd end up with wrong lookup
ERROR: do not use C99 // comments
#765: FILE: tools/virtiofsd/passthrough_ll.c:738:
+ // counts for the entries that are already in the buffer. So we
ERROR: do not use C99 // comments
#766: FILE: tools/virtiofsd/passthrough_ll.c:739:
+ // return what we've collected until that point.
ERROR: braces {} are necessary for all arms of this statement
#767: FILE: tools/virtiofsd/passthrough_ll.c:740:
+ if (err && rem == size)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#768: FILE: tools/virtiofsd/passthrough_ll.c:741:
+^I fuse_reply_err(req, err);$
ERROR: code indent should never use tabs
#770: FILE: tools/virtiofsd/passthrough_ll.c:743:
+^I fuse_reply_buf(req, buf, size - rem);$
ERROR: code indent should never use tabs
#775: FILE: tools/virtiofsd/passthrough_ll.c:748:
+^I^I off_t offset, struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#777: FILE: tools/virtiofsd/passthrough_ll.c:750:
+^Ilo_do_readdir(req, ino, size, offset, fi, 0);$
ERROR: code indent should never use tabs
#781: FILE: tools/virtiofsd/passthrough_ll.c:754:
+^I^I^I off_t offset, struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#783: FILE: tools/virtiofsd/passthrough_ll.c:756:
+^Ilo_do_readdir(req, ino, size, offset, fi, 1);$
WARNING: line over 80 characters
#786: FILE: tools/virtiofsd/passthrough_ll.c:759:
+static void lo_releasedir(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
ERROR: code indent should never use tabs
#788: FILE: tools/virtiofsd/passthrough_ll.c:761:
+^Istruct lo_dirp *d = lo_dirp(fi);$
ERROR: code indent should never use tabs
#789: FILE: tools/virtiofsd/passthrough_ll.c:762:
+^I(void) ino;$
ERROR: code indent should never use tabs
#790: FILE: tools/virtiofsd/passthrough_ll.c:763:
+^Iclosedir(d->dp);$
ERROR: code indent should never use tabs
#791: FILE: tools/virtiofsd/passthrough_ll.c:764:
+^Ifree(d);$
ERROR: code indent should never use tabs
#792: FILE: tools/virtiofsd/passthrough_ll.c:765:
+^Ifuse_reply_err(req, 0);$
ERROR: code indent should never use tabs
#796: FILE: tools/virtiofsd/passthrough_ll.c:769:
+^I^I mode_t mode, struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#798: FILE: tools/virtiofsd/passthrough_ll.c:771:
+^Iint fd;$
ERROR: code indent should never use tabs
#799: FILE: tools/virtiofsd/passthrough_ll.c:772:
+^Istruct lo_data *lo = lo_data(req);$
ERROR: code indent should never use tabs
#800: FILE: tools/virtiofsd/passthrough_ll.c:773:
+^Istruct fuse_entry_param e;$
ERROR: code indent should never use tabs
#801: FILE: tools/virtiofsd/passthrough_ll.c:774:
+^Iint err;$
ERROR: code indent should never use tabs
#803: FILE: tools/virtiofsd/passthrough_ll.c:776:
+^Iif (lo_debug(req))$
WARNING: line over 80 characters
#804: FILE: tools/virtiofsd/passthrough_ll.c:777:
+ fuse_log(FUSE_LOG_DEBUG, "lo_create(parent=%" PRIu64 ", name=%s)\n",
ERROR: code indent should never use tabs
#804: FILE: tools/virtiofsd/passthrough_ll.c:777:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_create(parent=%" PRIu64 ", name=%s)\n",$
ERROR: code indent should never use tabs
#805: FILE: tools/virtiofsd/passthrough_ll.c:778:
+^I^I^Iparent, name);$
ERROR: code indent should never use tabs
#807: FILE: tools/virtiofsd/passthrough_ll.c:780:
+^Ifd = openat(lo_fd(req, parent), name,$
ERROR: code indent should never use tabs
#808: FILE: tools/virtiofsd/passthrough_ll.c:781:
+^I^I (fi->flags | O_CREAT) & ~O_NOFOLLOW, mode);$
ERROR: code indent should never use tabs
#809: FILE: tools/virtiofsd/passthrough_ll.c:782:
+^Iif (fd == -1)$
ERROR: braces {} are necessary for all arms of this statement
#809: FILE: tools/virtiofsd/passthrough_ll.c:782:
+ if (fd == -1)
[...]
ERROR: code indent should never use tabs
#810: FILE: tools/virtiofsd/passthrough_ll.c:783:
+^I^Ireturn (void) fuse_reply_err(req, errno);$
ERROR: code indent should never use tabs
#812: FILE: tools/virtiofsd/passthrough_ll.c:785:
+^Ifi->fh = fd;$
ERROR: code indent should never use tabs
#813: FILE: tools/virtiofsd/passthrough_ll.c:786:
+^Iif (lo->cache == CACHE_NEVER)$
ERROR: braces {} are necessary for all arms of this statement
#813: FILE: tools/virtiofsd/passthrough_ll.c:786:
+ if (lo->cache == CACHE_NEVER)
[...]
+ else if (lo->cache == CACHE_ALWAYS)
[...]
ERROR: code indent should never use tabs
#814: FILE: tools/virtiofsd/passthrough_ll.c:787:
+^I^Ifi->direct_io = 1;$
ERROR: code indent should never use tabs
#815: FILE: tools/virtiofsd/passthrough_ll.c:788:
+^Ielse if (lo->cache == CACHE_ALWAYS)$
ERROR: braces {} are necessary for all arms of this statement
#815: FILE: tools/virtiofsd/passthrough_ll.c:788:
+ else if (lo->cache == CACHE_ALWAYS)
[...]
ERROR: code indent should never use tabs
#816: FILE: tools/virtiofsd/passthrough_ll.c:789:
+^I^Ifi->keep_cache = 1;$
ERROR: code indent should never use tabs
#818: FILE: tools/virtiofsd/passthrough_ll.c:791:
+^Ierr = lo_do_lookup(req, parent, name, &e);$
ERROR: code indent should never use tabs
#819: FILE: tools/virtiofsd/passthrough_ll.c:792:
+^Iif (err)$
ERROR: braces {} are necessary for all arms of this statement
#819: FILE: tools/virtiofsd/passthrough_ll.c:792:
+ if (err)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#820: FILE: tools/virtiofsd/passthrough_ll.c:793:
+^I^Ifuse_reply_err(req, err);$
ERROR: code indent should never use tabs
#821: FILE: tools/virtiofsd/passthrough_ll.c:794:
+^Ielse$
ERROR: code indent should never use tabs
#822: FILE: tools/virtiofsd/passthrough_ll.c:795:
+^I^Ifuse_reply_create(req, &e, fi);$
ERROR: code indent should never use tabs
#826: FILE: tools/virtiofsd/passthrough_ll.c:799:
+^I^I^Istruct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#828: FILE: tools/virtiofsd/passthrough_ll.c:801:
+^Iint res;$
ERROR: code indent should never use tabs
#829: FILE: tools/virtiofsd/passthrough_ll.c:802:
+^Iint fd = dirfd(lo_dirp(fi)->dp);$
ERROR: code indent should never use tabs
#830: FILE: tools/virtiofsd/passthrough_ll.c:803:
+^I(void) ino;$
ERROR: code indent should never use tabs
#831: FILE: tools/virtiofsd/passthrough_ll.c:804:
+^Iif (datasync)$
ERROR: braces {} are necessary for all arms of this statement
#831: FILE: tools/virtiofsd/passthrough_ll.c:804:
+ if (datasync)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#832: FILE: tools/virtiofsd/passthrough_ll.c:805:
+^I^Ires = fdatasync(fd);$
ERROR: code indent should never use tabs
#833: FILE: tools/virtiofsd/passthrough_ll.c:806:
+^Ielse$
ERROR: code indent should never use tabs
#834: FILE: tools/virtiofsd/passthrough_ll.c:807:
+^I^Ires = fsync(fd);$
ERROR: code indent should never use tabs
#835: FILE: tools/virtiofsd/passthrough_ll.c:808:
+^Ifuse_reply_err(req, res == -1 ? errno : 0);$
ERROR: code indent should never use tabs
#840: FILE: tools/virtiofsd/passthrough_ll.c:813:
+^Iint fd;$
ERROR: code indent should never use tabs
#841: FILE: tools/virtiofsd/passthrough_ll.c:814:
+^Ichar buf[64];$
ERROR: code indent should never use tabs
#842: FILE: tools/virtiofsd/passthrough_ll.c:815:
+^Istruct lo_data *lo = lo_data(req);$
ERROR: code indent should never use tabs
#844: FILE: tools/virtiofsd/passthrough_ll.c:817:
+^Iif (lo_debug(req))$
ERROR: code indent should never use tabs
#845: FILE: tools/virtiofsd/passthrough_ll.c:818:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_open(ino=%" PRIu64 ", flags=%d)\n",$
ERROR: code indent should never use tabs
#846: FILE: tools/virtiofsd/passthrough_ll.c:819:
+^I^I^Iino, fi->flags);$
ERROR: code indent should never use tabs
#848: FILE: tools/virtiofsd/passthrough_ll.c:821:
+^I/* With writeback cache, kernel may send read requests even$
WARNING: Block comments use a leading /* on a separate line
#848: FILE: tools/virtiofsd/passthrough_ll.c:821:
+ /* With writeback cache, kernel may send read requests even
ERROR: code indent should never use tabs
#849: FILE: tools/virtiofsd/passthrough_ll.c:822:
+^I when userspace opened write-only */$
WARNING: Block comments use * on subsequent lines
#849: FILE: tools/virtiofsd/passthrough_ll.c:822:
+ /* With writeback cache, kernel may send read requests even
+ when userspace opened write-only */
WARNING: Block comments use a trailing */ on a separate line
#849: FILE: tools/virtiofsd/passthrough_ll.c:822:
+ when userspace opened write-only */
ERROR: code indent should never use tabs
#850: FILE: tools/virtiofsd/passthrough_ll.c:823:
+^Iif (lo->writeback && (fi->flags & O_ACCMODE) == O_WRONLY) {$
ERROR: code indent should never use tabs
#851: FILE: tools/virtiofsd/passthrough_ll.c:824:
+^I^Ifi->flags &= ~O_ACCMODE;$
ERROR: code indent should never use tabs
#852: FILE: tools/virtiofsd/passthrough_ll.c:825:
+^I^Ifi->flags |= O_RDWR;$
ERROR: code indent should never use tabs
#853: FILE: tools/virtiofsd/passthrough_ll.c:826:
+^I}$
ERROR: code indent should never use tabs
#855: FILE: tools/virtiofsd/passthrough_ll.c:828:
+^I/* With writeback cache, O_APPEND is handled by the kernel.$
WARNING: Block comments use a leading /* on a separate line
#855: FILE: tools/virtiofsd/passthrough_ll.c:828:
+ /* With writeback cache, O_APPEND is handled by the kernel.
ERROR: code indent should never use tabs
#856: FILE: tools/virtiofsd/passthrough_ll.c:829:
+^I This breaks atomicity (since the file may change in the$
WARNING: Block comments use * on subsequent lines
#856: FILE: tools/virtiofsd/passthrough_ll.c:829:
+ /* With writeback cache, O_APPEND is handled by the kernel.
+ This breaks atomicity (since the file may change in the
ERROR: code indent should never use tabs
#857: FILE: tools/virtiofsd/passthrough_ll.c:830:
+^I underlying filesystem, so that the kernel's idea of the$
ERROR: code indent should never use tabs
#858: FILE: tools/virtiofsd/passthrough_ll.c:831:
+^I end of the file isn't accurate anymore). In this example,$
ERROR: code indent should never use tabs
#859: FILE: tools/virtiofsd/passthrough_ll.c:832:
+^I we just accept that. A more rigorous filesystem may want$
ERROR: code indent should never use tabs
#860: FILE: tools/virtiofsd/passthrough_ll.c:833:
+^I to return an error here */$
WARNING: Block comments use a trailing */ on a separate line
#860: FILE: tools/virtiofsd/passthrough_ll.c:833:
+ to return an error here */
ERROR: code indent should never use tabs
#861: FILE: tools/virtiofsd/passthrough_ll.c:834:
+^Iif (lo->writeback && (fi->flags & O_APPEND))$
ERROR: braces {} are necessary for all arms of this statement
#861: FILE: tools/virtiofsd/passthrough_ll.c:834:
+ if (lo->writeback && (fi->flags & O_APPEND))
[...]
ERROR: code indent should never use tabs
#862: FILE: tools/virtiofsd/passthrough_ll.c:835:
+^I^Ifi->flags &= ~O_APPEND;$
ERROR: code indent should never use tabs
#864: FILE: tools/virtiofsd/passthrough_ll.c:837:
+^Isprintf(buf, "/proc/self/fd/%i", lo_fd(req, ino));$
ERROR: code indent should never use tabs
#865: FILE: tools/virtiofsd/passthrough_ll.c:838:
+^Ifd = open(buf, fi->flags & ~O_NOFOLLOW);$
ERROR: code indent should never use tabs
#866: FILE: tools/virtiofsd/passthrough_ll.c:839:
+^Iif (fd == -1)$
ERROR: braces {} are necessary for all arms of this statement
#866: FILE: tools/virtiofsd/passthrough_ll.c:839:
+ if (fd == -1)
[...]
ERROR: code indent should never use tabs
#867: FILE: tools/virtiofsd/passthrough_ll.c:840:
+^I^Ireturn (void) fuse_reply_err(req, errno);$
ERROR: code indent should never use tabs
#869: FILE: tools/virtiofsd/passthrough_ll.c:842:
+^Ifi->fh = fd;$
ERROR: code indent should never use tabs
#870: FILE: tools/virtiofsd/passthrough_ll.c:843:
+^Iif (lo->cache == CACHE_NEVER)$
ERROR: braces {} are necessary for all arms of this statement
#870: FILE: tools/virtiofsd/passthrough_ll.c:843:
+ if (lo->cache == CACHE_NEVER)
[...]
+ else if (lo->cache == CACHE_ALWAYS)
[...]
ERROR: code indent should never use tabs
#871: FILE: tools/virtiofsd/passthrough_ll.c:844:
+^I^Ifi->direct_io = 1;$
ERROR: code indent should never use tabs
#872: FILE: tools/virtiofsd/passthrough_ll.c:845:
+^Ielse if (lo->cache == CACHE_ALWAYS)$
ERROR: braces {} are necessary for all arms of this statement
#872: FILE: tools/virtiofsd/passthrough_ll.c:845:
+ else if (lo->cache == CACHE_ALWAYS)
[...]
ERROR: code indent should never use tabs
#873: FILE: tools/virtiofsd/passthrough_ll.c:846:
+^I^Ifi->keep_cache = 1;$
ERROR: code indent should never use tabs
#874: FILE: tools/virtiofsd/passthrough_ll.c:847:
+^Ifuse_reply_open(req, fi);$
WARNING: line over 80 characters
#877: FILE: tools/virtiofsd/passthrough_ll.c:850:
+static void lo_release(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
ERROR: code indent should never use tabs
#879: FILE: tools/virtiofsd/passthrough_ll.c:852:
+^I(void) ino;$
ERROR: code indent should never use tabs
#881: FILE: tools/virtiofsd/passthrough_ll.c:854:
+^Iclose(fi->fh);$
ERROR: code indent should never use tabs
#882: FILE: tools/virtiofsd/passthrough_ll.c:855:
+^Ifuse_reply_err(req, 0);$
ERROR: code indent should never use tabs
#887: FILE: tools/virtiofsd/passthrough_ll.c:860:
+^Iint res;$
ERROR: code indent should never use tabs
#888: FILE: tools/virtiofsd/passthrough_ll.c:861:
+^I(void) ino;$
ERROR: code indent should never use tabs
#889: FILE: tools/virtiofsd/passthrough_ll.c:862:
+^Ires = close(dup(fi->fh));$
ERROR: code indent should never use tabs
#890: FILE: tools/virtiofsd/passthrough_ll.c:863:
+^Ifuse_reply_err(req, res == -1 ? errno : 0);$
ERROR: code indent should never use tabs
#894: FILE: tools/virtiofsd/passthrough_ll.c:867:
+^I^I struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#896: FILE: tools/virtiofsd/passthrough_ll.c:869:
+^Iint res;$
ERROR: code indent should never use tabs
#897: FILE: tools/virtiofsd/passthrough_ll.c:870:
+^I(void) ino;$
ERROR: code indent should never use tabs
#898: FILE: tools/virtiofsd/passthrough_ll.c:871:
+^Iif (datasync)$
ERROR: braces {} are necessary for all arms of this statement
#898: FILE: tools/virtiofsd/passthrough_ll.c:871:
+ if (datasync)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#899: FILE: tools/virtiofsd/passthrough_ll.c:872:
+^I^Ires = fdatasync(fi->fh);$
ERROR: code indent should never use tabs
#900: FILE: tools/virtiofsd/passthrough_ll.c:873:
+^Ielse$
ERROR: code indent should never use tabs
#901: FILE: tools/virtiofsd/passthrough_ll.c:874:
+^I^Ires = fsync(fi->fh);$
ERROR: code indent should never use tabs
#902: FILE: tools/virtiofsd/passthrough_ll.c:875:
+^Ifuse_reply_err(req, res == -1 ? errno : 0);$
ERROR: code indent should never use tabs
#906: FILE: tools/virtiofsd/passthrough_ll.c:879:
+^I^I off_t offset, struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#908: FILE: tools/virtiofsd/passthrough_ll.c:881:
+^Istruct fuse_bufvec buf = FUSE_BUFVEC_INIT(size);$
ERROR: code indent should never use tabs
#910: FILE: tools/virtiofsd/passthrough_ll.c:883:
+^Iif (lo_debug(req))$
ERROR: code indent should never use tabs
#911: FILE: tools/virtiofsd/passthrough_ll.c:884:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_read(ino=%" PRIu64 ", size=%zd, "$
ERROR: code indent should never use tabs
#912: FILE: tools/virtiofsd/passthrough_ll.c:885:
+^I^I^I"off=%lu)\n", ino, size, (unsigned long) offset);$
ERROR: code indent should never use tabs
#914: FILE: tools/virtiofsd/passthrough_ll.c:887:
+^Ibuf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;$
ERROR: code indent should never use tabs
#915: FILE: tools/virtiofsd/passthrough_ll.c:888:
+^Ibuf.buf[0].fd = fi->fh;$
ERROR: code indent should never use tabs
#916: FILE: tools/virtiofsd/passthrough_ll.c:889:
+^Ibuf.buf[0].pos = offset;$
ERROR: code indent should never use tabs
#918: FILE: tools/virtiofsd/passthrough_ll.c:891:
+^Ifuse_reply_data(req, &buf, FUSE_BUF_SPLICE_MOVE);$
ERROR: code indent should never use tabs
#922: FILE: tools/virtiofsd/passthrough_ll.c:895:
+^I^I^I struct fuse_bufvec *in_buf, off_t off,$
ERROR: code indent should never use tabs
#923: FILE: tools/virtiofsd/passthrough_ll.c:896:
+^I^I^I struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#925: FILE: tools/virtiofsd/passthrough_ll.c:898:
+^I(void) ino;$
ERROR: code indent should never use tabs
#926: FILE: tools/virtiofsd/passthrough_ll.c:899:
+^Issize_t res;$
ERROR: code indent should never use tabs
#927: FILE: tools/virtiofsd/passthrough_ll.c:900:
+^Istruct fuse_bufvec out_buf = FUSE_BUFVEC_INIT(fuse_buf_size(in_buf));$
ERROR: code indent should never use tabs
#929: FILE: tools/virtiofsd/passthrough_ll.c:902:
+^Iout_buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;$
ERROR: code indent should never use tabs
#930: FILE: tools/virtiofsd/passthrough_ll.c:903:
+^Iout_buf.buf[0].fd = fi->fh;$
ERROR: code indent should never use tabs
#931: FILE: tools/virtiofsd/passthrough_ll.c:904:
+^Iout_buf.buf[0].pos = off;$
ERROR: code indent should never use tabs
#933: FILE: tools/virtiofsd/passthrough_ll.c:906:
+^Iif (lo_debug(req))$
WARNING: line over 80 characters
#934: FILE: tools/virtiofsd/passthrough_ll.c:907:
+ fuse_log(FUSE_LOG_DEBUG, "lo_write(ino=%" PRIu64 ", size=%zd, off=%lu)\n",
ERROR: code indent should never use tabs
#934: FILE: tools/virtiofsd/passthrough_ll.c:907:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_write(ino=%" PRIu64 ", size=%zd, off=%lu)\n",$
ERROR: code indent should never use tabs
#935: FILE: tools/virtiofsd/passthrough_ll.c:908:
+^I^I^Iino, out_buf.buf[0].size, (unsigned long) off);$
ERROR: code indent should never use tabs
#937: FILE: tools/virtiofsd/passthrough_ll.c:910:
+^Ires = fuse_buf_copy(&out_buf, in_buf, 0);$
ERROR: code indent should never use tabs
#938: FILE: tools/virtiofsd/passthrough_ll.c:911:
+^Iif(res < 0)$
ERROR: space required before the open parenthesis '('
#938: FILE: tools/virtiofsd/passthrough_ll.c:911:
+ if(res < 0)
ERROR: braces {} are necessary for all arms of this statement
#938: FILE: tools/virtiofsd/passthrough_ll.c:911:
+ if(res < 0)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#939: FILE: tools/virtiofsd/passthrough_ll.c:912:
+^I^Ifuse_reply_err(req, -res);$
ERROR: code indent should never use tabs
#940: FILE: tools/virtiofsd/passthrough_ll.c:913:
+^Ielse$
ERROR: code indent should never use tabs
#941: FILE: tools/virtiofsd/passthrough_ll.c:914:
+^I^Ifuse_reply_write(req, (size_t) res);$
ERROR: code indent should never use tabs
#946: FILE: tools/virtiofsd/passthrough_ll.c:919:
+^Iint res;$
ERROR: code indent should never use tabs
#947: FILE: tools/virtiofsd/passthrough_ll.c:920:
+^Istruct statvfs stbuf;$
ERROR: code indent should never use tabs
#949: FILE: tools/virtiofsd/passthrough_ll.c:922:
+^Ires = fstatvfs(lo_fd(req, ino), &stbuf);$
ERROR: code indent should never use tabs
#950: FILE: tools/virtiofsd/passthrough_ll.c:923:
+^Iif (res == -1)$
ERROR: braces {} are necessary for all arms of this statement
#950: FILE: tools/virtiofsd/passthrough_ll.c:923:
+ if (res == -1)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#951: FILE: tools/virtiofsd/passthrough_ll.c:924:
+^I^Ifuse_reply_err(req, errno);$
ERROR: code indent should never use tabs
#952: FILE: tools/virtiofsd/passthrough_ll.c:925:
+^Ielse$
ERROR: code indent should never use tabs
#953: FILE: tools/virtiofsd/passthrough_ll.c:926:
+^I^Ifuse_reply_statfs(req, &stbuf);$
ERROR: code indent should never use tabs
#957: FILE: tools/virtiofsd/passthrough_ll.c:930:
+^I^I^I off_t offset, off_t length, struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#959: FILE: tools/virtiofsd/passthrough_ll.c:932:
+^Iint err = EOPNOTSUPP;$
ERROR: code indent should never use tabs
#960: FILE: tools/virtiofsd/passthrough_ll.c:933:
+^I(void) ino;$
ERROR: code indent should never use tabs
#963: FILE: tools/virtiofsd/passthrough_ll.c:936:
+^Ierr = fallocate(fi->fh, mode, offset, length);$
ERROR: code indent should never use tabs
#964: FILE: tools/virtiofsd/passthrough_ll.c:937:
+^Iif (err < 0)$
ERROR: braces {} are necessary for all arms of this statement
#964: FILE: tools/virtiofsd/passthrough_ll.c:937:
+ if (err < 0)
[...]
ERROR: code indent should never use tabs
#965: FILE: tools/virtiofsd/passthrough_ll.c:938:
+^I^Ierr = errno;$
ERROR: code indent should never use tabs
#968: FILE: tools/virtiofsd/passthrough_ll.c:941:
+^Iif (mode) {$
ERROR: code indent should never use tabs
#969: FILE: tools/virtiofsd/passthrough_ll.c:942:
+^I^Ifuse_reply_err(req, EOPNOTSUPP);$
ERROR: code indent should never use tabs
#970: FILE: tools/virtiofsd/passthrough_ll.c:943:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#971: FILE: tools/virtiofsd/passthrough_ll.c:944:
+^I}$
ERROR: code indent should never use tabs
#973: FILE: tools/virtiofsd/passthrough_ll.c:946:
+^Ierr = posix_fallocate(fi->fh, offset, length);$
ERROR: code indent should never use tabs
#976: FILE: tools/virtiofsd/passthrough_ll.c:949:
+^Ifuse_reply_err(req, err);$
ERROR: code indent should never use tabs
#980: FILE: tools/virtiofsd/passthrough_ll.c:953:
+^I^I int op)$
ERROR: code indent should never use tabs
#982: FILE: tools/virtiofsd/passthrough_ll.c:955:
+^Iint res;$
ERROR: code indent should never use tabs
#983: FILE: tools/virtiofsd/passthrough_ll.c:956:
+^I(void) ino;$
ERROR: code indent should never use tabs
#985: FILE: tools/virtiofsd/passthrough_ll.c:958:
+^Ires = flock(fi->fh, op);$
ERROR: code indent should never use tabs
#987: FILE: tools/virtiofsd/passthrough_ll.c:960:
+^Ifuse_reply_err(req, res == -1 ? errno : 0);$
ERROR: code indent should never use tabs
#991: FILE: tools/virtiofsd/passthrough_ll.c:964:
+^I^I^Isize_t size)$
ERROR: code indent should never use tabs
#993: FILE: tools/virtiofsd/passthrough_ll.c:966:
+^Ichar *value = NULL;$
ERROR: code indent should never use tabs
#994: FILE: tools/virtiofsd/passthrough_ll.c:967:
+^Ichar procname[64];$
ERROR: code indent should never use tabs
#995: FILE: tools/virtiofsd/passthrough_ll.c:968:
+^Istruct lo_inode *inode = lo_inode(req, ino);$
ERROR: code indent should never use tabs
#996: FILE: tools/virtiofsd/passthrough_ll.c:969:
+^Issize_t ret;$
ERROR: code indent should never use tabs
#997: FILE: tools/virtiofsd/passthrough_ll.c:970:
+^Iint saverr;$
ERROR: code indent should never use tabs
#999: FILE: tools/virtiofsd/passthrough_ll.c:972:
+^Isaverr = ENOSYS;$
ERROR: code indent should never use tabs
#1000: FILE: tools/virtiofsd/passthrough_ll.c:973:
+^Iif (!lo_data(req)->xattr)$
ERROR: braces {} are necessary for all arms of this statement
#1000: FILE: tools/virtiofsd/passthrough_ll.c:973:
+ if (!lo_data(req)->xattr)
[...]
ERROR: code indent should never use tabs
#1001: FILE: tools/virtiofsd/passthrough_ll.c:974:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1003: FILE: tools/virtiofsd/passthrough_ll.c:976:
+^Iif (lo_debug(req)) {$
ERROR: line over 90 characters
#1004: FILE: tools/virtiofsd/passthrough_ll.c:977:
+ fuse_log(FUSE_LOG_DEBUG, "lo_getxattr(ino=%" PRIu64 ", name=%s size=%zd)\n",
ERROR: code indent should never use tabs
#1004: FILE: tools/virtiofsd/passthrough_ll.c:977:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_getxattr(ino=%" PRIu64 ", name=%s size=%zd)\n",$
ERROR: code indent should never use tabs
#1005: FILE: tools/virtiofsd/passthrough_ll.c:978:
+^I^I^Iino, name, size);$
ERROR: code indent should never use tabs
#1006: FILE: tools/virtiofsd/passthrough_ll.c:979:
+^I}$
ERROR: code indent should never use tabs
#1008: FILE: tools/virtiofsd/passthrough_ll.c:981:
+^Iif (inode->is_symlink) {$
ERROR: code indent should never use tabs
#1009: FILE: tools/virtiofsd/passthrough_ll.c:982:
+^I^I/* Sorry, no race free way to getxattr on symlink. */$
ERROR: code indent should never use tabs
#1010: FILE: tools/virtiofsd/passthrough_ll.c:983:
+^I^Isaverr = EPERM;$
ERROR: code indent should never use tabs
#1011: FILE: tools/virtiofsd/passthrough_ll.c:984:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1012: FILE: tools/virtiofsd/passthrough_ll.c:985:
+^I}$
ERROR: code indent should never use tabs
#1014: FILE: tools/virtiofsd/passthrough_ll.c:987:
+^Isprintf(procname, "/proc/self/fd/%i", inode->fd);$
ERROR: code indent should never use tabs
#1016: FILE: tools/virtiofsd/passthrough_ll.c:989:
+^Iif (size) {$
ERROR: code indent should never use tabs
#1017: FILE: tools/virtiofsd/passthrough_ll.c:990:
+^I^Ivalue = malloc(size);$
ERROR: code indent should never use tabs
#1018: FILE: tools/virtiofsd/passthrough_ll.c:991:
+^I^Iif (!value)$
ERROR: braces {} are necessary for all arms of this statement
#1018: FILE: tools/virtiofsd/passthrough_ll.c:991:
+ if (!value)
[...]
ERROR: code indent should never use tabs
#1019: FILE: tools/virtiofsd/passthrough_ll.c:992:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#1021: FILE: tools/virtiofsd/passthrough_ll.c:994:
+^I^Iret = getxattr(procname, name, value, size);$
ERROR: code indent should never use tabs
#1022: FILE: tools/virtiofsd/passthrough_ll.c:995:
+^I^Iif (ret == -1)$
ERROR: braces {} are necessary for all arms of this statement
#1022: FILE: tools/virtiofsd/passthrough_ll.c:995:
+ if (ret == -1)
[...]
ERROR: code indent should never use tabs
#1023: FILE: tools/virtiofsd/passthrough_ll.c:996:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#1024: FILE: tools/virtiofsd/passthrough_ll.c:997:
+^I^Isaverr = 0;$
ERROR: code indent should never use tabs
#1025: FILE: tools/virtiofsd/passthrough_ll.c:998:
+^I^Iif (ret == 0)$
ERROR: braces {} are necessary for all arms of this statement
#1025: FILE: tools/virtiofsd/passthrough_ll.c:998:
+ if (ret == 0)
[...]
ERROR: code indent should never use tabs
#1026: FILE: tools/virtiofsd/passthrough_ll.c:999:
+^I^I^Igoto out;$
ERROR: code indent should never use tabs
#1028: FILE: tools/virtiofsd/passthrough_ll.c:1001:
+^I^Ifuse_reply_buf(req, value, ret);$
ERROR: code indent should never use tabs
#1029: FILE: tools/virtiofsd/passthrough_ll.c:1002:
+^I} else {$
ERROR: code indent should never use tabs
#1030: FILE: tools/virtiofsd/passthrough_ll.c:1003:
+^I^Iret = getxattr(procname, name, NULL, 0);$
ERROR: code indent should never use tabs
#1031: FILE: tools/virtiofsd/passthrough_ll.c:1004:
+^I^Iif (ret == -1)$
ERROR: braces {} are necessary for all arms of this statement
#1031: FILE: tools/virtiofsd/passthrough_ll.c:1004:
+ if (ret == -1)
[...]
ERROR: code indent should never use tabs
#1032: FILE: tools/virtiofsd/passthrough_ll.c:1005:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#1034: FILE: tools/virtiofsd/passthrough_ll.c:1007:
+^I^Ifuse_reply_xattr(req, ret);$
ERROR: code indent should never use tabs
#1035: FILE: tools/virtiofsd/passthrough_ll.c:1008:
+^I}$
ERROR: code indent should never use tabs
#1037: FILE: tools/virtiofsd/passthrough_ll.c:1010:
+^Ifree(value);$
ERROR: code indent should never use tabs
#1038: FILE: tools/virtiofsd/passthrough_ll.c:1011:
+^Ireturn;$
ERROR: code indent should never use tabs
#1041: FILE: tools/virtiofsd/passthrough_ll.c:1014:
+^Isaverr = errno;$
ERROR: code indent should never use tabs
#1043: FILE: tools/virtiofsd/passthrough_ll.c:1016:
+^Ifuse_reply_err(req, saverr);$
ERROR: code indent should never use tabs
#1044: FILE: tools/virtiofsd/passthrough_ll.c:1017:
+^Igoto out_free;$
ERROR: code indent should never use tabs
#1049: FILE: tools/virtiofsd/passthrough_ll.c:1022:
+^Ichar *value = NULL;$
ERROR: code indent should never use tabs
#1050: FILE: tools/virtiofsd/passthrough_ll.c:1023:
+^Ichar procname[64];$
ERROR: code indent should never use tabs
#1051: FILE: tools/virtiofsd/passthrough_ll.c:1024:
+^Istruct lo_inode *inode = lo_inode(req, ino);$
ERROR: code indent should never use tabs
#1052: FILE: tools/virtiofsd/passthrough_ll.c:1025:
+^Issize_t ret;$
ERROR: code indent should never use tabs
#1053: FILE: tools/virtiofsd/passthrough_ll.c:1026:
+^Iint saverr;$
ERROR: code indent should never use tabs
#1055: FILE: tools/virtiofsd/passthrough_ll.c:1028:
+^Isaverr = ENOSYS;$
ERROR: code indent should never use tabs
#1056: FILE: tools/virtiofsd/passthrough_ll.c:1029:
+^Iif (!lo_data(req)->xattr)$
ERROR: braces {} are necessary for all arms of this statement
#1056: FILE: tools/virtiofsd/passthrough_ll.c:1029:
+ if (!lo_data(req)->xattr)
[...]
ERROR: code indent should never use tabs
#1057: FILE: tools/virtiofsd/passthrough_ll.c:1030:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1059: FILE: tools/virtiofsd/passthrough_ll.c:1032:
+^Iif (lo_debug(req)) {$
WARNING: line over 80 characters
#1060: FILE: tools/virtiofsd/passthrough_ll.c:1033:
+ fuse_log(FUSE_LOG_DEBUG, "lo_listxattr(ino=%" PRIu64 ", size=%zd)\n",
ERROR: code indent should never use tabs
#1060: FILE: tools/virtiofsd/passthrough_ll.c:1033:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_listxattr(ino=%" PRIu64 ", size=%zd)\n",$
ERROR: code indent should never use tabs
#1061: FILE: tools/virtiofsd/passthrough_ll.c:1034:
+^I^I^Iino, size);$
ERROR: code indent should never use tabs
#1062: FILE: tools/virtiofsd/passthrough_ll.c:1035:
+^I}$
ERROR: code indent should never use tabs
#1064: FILE: tools/virtiofsd/passthrough_ll.c:1037:
+^Iif (inode->is_symlink) {$
ERROR: code indent should never use tabs
#1065: FILE: tools/virtiofsd/passthrough_ll.c:1038:
+^I^I/* Sorry, no race free way to listxattr on symlink. */$
ERROR: code indent should never use tabs
#1066: FILE: tools/virtiofsd/passthrough_ll.c:1039:
+^I^Isaverr = EPERM;$
ERROR: code indent should never use tabs
#1067: FILE: tools/virtiofsd/passthrough_ll.c:1040:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1068: FILE: tools/virtiofsd/passthrough_ll.c:1041:
+^I}$
ERROR: code indent should never use tabs
#1070: FILE: tools/virtiofsd/passthrough_ll.c:1043:
+^Isprintf(procname, "/proc/self/fd/%i", inode->fd);$
ERROR: code indent should never use tabs
#1072: FILE: tools/virtiofsd/passthrough_ll.c:1045:
+^Iif (size) {$
ERROR: code indent should never use tabs
#1073: FILE: tools/virtiofsd/passthrough_ll.c:1046:
+^I^Ivalue = malloc(size);$
ERROR: code indent should never use tabs
#1074: FILE: tools/virtiofsd/passthrough_ll.c:1047:
+^I^Iif (!value)$
ERROR: braces {} are necessary for all arms of this statement
#1074: FILE: tools/virtiofsd/passthrough_ll.c:1047:
+ if (!value)
[...]
ERROR: code indent should never use tabs
#1075: FILE: tools/virtiofsd/passthrough_ll.c:1048:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#1077: FILE: tools/virtiofsd/passthrough_ll.c:1050:
+^I^Iret = listxattr(procname, value, size);$
ERROR: code indent should never use tabs
#1078: FILE: tools/virtiofsd/passthrough_ll.c:1051:
+^I^Iif (ret == -1)$
ERROR: braces {} are necessary for all arms of this statement
#1078: FILE: tools/virtiofsd/passthrough_ll.c:1051:
+ if (ret == -1)
[...]
ERROR: code indent should never use tabs
#1079: FILE: tools/virtiofsd/passthrough_ll.c:1052:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#1080: FILE: tools/virtiofsd/passthrough_ll.c:1053:
+^I^Isaverr = 0;$
ERROR: code indent should never use tabs
#1081: FILE: tools/virtiofsd/passthrough_ll.c:1054:
+^I^Iif (ret == 0)$
ERROR: braces {} are necessary for all arms of this statement
#1081: FILE: tools/virtiofsd/passthrough_ll.c:1054:
+ if (ret == 0)
[...]
ERROR: code indent should never use tabs
#1082: FILE: tools/virtiofsd/passthrough_ll.c:1055:
+^I^I^Igoto out;$
ERROR: code indent should never use tabs
#1084: FILE: tools/virtiofsd/passthrough_ll.c:1057:
+^I^Ifuse_reply_buf(req, value, ret);$
ERROR: code indent should never use tabs
#1085: FILE: tools/virtiofsd/passthrough_ll.c:1058:
+^I} else {$
ERROR: code indent should never use tabs
#1086: FILE: tools/virtiofsd/passthrough_ll.c:1059:
+^I^Iret = listxattr(procname, NULL, 0);$
ERROR: code indent should never use tabs
#1087: FILE: tools/virtiofsd/passthrough_ll.c:1060:
+^I^Iif (ret == -1)$
ERROR: braces {} are necessary for all arms of this statement
#1087: FILE: tools/virtiofsd/passthrough_ll.c:1060:
+ if (ret == -1)
[...]
ERROR: code indent should never use tabs
#1088: FILE: tools/virtiofsd/passthrough_ll.c:1061:
+^I^I^Igoto out_err;$
ERROR: code indent should never use tabs
#1090: FILE: tools/virtiofsd/passthrough_ll.c:1063:
+^I^Ifuse_reply_xattr(req, ret);$
ERROR: code indent should never use tabs
#1091: FILE: tools/virtiofsd/passthrough_ll.c:1064:
+^I}$
ERROR: code indent should never use tabs
#1093: FILE: tools/virtiofsd/passthrough_ll.c:1066:
+^Ifree(value);$
ERROR: code indent should never use tabs
#1094: FILE: tools/virtiofsd/passthrough_ll.c:1067:
+^Ireturn;$
ERROR: code indent should never use tabs
#1097: FILE: tools/virtiofsd/passthrough_ll.c:1070:
+^Isaverr = errno;$
ERROR: code indent should never use tabs
#1099: FILE: tools/virtiofsd/passthrough_ll.c:1072:
+^Ifuse_reply_err(req, saverr);$
ERROR: code indent should never use tabs
#1100: FILE: tools/virtiofsd/passthrough_ll.c:1073:
+^Igoto out_free;$
ERROR: code indent should never use tabs
#1104: FILE: tools/virtiofsd/passthrough_ll.c:1077:
+^I^I^Iconst char *value, size_t size, int flags)$
ERROR: code indent should never use tabs
#1106: FILE: tools/virtiofsd/passthrough_ll.c:1079:
+^Ichar procname[64];$
ERROR: code indent should never use tabs
#1107: FILE: tools/virtiofsd/passthrough_ll.c:1080:
+^Istruct lo_inode *inode = lo_inode(req, ino);$
ERROR: code indent should never use tabs
#1108: FILE: tools/virtiofsd/passthrough_ll.c:1081:
+^Issize_t ret;$
ERROR: code indent should never use tabs
#1109: FILE: tools/virtiofsd/passthrough_ll.c:1082:
+^Iint saverr;$
ERROR: code indent should never use tabs
#1111: FILE: tools/virtiofsd/passthrough_ll.c:1084:
+^Isaverr = ENOSYS;$
ERROR: code indent should never use tabs
#1112: FILE: tools/virtiofsd/passthrough_ll.c:1085:
+^Iif (!lo_data(req)->xattr)$
ERROR: braces {} are necessary for all arms of this statement
#1112: FILE: tools/virtiofsd/passthrough_ll.c:1085:
+ if (!lo_data(req)->xattr)
[...]
ERROR: code indent should never use tabs
#1113: FILE: tools/virtiofsd/passthrough_ll.c:1086:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1115: FILE: tools/virtiofsd/passthrough_ll.c:1088:
+^Iif (lo_debug(req)) {$
ERROR: line over 90 characters
#1116: FILE: tools/virtiofsd/passthrough_ll.c:1089:
+ fuse_log(FUSE_LOG_DEBUG, "lo_setxattr(ino=%" PRIu64 ", name=%s value=%s size=%zd)\n",
ERROR: code indent should never use tabs
#1116: FILE: tools/virtiofsd/passthrough_ll.c:1089:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_setxattr(ino=%" PRIu64 ", name=%s value=%s size=%zd)\n",$
ERROR: code indent should never use tabs
#1117: FILE: tools/virtiofsd/passthrough_ll.c:1090:
+^I^I^Iino, name, value, size);$
ERROR: code indent should never use tabs
#1118: FILE: tools/virtiofsd/passthrough_ll.c:1091:
+^I}$
ERROR: code indent should never use tabs
#1120: FILE: tools/virtiofsd/passthrough_ll.c:1093:
+^Iif (inode->is_symlink) {$
ERROR: code indent should never use tabs
#1121: FILE: tools/virtiofsd/passthrough_ll.c:1094:
+^I^I/* Sorry, no race free way to setxattr on symlink. */$
ERROR: code indent should never use tabs
#1122: FILE: tools/virtiofsd/passthrough_ll.c:1095:
+^I^Isaverr = EPERM;$
ERROR: code indent should never use tabs
#1123: FILE: tools/virtiofsd/passthrough_ll.c:1096:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1124: FILE: tools/virtiofsd/passthrough_ll.c:1097:
+^I}$
ERROR: code indent should never use tabs
#1126: FILE: tools/virtiofsd/passthrough_ll.c:1099:
+^Isprintf(procname, "/proc/self/fd/%i", inode->fd);$
ERROR: code indent should never use tabs
#1128: FILE: tools/virtiofsd/passthrough_ll.c:1101:
+^Iret = setxattr(procname, name, value, size, flags);$
ERROR: code indent should never use tabs
#1129: FILE: tools/virtiofsd/passthrough_ll.c:1102:
+^Isaverr = ret == -1 ? errno : 0;$
ERROR: code indent should never use tabs
#1132: FILE: tools/virtiofsd/passthrough_ll.c:1105:
+^Ifuse_reply_err(req, saverr);$
ERROR: code indent should never use tabs
#1137: FILE: tools/virtiofsd/passthrough_ll.c:1110:
+^Ichar procname[64];$
ERROR: code indent should never use tabs
#1138: FILE: tools/virtiofsd/passthrough_ll.c:1111:
+^Istruct lo_inode *inode = lo_inode(req, ino);$
ERROR: code indent should never use tabs
#1139: FILE: tools/virtiofsd/passthrough_ll.c:1112:
+^Issize_t ret;$
ERROR: code indent should never use tabs
#1140: FILE: tools/virtiofsd/passthrough_ll.c:1113:
+^Iint saverr;$
ERROR: code indent should never use tabs
#1142: FILE: tools/virtiofsd/passthrough_ll.c:1115:
+^Isaverr = ENOSYS;$
ERROR: code indent should never use tabs
#1143: FILE: tools/virtiofsd/passthrough_ll.c:1116:
+^Iif (!lo_data(req)->xattr)$
ERROR: braces {} are necessary for all arms of this statement
#1143: FILE: tools/virtiofsd/passthrough_ll.c:1116:
+ if (!lo_data(req)->xattr)
[...]
ERROR: code indent should never use tabs
#1144: FILE: tools/virtiofsd/passthrough_ll.c:1117:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1146: FILE: tools/virtiofsd/passthrough_ll.c:1119:
+^Iif (lo_debug(req)) {$
WARNING: line over 80 characters
#1147: FILE: tools/virtiofsd/passthrough_ll.c:1120:
+ fuse_log(FUSE_LOG_DEBUG, "lo_removexattr(ino=%" PRIu64 ", name=%s)\n",
ERROR: code indent should never use tabs
#1147: FILE: tools/virtiofsd/passthrough_ll.c:1120:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_removexattr(ino=%" PRIu64 ", name=%s)\n",$
ERROR: code indent should never use tabs
#1148: FILE: tools/virtiofsd/passthrough_ll.c:1121:
+^I^I^Iino, name);$
ERROR: code indent should never use tabs
#1149: FILE: tools/virtiofsd/passthrough_ll.c:1122:
+^I}$
ERROR: code indent should never use tabs
#1151: FILE: tools/virtiofsd/passthrough_ll.c:1124:
+^Iif (inode->is_symlink) {$
ERROR: code indent should never use tabs
#1152: FILE: tools/virtiofsd/passthrough_ll.c:1125:
+^I^I/* Sorry, no race free way to setxattr on symlink. */$
ERROR: code indent should never use tabs
#1153: FILE: tools/virtiofsd/passthrough_ll.c:1126:
+^I^Isaverr = EPERM;$
ERROR: code indent should never use tabs
#1154: FILE: tools/virtiofsd/passthrough_ll.c:1127:
+^I^Igoto out;$
ERROR: code indent should never use tabs
#1155: FILE: tools/virtiofsd/passthrough_ll.c:1128:
+^I}$
ERROR: code indent should never use tabs
#1157: FILE: tools/virtiofsd/passthrough_ll.c:1130:
+^Isprintf(procname, "/proc/self/fd/%i", inode->fd);$
ERROR: code indent should never use tabs
#1159: FILE: tools/virtiofsd/passthrough_ll.c:1132:
+^Iret = removexattr(procname, name);$
ERROR: code indent should never use tabs
#1160: FILE: tools/virtiofsd/passthrough_ll.c:1133:
+^Isaverr = ret == -1 ? errno : 0;$
ERROR: code indent should never use tabs
#1163: FILE: tools/virtiofsd/passthrough_ll.c:1136:
+^Ifuse_reply_err(req, saverr);$
ERROR: code indent should never use tabs
#1168: FILE: tools/virtiofsd/passthrough_ll.c:1141:
+^I^I^I struct fuse_file_info *fi_in,$
ERROR: code indent should never use tabs
#1169: FILE: tools/virtiofsd/passthrough_ll.c:1142:
+^I^I^I fuse_ino_t ino_out, off_t off_out,$
ERROR: code indent should never use tabs
#1170: FILE: tools/virtiofsd/passthrough_ll.c:1143:
+^I^I^I struct fuse_file_info *fi_out, size_t len,$
ERROR: code indent should never use tabs
#1171: FILE: tools/virtiofsd/passthrough_ll.c:1144:
+^I^I^I int flags)$
ERROR: code indent should never use tabs
#1173: FILE: tools/virtiofsd/passthrough_ll.c:1146:
+^Issize_t res;$
ERROR: code indent should never use tabs
#1175: FILE: tools/virtiofsd/passthrough_ll.c:1148:
+^Iif (lo_debug(req))$
WARNING: line over 80 characters
#1176: FILE: tools/virtiofsd/passthrough_ll.c:1149:
+ fuse_log(FUSE_LOG_DEBUG, "lo_copy_file_range(ino=%" PRIu64 "/fd=%lu, "
ERROR: code indent should never use tabs
#1176: FILE: tools/virtiofsd/passthrough_ll.c:1149:
+^I^Ifuse_log(FUSE_LOG_DEBUG, "lo_copy_file_range(ino=%" PRIu64 "/fd=%lu, "$
ERROR: code indent should never use tabs
#1177: FILE: tools/virtiofsd/passthrough_ll.c:1150:
+^I^I^I^I"off=%lu, ino=%" PRIu64 "/fd=%lu, "$
ERROR: code indent should never use tabs
#1178: FILE: tools/virtiofsd/passthrough_ll.c:1151:
+^I^I^I^I"off=%lu, size=%zd, flags=0x%x)\n",$
ERROR: code indent should never use tabs
#1179: FILE: tools/virtiofsd/passthrough_ll.c:1152:
+^I^I^Iino_in, fi_in->fh, off_in, ino_out, fi_out->fh, off_out,$
ERROR: code indent should never use tabs
#1180: FILE: tools/virtiofsd/passthrough_ll.c:1153:
+^I^I^Ilen, flags);$
ERROR: code indent should never use tabs
#1182: FILE: tools/virtiofsd/passthrough_ll.c:1155:
+^Ires = copy_file_range(fi_in->fh, &off_in, fi_out->fh, &off_out, len,$
ERROR: code indent should never use tabs
#1183: FILE: tools/virtiofsd/passthrough_ll.c:1156:
+^I^I^I flags);$
ERROR: code indent should never use tabs
#1184: FILE: tools/virtiofsd/passthrough_ll.c:1157:
+^Iif (res < 0)$
ERROR: braces {} are necessary for all arms of this statement
#1184: FILE: tools/virtiofsd/passthrough_ll.c:1157:
+ if (res < 0)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1185: FILE: tools/virtiofsd/passthrough_ll.c:1158:
+^I^Ifuse_reply_err(req, -errno);$
ERROR: code indent should never use tabs
#1186: FILE: tools/virtiofsd/passthrough_ll.c:1159:
+^Ielse$
ERROR: code indent should never use tabs
#1187: FILE: tools/virtiofsd/passthrough_ll.c:1160:
+^I^Ifuse_reply_write(req, res);$
ERROR: code indent should never use tabs
#1192: FILE: tools/virtiofsd/passthrough_ll.c:1165:
+^I^I struct fuse_file_info *fi)$
ERROR: code indent should never use tabs
#1194: FILE: tools/virtiofsd/passthrough_ll.c:1167:
+^Ioff_t res;$
ERROR: code indent should never use tabs
#1196: FILE: tools/virtiofsd/passthrough_ll.c:1169:
+^I(void)ino;$
ERROR: code indent should never use tabs
#1197: FILE: tools/virtiofsd/passthrough_ll.c:1170:
+^Ires = lseek(fi->fh, off, whence);$
ERROR: code indent should never use tabs
#1198: FILE: tools/virtiofsd/passthrough_ll.c:1171:
+^Iif (res != -1)$
ERROR: braces {} are necessary for all arms of this statement
#1198: FILE: tools/virtiofsd/passthrough_ll.c:1171:
+ if (res != -1)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1199: FILE: tools/virtiofsd/passthrough_ll.c:1172:
+^I^Ifuse_reply_lseek(req, res);$
ERROR: code indent should never use tabs
#1200: FILE: tools/virtiofsd/passthrough_ll.c:1173:
+^Ielse$
ERROR: code indent should never use tabs
#1201: FILE: tools/virtiofsd/passthrough_ll.c:1174:
+^I^Ifuse_reply_err(req, errno);$
ERROR: code indent should never use tabs
#1205: FILE: tools/virtiofsd/passthrough_ll.c:1178:
+^I.init^I^I= lo_init,$
ERROR: code indent should never use tabs
#1206: FILE: tools/virtiofsd/passthrough_ll.c:1179:
+^I.lookup^I^I= lo_lookup,$
ERROR: code indent should never use tabs
#1207: FILE: tools/virtiofsd/passthrough_ll.c:1180:
+^I.mkdir^I^I= lo_mkdir,$
ERROR: code indent should never use tabs
#1208: FILE: tools/virtiofsd/passthrough_ll.c:1181:
+^I.mknod^I^I= lo_mknod,$
ERROR: code indent should never use tabs
#1209: FILE: tools/virtiofsd/passthrough_ll.c:1182:
+^I.symlink^I= lo_symlink,$
ERROR: code indent should never use tabs
#1210: FILE: tools/virtiofsd/passthrough_ll.c:1183:
+^I.link^I^I= lo_link,$
ERROR: code indent should never use tabs
#1211: FILE: tools/virtiofsd/passthrough_ll.c:1184:
+^I.unlink^I^I= lo_unlink,$
ERROR: code indent should never use tabs
#1212: FILE: tools/virtiofsd/passthrough_ll.c:1185:
+^I.rmdir^I^I= lo_rmdir,$
ERROR: code indent should never use tabs
#1213: FILE: tools/virtiofsd/passthrough_ll.c:1186:
+^I.rename^I^I= lo_rename,$
ERROR: code indent should never use tabs
#1214: FILE: tools/virtiofsd/passthrough_ll.c:1187:
+^I.forget^I^I= lo_forget,$
ERROR: code indent should never use tabs
#1215: FILE: tools/virtiofsd/passthrough_ll.c:1188:
+^I.forget_multi^I= lo_forget_multi,$
ERROR: code indent should never use tabs
#1216: FILE: tools/virtiofsd/passthrough_ll.c:1189:
+^I.getattr^I= lo_getattr,$
ERROR: code indent should never use tabs
#1217: FILE: tools/virtiofsd/passthrough_ll.c:1190:
+^I.setattr^I= lo_setattr,$
ERROR: code indent should never use tabs
#1218: FILE: tools/virtiofsd/passthrough_ll.c:1191:
+^I.readlink^I= lo_readlink,$
ERROR: code indent should never use tabs
#1219: FILE: tools/virtiofsd/passthrough_ll.c:1192:
+^I.opendir^I= lo_opendir,$
ERROR: code indent should never use tabs
#1220: FILE: tools/virtiofsd/passthrough_ll.c:1193:
+^I.readdir^I= lo_readdir,$
ERROR: code indent should never use tabs
#1221: FILE: tools/virtiofsd/passthrough_ll.c:1194:
+^I.readdirplus^I= lo_readdirplus,$
ERROR: code indent should never use tabs
#1222: FILE: tools/virtiofsd/passthrough_ll.c:1195:
+^I.releasedir^I= lo_releasedir,$
ERROR: code indent should never use tabs
#1223: FILE: tools/virtiofsd/passthrough_ll.c:1196:
+^I.fsyncdir^I= lo_fsyncdir,$
ERROR: code indent should never use tabs
#1224: FILE: tools/virtiofsd/passthrough_ll.c:1197:
+^I.create^I^I= lo_create,$
ERROR: code indent should never use tabs
#1225: FILE: tools/virtiofsd/passthrough_ll.c:1198:
+^I.open^I^I= lo_open,$
ERROR: code indent should never use tabs
#1226: FILE: tools/virtiofsd/passthrough_ll.c:1199:
+^I.release^I= lo_release,$
ERROR: code indent should never use tabs
#1227: FILE: tools/virtiofsd/passthrough_ll.c:1200:
+^I.flush^I^I= lo_flush,$
ERROR: code indent should never use tabs
#1228: FILE: tools/virtiofsd/passthrough_ll.c:1201:
+^I.fsync^I^I= lo_fsync,$
ERROR: code indent should never use tabs
#1229: FILE: tools/virtiofsd/passthrough_ll.c:1202:
+^I.read^I^I= lo_read,$
ERROR: code indent should never use tabs
#1230: FILE: tools/virtiofsd/passthrough_ll.c:1203:
+^I.write_buf = lo_write_buf,$
ERROR: code indent should never use tabs
#1231: FILE: tools/virtiofsd/passthrough_ll.c:1204:
+^I.statfs^I^I= lo_statfs,$
ERROR: code indent should never use tabs
#1232: FILE: tools/virtiofsd/passthrough_ll.c:1205:
+^I.fallocate^I= lo_fallocate,$
ERROR: code indent should never use tabs
#1233: FILE: tools/virtiofsd/passthrough_ll.c:1206:
+^I.flock^I^I= lo_flock,$
ERROR: code indent should never use tabs
#1234: FILE: tools/virtiofsd/passthrough_ll.c:1207:
+^I.getxattr^I= lo_getxattr,$
ERROR: code indent should never use tabs
#1235: FILE: tools/virtiofsd/passthrough_ll.c:1208:
+^I.listxattr^I= lo_listxattr,$
ERROR: code indent should never use tabs
#1236: FILE: tools/virtiofsd/passthrough_ll.c:1209:
+^I.setxattr^I= lo_setxattr,$
ERROR: code indent should never use tabs
#1237: FILE: tools/virtiofsd/passthrough_ll.c:1210:
+^I.removexattr^I= lo_removexattr,$
ERROR: code indent should never use tabs
#1239: FILE: tools/virtiofsd/passthrough_ll.c:1212:
+^I.copy_file_range = lo_copy_file_range,$
ERROR: code indent should never use tabs
#1241: FILE: tools/virtiofsd/passthrough_ll.c:1214:
+^I.lseek^I^I= lo_lseek,$
ERROR: code indent should never use tabs
#1246: FILE: tools/virtiofsd/passthrough_ll.c:1219:
+^Istruct fuse_args args = FUSE_ARGS_INIT(argc, argv);$
ERROR: code indent should never use tabs
#1247: FILE: tools/virtiofsd/passthrough_ll.c:1220:
+^Istruct fuse_session *se;$
ERROR: code indent should never use tabs
#1248: FILE: tools/virtiofsd/passthrough_ll.c:1221:
+^Istruct fuse_cmdline_opts opts;$
ERROR: code indent should never use tabs
#1249: FILE: tools/virtiofsd/passthrough_ll.c:1222:
+^Istruct lo_data lo = { .debug = 0,$
ERROR: code indent should never use tabs
#1250: FILE: tools/virtiofsd/passthrough_ll.c:1223:
+^I .writeback = 0 };$
ERROR: code indent should never use tabs
#1251: FILE: tools/virtiofsd/passthrough_ll.c:1224:
+^Iint ret = -1;$
ERROR: code indent should never use tabs
#1253: FILE: tools/virtiofsd/passthrough_ll.c:1226:
+^I/* Don't mask creation mode, kernel already did that */$
ERROR: code indent should never use tabs
#1254: FILE: tools/virtiofsd/passthrough_ll.c:1227:
+^Iumask(0);$
ERROR: code indent should never use tabs
#1256: FILE: tools/virtiofsd/passthrough_ll.c:1229:
+^Ipthread_mutex_init(&lo.mutex, NULL);$
ERROR: code indent should never use tabs
#1257: FILE: tools/virtiofsd/passthrough_ll.c:1230:
+^Ilo.root.next = lo.root.prev = &lo.root;$
ERROR: code indent should never use tabs
#1258: FILE: tools/virtiofsd/passthrough_ll.c:1231:
+^Ilo.root.fd = -1;$
ERROR: code indent should never use tabs
#1259: FILE: tools/virtiofsd/passthrough_ll.c:1232:
+^Ilo.cache = CACHE_NORMAL;$
ERROR: code indent should never use tabs
#1261: FILE: tools/virtiofsd/passthrough_ll.c:1234:
+^Iif (fuse_parse_cmdline(&args, &opts) != 0)$
ERROR: braces {} are necessary for all arms of this statement
#1261: FILE: tools/virtiofsd/passthrough_ll.c:1234:
+ if (fuse_parse_cmdline(&args, &opts) != 0)
[...]
ERROR: code indent should never use tabs
#1262: FILE: tools/virtiofsd/passthrough_ll.c:1235:
+^I^Ireturn 1;$
ERROR: code indent should never use tabs
#1263: FILE: tools/virtiofsd/passthrough_ll.c:1236:
+^Iif (opts.show_help) {$
ERROR: code indent should never use tabs
#1264: FILE: tools/virtiofsd/passthrough_ll.c:1237:
+^I^Iprintf("usage: %s [options] <mountpoint>\n\n", argv[0]);$
ERROR: code indent should never use tabs
#1265: FILE: tools/virtiofsd/passthrough_ll.c:1238:
+^I^Ifuse_cmdline_help();$
ERROR: code indent should never use tabs
#1266: FILE: tools/virtiofsd/passthrough_ll.c:1239:
+^I^Ifuse_lowlevel_help();$
ERROR: code indent should never use tabs
#1267: FILE: tools/virtiofsd/passthrough_ll.c:1240:
+^I^Iret = 0;$
ERROR: code indent should never use tabs
#1268: FILE: tools/virtiofsd/passthrough_ll.c:1241:
+^I^Igoto err_out1;$
ERROR: code indent should never use tabs
#1269: FILE: tools/virtiofsd/passthrough_ll.c:1242:
+^I} else if (opts.show_version) {$
ERROR: code indent should never use tabs
#1270: FILE: tools/virtiofsd/passthrough_ll.c:1243:
+^I^Iprintf("FUSE library version %s\n", fuse_pkgversion());$
ERROR: code indent should never use tabs
#1271: FILE: tools/virtiofsd/passthrough_ll.c:1244:
+^I^Ifuse_lowlevel_version();$
ERROR: code indent should never use tabs
#1272: FILE: tools/virtiofsd/passthrough_ll.c:1245:
+^I^Iret = 0;$
ERROR: code indent should never use tabs
#1273: FILE: tools/virtiofsd/passthrough_ll.c:1246:
+^I^Igoto err_out1;$
ERROR: code indent should never use tabs
#1274: FILE: tools/virtiofsd/passthrough_ll.c:1247:
+^I}$
ERROR: code indent should never use tabs
#1276: FILE: tools/virtiofsd/passthrough_ll.c:1249:
+^Iif(opts.mountpoint == NULL) {$
ERROR: space required before the open parenthesis '('
#1276: FILE: tools/virtiofsd/passthrough_ll.c:1249:
+ if(opts.mountpoint == NULL) {
ERROR: code indent should never use tabs
#1277: FILE: tools/virtiofsd/passthrough_ll.c:1250:
+^I^Iprintf("usage: %s [options] <mountpoint>\n", argv[0]);$
ERROR: code indent should never use tabs
#1278: FILE: tools/virtiofsd/passthrough_ll.c:1251:
+^I^Iprintf(" %s --help\n", argv[0]);$
ERROR: code indent should never use tabs
#1279: FILE: tools/virtiofsd/passthrough_ll.c:1252:
+^I^Iret = 1;$
ERROR: code indent should never use tabs
#1280: FILE: tools/virtiofsd/passthrough_ll.c:1253:
+^I^Igoto err_out1;$
ERROR: code indent should never use tabs
#1281: FILE: tools/virtiofsd/passthrough_ll.c:1254:
+^I}$
ERROR: code indent should never use tabs
#1283: FILE: tools/virtiofsd/passthrough_ll.c:1256:
+^Iif (fuse_opt_parse(&args, &lo, lo_opts, NULL)== -1)$
ERROR: spaces required around that '==' (ctx:VxW)
#1283: FILE: tools/virtiofsd/passthrough_ll.c:1256:
+ if (fuse_opt_parse(&args, &lo, lo_opts, NULL)== -1)
^
ERROR: braces {} are necessary for all arms of this statement
#1283: FILE: tools/virtiofsd/passthrough_ll.c:1256:
+ if (fuse_opt_parse(&args, &lo, lo_opts, NULL)== -1)
[...]
ERROR: code indent should never use tabs
#1284: FILE: tools/virtiofsd/passthrough_ll.c:1257:
+^I^Ireturn 1;$
ERROR: code indent should never use tabs
#1286: FILE: tools/virtiofsd/passthrough_ll.c:1259:
+^Ilo.debug = opts.debug;$
ERROR: code indent should never use tabs
#1287: FILE: tools/virtiofsd/passthrough_ll.c:1260:
+^Ilo.root.refcount = 2;$
ERROR: code indent should never use tabs
#1288: FILE: tools/virtiofsd/passthrough_ll.c:1261:
+^Iif (lo.source) {$
ERROR: code indent should never use tabs
#1289: FILE: tools/virtiofsd/passthrough_ll.c:1262:
+^I^Istruct stat stat;$
ERROR: code indent should never use tabs
#1290: FILE: tools/virtiofsd/passthrough_ll.c:1263:
+^I^Iint res;$
ERROR: code indent should never use tabs
#1292: FILE: tools/virtiofsd/passthrough_ll.c:1265:
+^I^Ires = lstat(lo.source, &stat);$
ERROR: code indent should never use tabs
#1293: FILE: tools/virtiofsd/passthrough_ll.c:1266:
+^I^Iif (res == -1) {$
WARNING: line over 80 characters
#1294: FILE: tools/virtiofsd/passthrough_ll.c:1267:
+ fuse_log(FUSE_LOG_ERR, "failed to stat source (\"%s\"): %m\n",
ERROR: code indent should never use tabs
#1294: FILE: tools/virtiofsd/passthrough_ll.c:1267:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "failed to stat source (\"%s\"): %m\n",$
ERROR: code indent should never use tabs
#1295: FILE: tools/virtiofsd/passthrough_ll.c:1268:
+^I^I^I^I lo.source);$
ERROR: code indent should never use tabs
#1296: FILE: tools/virtiofsd/passthrough_ll.c:1269:
+^I^I^Iexit(1);$
ERROR: code indent should never use tabs
#1297: FILE: tools/virtiofsd/passthrough_ll.c:1270:
+^I^I}$
ERROR: code indent should never use tabs
#1298: FILE: tools/virtiofsd/passthrough_ll.c:1271:
+^I^Iif (!S_ISDIR(stat.st_mode)) {$
ERROR: code indent should never use tabs
#1299: FILE: tools/virtiofsd/passthrough_ll.c:1272:
+^I^I^Ifuse_log(FUSE_LOG_ERR, "source is not a directory\n");$
ERROR: code indent should never use tabs
#1300: FILE: tools/virtiofsd/passthrough_ll.c:1273:
+^I^I^Iexit(1);$
ERROR: code indent should never use tabs
#1301: FILE: tools/virtiofsd/passthrough_ll.c:1274:
+^I^I}$
ERROR: code indent should never use tabs
#1303: FILE: tools/virtiofsd/passthrough_ll.c:1276:
+^I} else {$
ERROR: code indent should never use tabs
#1304: FILE: tools/virtiofsd/passthrough_ll.c:1277:
+^I^Ilo.source = "/";$
ERROR: code indent should never use tabs
#1305: FILE: tools/virtiofsd/passthrough_ll.c:1278:
+^I}$
ERROR: code indent should never use tabs
#1306: FILE: tools/virtiofsd/passthrough_ll.c:1279:
+^Ilo.root.is_symlink = false;$
ERROR: code indent should never use tabs
#1307: FILE: tools/virtiofsd/passthrough_ll.c:1280:
+^Iif (!lo.timeout_set) {$
ERROR: code indent should never use tabs
#1308: FILE: tools/virtiofsd/passthrough_ll.c:1281:
+^I^Iswitch (lo.cache) {$
ERROR: code indent should never use tabs
#1309: FILE: tools/virtiofsd/passthrough_ll.c:1282:
+^I^Icase CACHE_NEVER:$
ERROR: code indent should never use tabs
#1310: FILE: tools/virtiofsd/passthrough_ll.c:1283:
+^I^I^Ilo.timeout = 0.0;$
ERROR: code indent should never use tabs
#1311: FILE: tools/virtiofsd/passthrough_ll.c:1284:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#1313: FILE: tools/virtiofsd/passthrough_ll.c:1286:
+^I^Icase CACHE_NORMAL:$
ERROR: code indent should never use tabs
#1314: FILE: tools/virtiofsd/passthrough_ll.c:1287:
+^I^I^Ilo.timeout = 1.0;$
ERROR: code indent should never use tabs
#1315: FILE: tools/virtiofsd/passthrough_ll.c:1288:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#1317: FILE: tools/virtiofsd/passthrough_ll.c:1290:
+^I^Icase CACHE_ALWAYS:$
ERROR: code indent should never use tabs
#1318: FILE: tools/virtiofsd/passthrough_ll.c:1291:
+^I^I^Ilo.timeout = 86400.0;$
ERROR: code indent should never use tabs
#1319: FILE: tools/virtiofsd/passthrough_ll.c:1292:
+^I^I^Ibreak;$
ERROR: code indent should never use tabs
#1320: FILE: tools/virtiofsd/passthrough_ll.c:1293:
+^I^I}$
ERROR: code indent should never use tabs
#1321: FILE: tools/virtiofsd/passthrough_ll.c:1294:
+^I} else if (lo.timeout < 0) {$
ERROR: code indent should never use tabs
#1322: FILE: tools/virtiofsd/passthrough_ll.c:1295:
+^I^Ifuse_log(FUSE_LOG_ERR, "timeout is negative (%lf)\n",$
ERROR: code indent should never use tabs
#1323: FILE: tools/virtiofsd/passthrough_ll.c:1296:
+^I^I^I lo.timeout);$
ERROR: code indent should never use tabs
#1324: FILE: tools/virtiofsd/passthrough_ll.c:1297:
+^I^Iexit(1);$
ERROR: code indent should never use tabs
#1325: FILE: tools/virtiofsd/passthrough_ll.c:1298:
+^I}$
ERROR: code indent should never use tabs
#1327: FILE: tools/virtiofsd/passthrough_ll.c:1300:
+^Ilo.root.fd = open(lo.source, O_PATH);$
ERROR: code indent should never use tabs
#1328: FILE: tools/virtiofsd/passthrough_ll.c:1301:
+^Iif (lo.root.fd == -1) {$
ERROR: code indent should never use tabs
#1329: FILE: tools/virtiofsd/passthrough_ll.c:1302:
+^I^Ifuse_log(FUSE_LOG_ERR, "open(\"%s\", O_PATH): %m\n",$
ERROR: code indent should never use tabs
#1330: FILE: tools/virtiofsd/passthrough_ll.c:1303:
+^I^I^I lo.source);$
ERROR: code indent should never use tabs
#1331: FILE: tools/virtiofsd/passthrough_ll.c:1304:
+^I^Iexit(1);$
ERROR: code indent should never use tabs
#1332: FILE: tools/virtiofsd/passthrough_ll.c:1305:
+^I}$
ERROR: code indent should never use tabs
#1334: FILE: tools/virtiofsd/passthrough_ll.c:1307:
+^Ise = fuse_session_new(&args, &lo_oper, sizeof(lo_oper), &lo);$
ERROR: code indent should never use tabs
#1335: FILE: tools/virtiofsd/passthrough_ll.c:1308:
+^Iif (se == NULL)$
ERROR: braces {} are necessary for all arms of this statement
#1335: FILE: tools/virtiofsd/passthrough_ll.c:1308:
+ if (se == NULL)
[...]
ERROR: code indent should never use tabs
#1336: FILE: tools/virtiofsd/passthrough_ll.c:1309:
+^I goto err_out1;$
ERROR: code indent should never use tabs
#1338: FILE: tools/virtiofsd/passthrough_ll.c:1311:
+^Iif (fuse_set_signal_handlers(se) != 0)$
ERROR: braces {} are necessary for all arms of this statement
#1338: FILE: tools/virtiofsd/passthrough_ll.c:1311:
+ if (fuse_set_signal_handlers(se) != 0)
[...]
ERROR: code indent should never use tabs
#1339: FILE: tools/virtiofsd/passthrough_ll.c:1312:
+^I goto err_out2;$
ERROR: code indent should never use tabs
#1341: FILE: tools/virtiofsd/passthrough_ll.c:1314:
+^Iif (fuse_session_mount(se, opts.mountpoint) != 0)$
ERROR: braces {} are necessary for all arms of this statement
#1341: FILE: tools/virtiofsd/passthrough_ll.c:1314:
+ if (fuse_session_mount(se, opts.mountpoint) != 0)
[...]
ERROR: code indent should never use tabs
#1342: FILE: tools/virtiofsd/passthrough_ll.c:1315:
+^I goto err_out3;$
ERROR: code indent should never use tabs
#1344: FILE: tools/virtiofsd/passthrough_ll.c:1317:
+^Ifuse_daemonize(opts.foreground);$
ERROR: code indent should never use tabs
#1346: FILE: tools/virtiofsd/passthrough_ll.c:1319:
+^I/* Block until ctrl+c or fusermount -u */$
ERROR: code indent should never use tabs
#1347: FILE: tools/virtiofsd/passthrough_ll.c:1320:
+^Iif (opts.singlethread)$
ERROR: braces {} are necessary for all arms of this statement
#1347: FILE: tools/virtiofsd/passthrough_ll.c:1320:
+ if (opts.singlethread)
[...]
+ else
[...]
ERROR: code indent should never use tabs
#1348: FILE: tools/virtiofsd/passthrough_ll.c:1321:
+^I^Iret = fuse_session_loop(se);$
ERROR: code indent should never use tabs
#1349: FILE: tools/virtiofsd/passthrough_ll.c:1322:
+^Ielse$
ERROR: code indent should never use tabs
#1350: FILE: tools/virtiofsd/passthrough_ll.c:1323:
+^I^Iret = fuse_session_loop_mt(se, opts.clone_fd);$
ERROR: code indent should never use tabs
#1352: FILE: tools/virtiofsd/passthrough_ll.c:1325:
+^Ifuse_session_unmount(se);$
ERROR: code indent should never use tabs
#1354: FILE: tools/virtiofsd/passthrough_ll.c:1327:
+^Ifuse_remove_signal_handlers(se);$
ERROR: code indent should never use tabs
#1356: FILE: tools/virtiofsd/passthrough_ll.c:1329:
+^Ifuse_session_destroy(se);$
ERROR: code indent should never use tabs
#1358: FILE: tools/virtiofsd/passthrough_ll.c:1331:
+^Ifree(opts.mountpoint);$
ERROR: code indent should never use tabs
#1359: FILE: tools/virtiofsd/passthrough_ll.c:1332:
+^Ifuse_opt_free_args(&args);$
ERROR: code indent should never use tabs
#1361: FILE: tools/virtiofsd/passthrough_ll.c:1334:
+^Iif (lo.root.fd >= 0)$
ERROR: braces {} are necessary for all arms of this statement
#1361: FILE: tools/virtiofsd/passthrough_ll.c:1334:
+ if (lo.root.fd >= 0)
[...]
ERROR: code indent should never use tabs
#1362: FILE: tools/virtiofsd/passthrough_ll.c:1335:
+^I^Iclose(lo.root.fd);$
ERROR: code indent should never use tabs
#1364: FILE: tools/virtiofsd/passthrough_ll.c:1337:
+^Ireturn ret ? 1 : 0;$
total: 954 errors, 30 warnings, 1338 lines checked
Patch 5/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
6/108 Checking commit 4de66b5b1207 (virtiofsd: Trim down imported files)
ERROR: code indent should never use tabs
#103: FILE: tools/virtiofsd/buffer.c:184:
+^I^Ireturn fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);$
ERROR: code indent should never use tabs
#390: FILE: tools/virtiofsd/fuse_lowlevel.c:179:
+^Iabort(); /* virtio should have taken it before here */$
ERROR: code indent should never use tabs
#521: FILE: tools/virtiofsd/fuse_lowlevel.c:475:
+^Iabort(); /* Will have taken vhost path */$
ERROR: code indent should never use tabs
#770: FILE: tools/virtiofsd/fuse_lowlevel.c:1046:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#874: FILE: tools/virtiofsd/fuse_lowlevel.c:2142:
+^Iin = buf->mem;$
ERROR: code indent should never use tabs
#883: FILE: tools/virtiofsd/fuse_lowlevel.c:2164:
+^I^Ireturn;$
ERROR: code indent should never use tabs
#891: FILE: tools/virtiofsd/fuse_lowlevel.c:2171:
+^Ireq->ch = ch;$
total: 7 errors, 0 warnings, 1422 lines checked
Patch 6/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
7/108 Checking commit c695a07e2df4 (virtiofsd: Format imported files to qemu style)
WARNING: Block comments use a leading /* on a separate line
#3151: FILE: tools/virtiofsd/fuse_common.h:720:
+ ((struct fuse_bufvec){ /* .count= */ 1, \
WARNING: Block comments use a leading /* on a separate line
#3152: FILE: tools/virtiofsd/fuse_common.h:721:
+ /* .idx = */ 0, \
WARNING: Block comments use a leading /* on a separate line
#3153: FILE: tools/virtiofsd/fuse_common.h:722:
+ /* .off = */ 0, /* .buf = */ \
WARNING: Block comments use a leading /* on a separate line
#3154: FILE: tools/virtiofsd/fuse_common.h:723:
+ { /* [0] = */ { \
WARNING: Block comments use a leading /* on a separate line
#3155: FILE: tools/virtiofsd/fuse_common.h:724:
+ /* .size = */ (size__), \
WARNING: Block comments use a leading /* on a separate line
#3156: FILE: tools/virtiofsd/fuse_common.h:725:
+ /* .flags = */ (enum fuse_buf_flags)0, \
WARNING: Block comments use a leading /* on a separate line
#3157: FILE: tools/virtiofsd/fuse_common.h:726:
+ /* .mem = */ NULL, \
WARNING: Block comments use a leading /* on a separate line
#3158: FILE: tools/virtiofsd/fuse_common.h:727:
+ /* .fd = */ -1, \
WARNING: Block comments use a leading /* on a separate line
#3159: FILE: tools/virtiofsd/fuse_common.h:728:
+ /* .pos = */ 0, \
WARNING: architecture specific defines should be avoided
#3208: FILE: tools/virtiofsd/fuse_common.h:799:
+#if defined(__GNUC__) && \
ERROR: Use of volatile is usually wrong, please add a comment
#3319: FILE: tools/virtiofsd/fuse_i.h:44:
+ volatile int exited;
ERROR: spaces required around that '*' (ctx:WxV)
#3556: FILE: tools/virtiofsd/fuse_lowlevel.c:36:
+ const typeof(((type *)0)->member) *__mptr = (ptr); \
^
ERROR: use qemu_real_host_page_size instead of getpagesize()
#3572: FILE: tools/virtiofsd/fuse_lowlevel.c:49:
+ pagesize = getpagesize();
ERROR: use qemu_real_host_page_size instead of getpagesize()
#6228: FILE: tools/virtiofsd/fuse_lowlevel.c:1683:
+ FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize() +
ERROR: Macros with complex values should be enclosed in parenthesis
#6296: FILE: tools/virtiofsd/fuse_lowlevel.c:1713:
+#define LL_SET_DEFAULT(cond, cap) \
+ if ((cond) && (se->conn.capable & (cap))) \
+ se->conn.want |= (cap)
ERROR: use qemu_real_host_page_size instead of getpagesize()
#6370: FILE: tools/virtiofsd/fuse_lowlevel.c:1763:
+ outarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;
ERROR: use qemu_real_host_page_size instead of getpagesize()
#7489: FILE: tools/virtiofsd/fuse_lowlevel.c:2436:
+ se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() + FUSE_BUFFER_HEADER_SIZE;
ERROR: consider using qemu_strtoul in preference to strtoul
#7707: FILE: tools/virtiofsd/fuse_lowlevel.c:2567:
+ unsigned long val = strtoul(s, &end, 0);
ERROR: Macros with complex values should be enclosed in parenthesis
#11887: FILE: tools/virtiofsd/helper.c:260:
+#define LL_ENABLE(cond, cap) \
+ if (cond) \
+ conn->want |= (cap)
ERROR: Macros with complex values should be enclosed in parenthesis
#11890: FILE: tools/virtiofsd/helper.c:263:
+#define LL_DISABLE(cond, cap) \
+ if (cond) \
+ conn->want &= ~(cap)
WARNING: architecture specific defines should be avoided
#12088: FILE: tools/virtiofsd/passthrough_ll.c:67:
+#if defined(__GNUC__) && \
total: 10 errors, 11 warnings, 14038 lines checked
Patch 7/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
8/108 Checking commit 40408f0a4239 (virtiofsd: remove mountpoint dummy argument)
9/108 Checking commit e0ade3b24dea (virtiofsd: remove unused notify reply support)
10/108 Checking commit 988582cce94b (virtiofsd: Remove unused enum fuse_buf_copy_flags)
11/108 Checking commit 470bf03530a4 (virtiofsd: Fix fuse_daemonize ignored return values)
12/108 Checking commit 85d350a61df8 (virtiofsd: Fix common header and define for QEMU builds)
13/108 Checking commit afdaf8ea7ba4 (virtiofsd: Trim out compatibility code)
ERROR: use qemu_real_host_page_size instead of getpagesize()
#412: FILE: tools/virtiofsd/fuse_lowlevel.c:1614:
+ size_t max_bufsize = FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize() +
total: 1 errors, 0 warnings, 486 lines checked
Patch 13/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
14/108 Checking commit 674d18bfe6a0 (vitriofsd/passthrough_ll: fix fallocate() ifdefs)
15/108 Checking commit 01b4a15a5110 (virtiofsd: Make fsync work even if only inode is passed in)
16/108 Checking commit a6f8a688a96b (virtiofsd: Add options for virtio)
17/108 Checking commit 87cb3caee7f9 (virtiofsd: add -o source=PATH to help output)
18/108 Checking commit 083904978e42 (virtiofsd: Open vhost connection instead of mounting)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#120:
new file mode 100644
total: 0 errors, 1 warnings, 192 lines checked
Patch 18/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
19/108 Checking commit fef307e7df1d (virtiofsd: Start wiring up vhost-user)
20/108 Checking commit 287b48cb387e (virtiofsd: Add main virtio loop)
21/108 Checking commit ad8b170e940e (virtiofsd: get/set features callbacks)
22/108 Checking commit 440938ddf944 (virtiofsd: Start queue threads)
23/108 Checking commit 36e6c52c582c (virtiofsd: Poll kick_fd for queue)
24/108 Checking commit 1372ebdac6c3 (virtiofsd: Start reading commands from queue)
25/108 Checking commit 5bece7bc1bed (virtiofsd: Send replies to messages)
26/108 Checking commit 9e7093d27c97 (virtiofsd: Keep track of replies)
27/108 Checking commit ca3b0f6d8ff0 (virtiofsd: Add Makefile wiring for virtiofsd contrib)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#70:
new file mode 100644
total: 0 errors, 1 warnings, 44 lines checked
Patch 27/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
28/108 Checking commit 52a2eec7b8dd (virtiofsd: Fast path for virtio read)
29/108 Checking commit 312e7d4a9705 (virtiofsd: add --fd=FDNUM fd passing option)
30/108 Checking commit bd6c9f420399 (virtiofsd: make -f (foreground) the default)
31/108 Checking commit f437f8d68ea7 (virtiofsd: add vhost-user.json file)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#41:
new file mode 100644
total: 0 errors, 1 warnings, 19 lines checked
Patch 31/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
32/108 Checking commit c3172526b8aa (virtiofsd: add --print-capabilities option)
33/108 Checking commit cffa2eada53f (virtiofs: Add maintainers entry)
34/108 Checking commit d66da85d0c3e (virtiofsd: passthrough_ll: create new files in caller's context)
35/108 Checking commit 5a8812e49283 (virtiofsd: passthrough_ll: add lo_map for ino/fh indirection)
ERROR: storage class should be at the beginning of the declaration
#50: FILE: tools/virtiofsd/passthrough_ll.c:148:
+__attribute__((unused)) static void lo_map_init(struct lo_map *map)
ERROR: storage class should be at the beginning of the declaration
#57: FILE: tools/virtiofsd/passthrough_ll.c:155:
+__attribute__((unused)) static void lo_map_destroy(struct lo_map *map)
ERROR: storage class should be at the beginning of the declaration
#88: FILE: tools/virtiofsd/passthrough_ll.c:186:
+__attribute__((unused)) static struct lo_map_elem *
ERROR: storage class should be at the beginning of the declaration
#105: FILE: tools/virtiofsd/passthrough_ll.c:203:
+__attribute__((unused)) static struct lo_map_elem *
ERROR: storage class should be at the beginning of the declaration
#127: FILE: tools/virtiofsd/passthrough_ll.c:225:
+__attribute__((unused)) static struct lo_map_elem *
ERROR: storage class should be at the beginning of the declaration
#139: FILE: tools/virtiofsd/passthrough_ll.c:237:
+__attribute__((unused)) static void lo_map_remove(struct lo_map *map,
total: 6 errors, 0 warnings, 136 lines checked
Patch 35/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
36/108 Checking commit db71a83e306e (virtiofsd: passthrough_ll: add ino_map to hide lo_inode pointers)
37/108 Checking commit fad5ec76c542 (virtiofsd: passthrough_ll: add dirp_map to hide lo_dirp pointers)
38/108 Checking commit 3ed53576c346 (virtiofsd: passthrough_ll: add fd_map to hide file descriptors)
39/108 Checking commit bca92ad4101a (virtiofsd: passthrough_ll: add fallback for racy ops)
40/108 Checking commit 408f8a16069f (virtiofsd: validate path components)
41/108 Checking commit 78d7979aa404 (virtiofsd: Plumb fuse_bufvec through to do_write_buf)
42/108 Checking commit 6b7914f009aa (virtiofsd: Pass write iov's all the way through)
43/108 Checking commit 9c34b09ea272 (virtiofsd: add fuse_mbuf_iter API)
44/108 Checking commit 38b34ea4267a (virtiofsd: validate input buffer sizes in do_write_buf())
45/108 Checking commit 3d11f1290722 (virtiofsd: check input buffer size in fuse_lowlevel.c ops)
46/108 Checking commit 3cb44633ac0b (virtiofsd: prevent ".." escape in lo_do_lookup())
47/108 Checking commit c3f5b07b5770 (virtiofsd: prevent ".." escape in lo_do_readdir())
48/108 Checking commit b8b6552b0b69 (virtiofsd: use /proc/self/fd/ O_PATH file descriptor)
49/108 Checking commit f20606af251e (virtiofsd: sandbox mount namespace)
50/108 Checking commit 3228cd452850 (virtiofsd: move to an empty network namespace)
51/108 Checking commit eb214a7e2e19 (virtiofsd: move to a new pid namespace)
52/108 Checking commit 95d60ee9b439 (virtiofsd: add seccomp whitelist)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#83:
new file mode 100644
WARNING: architecture specific defines should be avoided
#106: FILE: tools/virtiofsd/seccomp.c:19:
+#if !defined(__SNR_ppoll) && defined(__SNR_brk)
WARNING: architecture specific defines should be avoided
#107: FILE: tools/virtiofsd/seccomp.c:20:
+#ifdef __NR_ppoll
WARNING: architecture specific defines should be avoided
#121: FILE: tools/virtiofsd/seccomp.c:34:
+#ifdef __NR_clone3
WARNING: architecture specific defines should be avoided
#181: FILE: tools/virtiofsd/seccomp.c:94:
+#ifdef __NR_setresgid32
WARNING: architecture specific defines should be avoided
#184: FILE: tools/virtiofsd/seccomp.c:97:
+#ifdef __NR_setresuid32
total: 0 errors, 6 warnings, 205 lines checked
Patch 52/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
53/108 Checking commit 7a0293638d16 (virtiofsd: Parse flag FUSE_WRITE_KILL_PRIV)
54/108 Checking commit 9cc34cc90aa7 (virtiofsd: cap-ng helpers)
ERROR: do not initialise statics to 0 or NULL
#59: FILE: tools/virtiofsd/passthrough_ll.c:148:
+static __thread bool cap_loaded = 0;
total: 1 errors, 0 warnings, 124 lines checked
Patch 54/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
55/108 Checking commit e13799272dc5 (virtiofsd: Drop CAP_FSETID if client asked for it)
56/108 Checking commit 8b61e8020b0e (virtiofsd: set maximum RLIMIT_NOFILE limit)
57/108 Checking commit 788d31909aa3 (virtiofsd: fix libfuse information leaks)
58/108 Checking commit d19e0624df20 (virtiofsd: add --syslog command-line option)
ERROR: do not initialise statics to 0 or NULL
#66: FILE: tools/virtiofsd/passthrough_ll.c:142:
+static bool use_syslog = false;
total: 1 errors, 0 warnings, 165 lines checked
Patch 58/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
59/108 Checking commit 776503cd485b (virtiofsd: print log only when priority is high enough)
60/108 Checking commit fb926eea957b (virtiofsd: Add ID to the log with FUSE_LOG_DEBUG level)
61/108 Checking commit c257992aa2b2 (virtiofsd: Add timestamp to the log with FUSE_LOG_DEBUG level)
62/108 Checking commit 4002eb603ff8 (virtiofsd: Handle reinit)
63/108 Checking commit f04fe35bfa29 (virtiofsd: Handle hard reboot)
64/108 Checking commit 818e2fc00716 (virtiofsd: Kill threads when queues are stopped)
65/108 Checking commit 851e8ec6f0b1 (vhost-user: Print unexpected slave message types)
66/108 Checking commit 824a1db34a76 (contrib/libvhost-user: Protect slave fd with mutex)
67/108 Checking commit c0279a678019 (virtiofsd: passthrough_ll: add renameat2 support)
68/108 Checking commit b9097c9ab5bd (virtiofsd: passthrough_ll: disable readdirplus on cache=never)
69/108 Checking commit 4dd6c3a82a92 (virtiofsd: passthrough_ll: control readdirplus)
70/108 Checking commit 7ddb8e28a38e (virtiofsd: rename unref_inode() to unref_inode_lolocked())
71/108 Checking commit 1c063c8e4268 (virtiofsd: fail when parent inode isn't known in lo_do_lookup())
ERROR: return of an errno should typically be -ve (return -ENOENT)
#33: FILE: tools/virtiofsd/passthrough_ll.c:786:
+ return ENOENT;
total: 1 errors, 0 warnings, 38 lines checked
Patch 71/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
72/108 Checking commit 1b0531636fc3 (virtiofsd: extract root inode init into setup_root())
73/108 Checking commit 1e21a9ced978 (virtiofsd: passthrough_ll: clean up cache related options)
74/108 Checking commit 7a380f3f3e58 (virtiofsd: passthrough_ll: use hashtable)
75/108 Checking commit 0220aed8f3ef (virtiofsd: Clean up inodes on destroy)
76/108 Checking commit f0e3fbc22bf8 (virtiofsd: support nanosecond resolution for file timestamp)
77/108 Checking commit a1522eaa7029 (virtiofsd: fix error handling in main())
78/108 Checking commit 7f99afcd6234 (virtiofsd: cleanup allocated resource in se)
79/108 Checking commit 38200c63dfe3 (virtiofsd: fix memory leak on lo.source)
80/108 Checking commit f211a361cfe9 (virtiofsd: add helper for lo_data cleanup)
81/108 Checking commit 4706f46b6c70 (virtiofsd: Prevent multiply running with same vhost_user_socket)
82/108 Checking commit 9006657fa6bb (virtiofsd: enable PARALLEL_DIROPS during INIT)
83/108 Checking commit be5097a9f8e9 (virtiofsd: fix incorrect error handling in lo_do_lookup)
84/108 Checking commit 6902eb89573a (Virtiofsd: fix memory leak on fuse queueinfo)
85/108 Checking commit b76abf527f0e (virtiofsd: Support remote posix locks)
86/108 Checking commit aead5347143a (virtiofsd: use fuse_lowlevel_is_virtio() in fuse_session_destroy())
87/108 Checking commit c1c535a7a3b7 (virtiofsd: prevent fv_queue_thread() vs virtio_loop() races)
88/108 Checking commit b6ff58c86e6a (virtiofsd: make lo_release() atomic)
89/108 Checking commit f00cb4ebb1b4 (virtiofsd: prevent races with lo_dirp_put())
90/108 Checking commit 2ad1f55629b0 (virtiofsd: rename inode->refcount to inode->nlookup)
91/108 Checking commit 604298d829b1 (libvhost-user: Fix some memtable remap cases)
92/108 Checking commit c70b7eeeb4ad (virtiofsd: passthrough_ll: fix refcounting on remove/rename)
93/108 Checking commit a769832235ef (virtiofsd: introduce inode refcount to prevent use-after-free)
94/108 Checking commit 649aa4935418 (virtiofsd: do not always set FUSE_FLOCK_LOCKS)
95/108 Checking commit 269002e44f93 (virtiofsd: convert more fprintf and perror to use fuse log infra)
96/108 Checking commit e5ee594338fb (virtiofsd: Reset O_DIRECT flag during file open)
97/108 Checking commit 9e739a1eaa59 (virtiofsd: Fix data corruption with O_APPEND write in writeback mode)
98/108 Checking commit 1f67fb7b203d (virtiofsd: passthrough_ll: Use cache_readdir for directory open)
99/108 Checking commit 4fda6a6b26f4 (virtiofsd: add definition of fuse_buf_writev())
100/108 Checking commit 0e583a177769 (virtiofsd: use fuse_buf_writev to replace fuse_buf_write for better performance)
101/108 Checking commit 322bbdc8daa2 (virtiofsd: process requests in a thread pool)
WARNING: Block comments use a leading /* on a separate line
#333: FILE: tools/virtiofsd/fuse_virtio.c:577:
+ pool = g_thread_pool_new(fv_queue_worker, qi, 1 /* TODO max_threads */,
total: 0 errors, 1 warnings, 466 lines checked
Patch 101/108 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
102/108 Checking commit b573bddfdbde (virtiofsd: prevent FUSE_INIT/FUSE_DESTROY races)
103/108 Checking commit 87504eb0152c (virtiofsd: fix lo_destroy() resource leaks)
104/108 Checking commit 72ece8ff7c59 (virtiofsd: add --thread-pool-size=NUM option)
105/108 Checking commit 698292e5ac7a (virtiofsd: Convert lo_destroy to take the lo->mutex lock itself)
106/108 Checking commit 932531004fc4 (virtiofsd/passthrough_ll: Pass errno to fuse_reply_err())
107/108 Checking commit 91b9210c6f82 (virtiofsd: stop all queue threads on exit in virtio_loop())
108/108 Checking commit 02e4c6d98946 (virtiofsd: add some options to the help message)
=== OUTPUT END ===
Test command exited with code: 1
The full log is available at
http://patchew.org/logs/20200123164630.91498-1-dgilbert@redhat.com/testing.checkpatch/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to patchew-devel@redhat.com
^ permalink raw reply [flat|nested] 113+ messages in thread