Pass struct fuse_config to high-level init() handler.

diff --git a/ChangeLog.rst b/ChangeLog.rst
index a668d5fa33bc4366adae36c757c1b94762fac67b..7d32ba6e8a5ec70dd6f788009ad23c696604c9cd 100644 (file)
--- a/ChangeLog.rst
+++ b/ChangeLog.rst
@@ -1,6 +1,10 @@
 Unreleased Changes
 ==================
 
+* The high-level init() handler now receives an additional struct
+  fuse_config pointer that can be used to adjust high-level API
+  specific configuration options.
+
 * File systems that use the low-level API and support lookup requests
   for '.' and '..' should continue make sure to set the
   FUSE_CAP_EXPORT_SUPPORT bit in fuse_conn_info->want.

diff --git a/include/fuse.h b/include/fuse.h
index 52b86985a7164b7c434aa17fbcd75cecf68bdf06..3c13c14a46cd2474cb12a5c09f61872f68363890 100644 (file)
--- a/include/fuse.h
+++ b/include/fuse.h
@@ -76,6 +76,183 @@ enum fuse_fill_dir_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
+ *
+ * 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), fch‐ mod(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.
+        */
+       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;
+
+       /**
+        * The remaining options are used by libfuse internally and
+        * should not be touched.
+        */
+       int show_help;
+       char *modules;
+       int debug;
+       int nopath;
+};
+
 
 /**
  * The file system operations:
@@ -354,7 +531,8 @@ struct fuse_operations {
         * fuse_context to all file operations and as a parameter to the
         * destroy() method.
         */
-       void *(*init) (struct fuse_conn_info *conn);
+       void *(*init) (struct fuse_conn_info *conn,
+                      struct fuse_config *cfg);
 
        /**
         * Clean up filesystem
@@ -881,7 +1059,8 @@ int fuse_fs_poll(struct fuse_fs *fs, const char *path,
                 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);
-void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn);
+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);

diff --git a/lib/fuse.c b/lib/fuse.c
index 07e63d28d30ff1581fb921a68c4fcb3ae55f949e..f469378a72f88301bf315185e4809134e6f3cd7e 100644 (file)
--- a/lib/fuse.c
+++ b/lib/fuse.c
@@ -57,33 +57,6 @@
 
 #define NODE_TABLE_MIN_SIZE 8192
 
-struct fuse_config {
-       unsigned int uid;
-       unsigned int gid;
-       unsigned int  umask;
-       double entry_timeout;
-       double negative_timeout;
-       double attr_timeout;
-       double ac_attr_timeout;
-       int ac_attr_timeout_set;
-       int remember;
-       int nopath;
-       int debug;
-       int hard_remove;
-       int use_ino;
-       int readdir_ino;
-       int set_mode;
-       int set_uid;
-       int set_gid;
-       int direct_io;
-       int kernel_cache;
-       int auto_cache;
-       int intr;
-       int intr_signal;
-       int show_help;
-       char *modules;
-};
-
 struct fuse_fs {
        struct fuse_operations op;
        struct fuse_module *m;
@@ -2478,7 +2451,8 @@ static void reply_entry(fuse_req_t req, const struct fuse_entry_param *e,
                reply_err(req, err);
 }
 
-void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn)
+void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn,
+                 struct fuse_config *cfg)
 {
        fuse_get_context()->private_data = fs->user_data;
        if (!fs->op.write_buf)
@@ -2488,7 +2462,7 @@ void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn)
        if (!fs->op.flock)
                conn->want &= ~FUSE_CAP_FLOCK_LOCKS;
        if (fs->op.init)
-               fs->user_data = fs->op.init(conn);
+               fs->user_data = fs->op.init(conn, cfg);
 }
 
 static void fuse_lib_init(void *data, struct fuse_conn_info *conn)
@@ -2497,7 +2471,7 @@ static void fuse_lib_init(void *data, struct fuse_conn_info *conn)
 
        fuse_create_context(f);
        conn->want |= FUSE_CAP_EXPORT_SUPPORT;
-       fuse_fs_init(f->fs, conn);
+       fuse_fs_init(f->fs, conn, &f->conf);
 }
 
 void fuse_fs_destroy(struct fuse_fs *fs)

diff --git a/lib/modules/iconv.c b/lib/modules/iconv.c
index 41a072cc67996c5e2c162a35dc139f0b01b1e7c0..b0453be4cdfbbf92448d7e6740bc7dd39fb431b4 100644 (file)
--- a/lib/modules/iconv.c
+++ b/lib/modules/iconv.c
@@ -556,10 +556,11 @@ static int iconv_bmap(const char *path, size_t blocksize, uint64_t *idx)
        return err;
 }
 
-static void *iconv_init(struct fuse_conn_info *conn)
+static void *iconv_init(struct fuse_conn_info *conn,
+                       struct fuse_config *cfg)
 {
        struct iconv *ic = iconv_get();
-       fuse_fs_init(ic->next, conn);
+       fuse_fs_init(ic->next, conn, cfg);
        return ic;
 }
 

diff --git a/lib/modules/subdir.c b/lib/modules/subdir.c
index c264fb44894885d83fa422b2322a565ddf2c3df3..708edf3ad1466fa164a74ae6861bceec97331f92 100644 (file)
--- a/lib/modules/subdir.c
+++ b/lib/modules/subdir.c
@@ -542,10 +542,11 @@ static int subdir_bmap(const char *path, size_t blocksize, uint64_t *idx)
        return err;
 }
 
-static void *subdir_init(struct fuse_conn_info *conn)
+static void *subdir_init(struct fuse_conn_info *conn,
+                        struct fuse_config *cfg)
 {
        struct subdir *d = subdir_get();
-       fuse_fs_init(d->next, conn);
+       fuse_fs_init(d->next, conn, cfg);
        return d;
 }