+2004-12-03 Miklos Szeredi <miklos@szeredi.hu>
+
+ * Add source compatibility to 2.1 and 1.1 APIs. To select betwen
+ versions simply define FUSE_USE_VERSION to 22, 21 or 11 before
+ including the fuse header
+
+ * Add binary compatibility to 2.1 version of library with symbol
+ versioning
+
2004-12-01 Miklos Szeredi <miklos@szeredi.hu>
* kernel: clean up writing functions
-AC_INIT(fuse, 3.0-pre0)
+AC_INIT(fuse, 2.2-pre0)
AM_INIT_AUTOMAKE
AM_CONFIG_HEADER(include/config.h)
fi
CFLAGS="-Wall -W -g -O2"
-CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64 -D_REENTRANT"
+CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64 -D_REENTRANT -DFUSE_USE_VERSION=22"
AC_ARG_ENABLE(kernel-module,
[ --enable-kernel-module Compile kernel module ])
## Process this file with automake to produce Makefile.in
fuseincludedir=$(includedir)/fuse
-fuseinclude_HEADERS = fuse.h
+fuseinclude_HEADERS = fuse.h fuse_compat.h
noinst_HEADERS = fuse_kernel.h
# remove fuse.h from old place to avoid collision with new one
/* This file defines the library interface of FUSE */
+/* IMPORTANT: you should define FUSE_USE_VERSION before including this
+ header. To use the new API define it to 22 (recommended for any
+ new application), to use the old API define it to 21, to use the
+ even older 1.X API define it to 11. */
+
+#ifndef FUSE_USE_VERSION
+#define FUSE_USE_VERSION 21
+#endif
+
/** Major version of FUSE library interface */
-#define FUSE_MAJOR_VERSION 3
+#define FUSE_MAJOR_VERSION 2
/** Minor version of FUSE library interface */
-#define FUSE_MINOR_VERSION 0
+#define FUSE_MINOR_VERSION 2
/* This interface uses 64 bit off_t */
#if _FILE_OFFSET_BITS != 64
* - registers the operations
* - calls either the single-threaded or the multi-threaded event loop
*
+ * Note: this is currently implemented as a macro.
+ *
* @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
* @return 0 on success, nonzero on failure
*/
-int fuse_main(int argc, char *argv[], const struct fuse_operations *op);
+/* int fuse_main(int argc, char *argv[], const struct fuse_operations *op); */
+#define fuse_main(argc, argv, op) __fuse_main(argc, argv, op, sizeof(*(op)))
/* ----------------------------------------------------------- *
* More detailed API *
* @param fd the control file descriptor
* @param opts mount options to be used by the library
* @param op the operations
+ * @param op_size the size of the fuse_operations structure
* @return the created FUSE handle
*/
struct fuse *fuse_new(int fd, const char *opts,
- const struct fuse_operations *op);
+ const struct fuse_operations *op, size_t op_size);
/**
* Destroy the FUSE handle.
*/
int fuse_is_lib_option(const char *opt);
+/**
+ * The real main function
+ *
+ * Do not call this directly, use fuse_main()
+ */
+int __fuse_main(int argc, char *argv[], const struct fuse_operations *op,
+ size_t op_size);
+
/* ----------------------------------------------------------- *
* Advanced API for event handling, don't worry about this... *
* ----------------------------------------------------------- */
struct fuse_cmd;
typedef void (*fuse_processor_t)(struct fuse *, struct fuse_cmd *, void *);
struct fuse *__fuse_setup(int argc, char *argv[],
- const struct fuse_operations *op,
+ const struct fuse_operations *op, size_t op_size,
char **mountpoint, int *multithreaded, int *fd);
void __fuse_teardown(struct fuse *fuse, int fd, char *mountpoint);
struct fuse_cmd *__fuse_read_cmd(struct fuse *f);
int __fuse_exited(struct fuse* f);
void __fuse_set_getcontext_func(struct fuse_context *(*func)(void));
+/* ----------------------------------------------------------- *
+ * Compatibility stuff *
+ * ----------------------------------------------------------- */
+
+#if FUSE_USE_VERSION == 21 || FUSE_USE_VERSION == 11
+# include <fuse_compat.h>
+# define fuse_dirfil_t _fuse_dirfil_t_compat
+# undef fuse_main
+# undef FUSE_MINOR_VERSION
+# undef FUSE_MAJOR_VERSION
+# if FUSE_USE_VERSION == 21
+# define FUSE_MAJOR_VERSION 2
+# define FUSE_MINOR_VERSION 1
+# define fuse_operations _fuse_operations_compat2
+# define fuse_main _fuse_main_compat2
+# define fuse_new _fuse_new_compat2
+# define __fuse_setup _fuse_setup_compat2
+# else
+# undef FUSE_MAJOR_VERSION
+# define FUSE_MAJOR_VERSION 1
+# define FUSE_MINOR_VERSION 1
+# define fuse_statfs _fuse_statfs_compat1
+# define fuse_operations _fuse_operations_compat1
+# define fuse_main _fuse_main_compat1
+# define fuse_new _fuse_new_compat1
+# define fuse_mount _fuse_mount_compat1
+# define FUSE_DEBUG _FUSE_DEBUG_COMPAT1
+# endif
+#elif FUSE_USE_VERSION != 22
+# error API version other than 22, 21 and 11 not supported
+#endif
+
#ifdef __cplusplus
}
#endif
--- /dev/null
+/*
+ FUSE: Filesystem in Userspace
+ Copyright (C) 2001-2004 Miklos Szeredi <miklos@szeredi.hu>
+
+ This program can be distributed under the terms of the GNU LGPL.
+ See the file COPYING.LIB.
+*/
+
+/* these definitions provide source compatibility to prior versions.
+ Do not include this file directly! */
+
+typedef int (*_fuse_dirfil_t_compat) (fuse_dirh_t h, const char *name, int type);
+struct _fuse_operations_compat2 {
+ int (*getattr) (const char *, struct stat *);
+ int (*readlink) (const char *, char *, size_t);
+ int (*getdir) (const char *, fuse_dirh_t, _fuse_dirfil_t_compat);
+ int (*mknod) (const char *, mode_t, dev_t);
+ int (*mkdir) (const char *, mode_t);
+ int (*unlink) (const char *);
+ int (*rmdir) (const char *);
+ int (*symlink) (const char *, const char *);
+ int (*rename) (const char *, const char *);
+ int (*link) (const char *, const char *);
+ int (*chmod) (const char *, mode_t);
+ int (*chown) (const char *, uid_t, gid_t);
+ int (*truncate) (const char *, off_t);
+ int (*utime) (const char *, struct utimbuf *);
+ int (*open) (const char *, int);
+ int (*read) (const char *, char *, size_t, off_t);
+ int (*write) (const char *, const char *, size_t, off_t);
+ int (*statfs) (const char *, struct statfs *);
+ int (*flush) (const char *);
+ int (*release) (const char *, int);
+ int (*fsync) (const char *, int);
+ int (*setxattr) (const char *, const char *, const char *, size_t, int);
+ int (*getxattr) (const char *, const char *, char *, size_t);
+ int (*listxattr) (const char *, char *, size_t);
+ int (*removexattr) (const char *, const char *);
+};
+
+int _fuse_main_compat2(int argc, char *argv[], const struct _fuse_operations_compat2 *op);
+
+struct fuse *_fuse_new_compat2(int fd, const char *opts, const struct _fuse_operations_compat2 *op);
+
+struct fuse *_fuse_setup_compat2(int argc, char *argv[], const struct _fuse_operations_compat2 *op, char **mountpoint, int *multithreaded, int *fd);
+
+struct _fuse_statfs_compat1 {
+ long block_size;
+ long blocks;
+ long blocks_free;
+ long files;
+ long files_free;
+ long namelen;
+};
+
+struct _fuse_operations_compat1 {
+ int (*getattr) (const char *, struct stat *);
+ int (*readlink) (const char *, char *, size_t);
+ int (*getdir) (const char *, fuse_dirh_t, _fuse_dirfil_t_compat);
+ int (*mknod) (const char *, mode_t, dev_t);
+ int (*mkdir) (const char *, mode_t);
+ int (*unlink) (const char *);
+ int (*rmdir) (const char *);
+ int (*symlink) (const char *, const char *);
+ int (*rename) (const char *, const char *);
+ int (*link) (const char *, const char *);
+ int (*chmod) (const char *, mode_t);
+ int (*chown) (const char *, uid_t, gid_t);
+ int (*truncate) (const char *, off_t);
+ int (*utime) (const char *, struct utimbuf *);
+ int (*open) (const char *, int);
+ int (*read) (const char *, char *, size_t, off_t);
+ int (*write) (const char *, const char *, size_t, off_t);
+ int (*statfs) (struct _fuse_statfs_compat1 *);
+ int (*release) (const char *, int);
+ int (*fsync) (const char *, int);
+};
+
+#define _FUSE_DEBUG_COMPAT1 (1 << 1)
+
+int _fuse_mount_compat1(const char *mountpoint, const char *args[]);
+
+struct fuse *_fuse_new_compat1(int fd, int flags, const struct _fuse_operations_compat1 *op);
+
+void _fuse_main_compat1(int argc, char *argv[], const struct _fuse_operations_compat1 *op);
-AC_INIT(fuse-kernel, 3.0-pre0)
+AC_INIT(fuse-kernel, 2.2-pre0)
AC_CONFIG_HEADERS([config.h])
AC_PROG_INSTALL
mount.c \
fuse_i.h
-libfuse_la_LDFLAGS = -lpthread -version-number 3:0:0
+libfuse_la_LDFLAGS = -lpthread -version-number 2:2:0 \
+ -Wl,--version-script,fuse_versionscript
#include <errno.h>
#include <sys/param.h>
+#define FUSE_KERNEL_MINOR_VERSION_NEED 1
#define FUSE_VERSION_FILE_OLD "/proc/fs/fuse/version"
#define FUSE_VERSION_FILE_NEW "/sys/fs/fuse/version"
#define FUSE_DEV_OLD "/proc/fs/fuse/dev"
path = get_path(f, in->nodeid);
if (path != NULL) {
res = -ENOSYS;
- if (f->op.open)
- res = f->op.open(path, &fi);
+ if (f->op.open.curr) {
+ if (!f->compat)
+ res = f->op.open.curr(path, &fi);
+ else
+ res = f->op.open.compat2(path, fi.flags);
+ }
}
if (res == 0) {
int res2;
res2 = __send_reply(f, in, res, &outarg, sizeof(outarg), 1);
if(res2 == -ENOENT) {
/* The open syscall was interrupted, so it must be cancelled */
- if(f->op.release)
- f->op.release(path, &fi);
+ if(f->op.release.curr) {
+ if (!f->compat)
+ f->op.release.curr(path, &fi);
+ else
+ f->op.release.compat2(path, fi.flags);
+ }
} else
get_node(f, in->nodeid)->open_count ++;
pthread_mutex_unlock(&f->lock);
printf("RELEASE[%lu]\n", arg->fh);
fflush(stdout);
}
- if (f->op.release)
- f->op.release(path, &fi);
+ if (f->op.release.curr) {
+ if (!f->compat)
+ f->op.release.curr(path, &fi);
+ else
+ f->op.release.compat2(path, fi.flags);
+ }
if(node->is_hidden && node->open_count == 0)
/* can now clean up this hidden file */
return 0;
}
+static void convert_statfs_compat(struct _fuse_statfs_compat1 *compatbuf,
+ struct statfs *statfs)
+{
+ statfs->f_bsize = compatbuf->block_size;
+ statfs->f_blocks = compatbuf->blocks;
+ statfs->f_bfree = compatbuf->blocks_free;
+ statfs->f_bavail = compatbuf->blocks_free;
+ statfs->f_files = compatbuf->files;
+ statfs->f_ffree = compatbuf->files_free;
+ statfs->f_namelen = compatbuf->namelen;
+}
+
static void convert_statfs(struct statfs *statfs, struct fuse_kstatfs *kstatfs)
{
kstatfs->bsize = statfs->f_bsize;
struct statfs buf;
memset(&buf, 0, sizeof(struct statfs));
- if (f->op.statfs)
- res = f->op.statfs("/", &buf);
+ if (f->op.statfs.curr) {
+ if (!f->compat || f->compat > 11)
+ res = f->op.statfs.curr("/", &buf);
+ else {
+ struct _fuse_statfs_compat1 compatbuf;
+ memset(&compatbuf, 0, sizeof(struct _fuse_statfs_compat1));
+ res = f->op.statfs.compat1(&compatbuf);
+ if (res == 0)
+ convert_statfs_compat(&compatbuf, &buf);
+ }
+ }
else
res = default_statfs(&buf);
FUSE_KERNEL_VERSION);
return -1;
}
- if (f->minorver < FUSE_KERNEL_MINOR_VERSION) {
+ if (f->minorver < FUSE_KERNEL_MINOR_VERSION_NEED) {
fprintf(stderr, "fuse: kernel interface too old: need >= %i.%i\n",
FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
return -1;
return 0;
}
-struct fuse *fuse_new(int fd, const char *opts, const struct fuse_operations *op)
+struct fuse *fuse_new_common(int fd, const char *opts,
+ const struct fuse_operations *op,
+ size_t op_size, int compat)
{
struct fuse *f;
struct node *root;
+ if (sizeof(struct fuse_operations_i) < op_size) {
+ fprintf(stderr, "fuse: warning: library too old, some operations may not not work\n");
+ op_size = sizeof(struct fuse_operations_i);
+ }
+
f = (struct fuse *) calloc(1, sizeof(struct fuse));
if (f == NULL)
goto out;
#endif
f->numworker = 0;
f->numavail = 0;
- f->op = *op;
+ memcpy(&f->op, op, op_size);
+ f->compat = compat;
f->exited = 0;
root = (struct node *) calloc(1, sizeof(struct node));
return NULL;
}
+struct fuse *fuse_new(int fd, const char *opts,
+ const struct fuse_operations *op, size_t op_size)
+{
+ return fuse_new_common(fd, opts, op, op_size, 0);
+}
+
+struct fuse *_fuse_new_compat2(int fd, const char *opts,
+ const struct _fuse_operations_compat2 *op)
+{
+ return fuse_new_common(fd, opts, (struct fuse_operations *) op,
+ sizeof(struct _fuse_operations_compat2), 21);
+}
+
+struct fuse *_fuse_new_compat1(int fd, int flags,
+ const struct _fuse_operations_compat1 *op)
+{
+ char *opts = NULL;
+ if (flags & _FUSE_DEBUG_COMPAT1)
+ opts = "debug";
+ return fuse_new_common(fd, opts, (struct fuse_operations *) op,
+ sizeof(struct _fuse_operations_compat1), 11);
+}
+
void fuse_destroy(struct fuse *f)
{
size_t i;
pthread_mutex_destroy(&f->lock);
free(f);
}
+
+__asm__(".symver _fuse_new_compat2,fuse_new@");
*/
#include "fuse.h"
+#include "fuse_compat.h"
#include <stdio.h>
#include <pthread.h>
int is_hidden;
};
+struct fuse_operations_i {
+ int (*getattr) (const char *, struct stat *);
+ int (*readlink) (const char *, char *, size_t);
+ int (*getdir) (const char *, fuse_dirh_t, fuse_dirfil_t);
+ int (*mknod) (const char *, mode_t, dev_t);
+ int (*mkdir) (const char *, mode_t);
+ int (*unlink) (const char *);
+ int (*rmdir) (const char *);
+ int (*symlink) (const char *, const char *);
+ int (*rename) (const char *, const char *);
+ int (*link) (const char *, const char *);
+ int (*chmod) (const char *, mode_t);
+ int (*chown) (const char *, uid_t, gid_t);
+ int (*truncate) (const char *, off_t);
+ int (*utime) (const char *, struct utimbuf *);
+ union {
+ int (*curr) (const char *, struct fuse_file_info *);
+ int (*compat2) (const char *, int);
+ } open;
+ int (*read) (const char *, char *, size_t, off_t,
+ struct fuse_file_info *);
+ int (*write) (const char *, const char *, size_t, off_t,
+ struct fuse_file_info *);
+ union {
+ int (*curr) (const char *, struct statfs *);
+ int (*compat1) (struct _fuse_statfs_compat1 *);
+ } statfs;
+ int (*flush) (const char *, struct fuse_file_info *);
+ union {
+ int (*curr) (const char *, struct fuse_file_info *);
+ int (*compat2) (const char *, int);
+ } release;
+ int (*fsync) (const char *, int, struct fuse_file_info *);
+ int (*setxattr) (const char *, const char *, const char *, size_t, int);
+ int (*getxattr) (const char *, const char *, char *, size_t);
+ int (*listxattr) (const char *, char *, size_t);
+ int (*removexattr) (const char *, const char *);
+};
+
struct fuse {
int flags;
int fd;
- struct fuse_operations op;
+ struct fuse_operations_i op;
+ int compat;
struct node **name_table;
size_t name_table_size;
struct node **id_table;
char *buf;
size_t buflen;
};
+
+struct fuse *fuse_new_common(int fd, const char *opts,
+ const struct fuse_operations *op,
+ size_t op_size, int compat);
--- /dev/null
+FUSE_2.2 {
+ global:
+ __fuse_exited;
+ __fuse_loop_mt;
+ __fuse_main;
+ __fuse_process_cmd;
+ __fuse_read_cmd;
+ __fuse_set_getcontext_func;
+ __fuse_setup;
+ __fuse_teardown;
+ _fuse_setup_compat2;
+ _fuse_main_compat1;
+ _fuse_main_compat2;
+ _fuse_mount_compat1;
+ _fuse_new_compat1;
+ _fuse_new_compat2;
+ fuse_destroy;
+ fuse_exit;
+ fuse_get_context;
+ fuse_invalidate;
+ fuse_is_lib_option;
+ fuse_loop;
+ fuse_loop_mt;
+ fuse_mount;
+ fuse_new;
+ fuse_unmount;
+ local:
+ *;
+};
See the file COPYING.LIB.
*/
-#include "fuse.h"
+#include "fuse_i.h"
#include <stdio.h>
#include <stdlib.h>
}
-struct fuse *__fuse_setup(int argc, char *argv[],
- const struct fuse_operations *op,
- char **mountpoint, int *multithreaded, int *fd)
+static struct fuse *fuse_setup_common(int argc, char *argv[],
+ const struct fuse_operations *op,
+ size_t op_size,
+ char **mountpoint,
+ int *multithreaded,
+ int *fd,
+ int compat)
{
struct fuse *fuse;
int background;
char *kernel_opts;
char *lib_opts;
int res;
-
+
if (fuse_instance != NULL) {
fprintf(stderr, "fuse: __fuse_setup() called twice\n");
return NULL;
if (*fd == -1)
goto err_free;
- fuse = fuse_new(*fd, lib_opts, op);
+ fuse = fuse_new_common(*fd, lib_opts, op, op_size, compat);
if (fuse == NULL)
goto err_unmount;
return NULL;
}
+struct fuse *__fuse_setup(int argc, char *argv[],
+ const struct fuse_operations *op,
+ size_t op_size, char **mountpoint,
+ int *multithreaded, int *fd)
+{
+ return fuse_setup_common(argc, argv, op, op_size, mountpoint,
+ multithreaded, fd, 0);
+}
+
+struct fuse *_fuse_setup_compat2(int argc, char *argv[],
+ const struct _fuse_operations_compat2 *op,
+ char **mountpoint, int *multithreaded,
+ int *fd)
+{
+ return fuse_setup_common(argc, argv, (struct fuse_operations *) op,
+ sizeof(struct _fuse_operations_compat2),
+ mountpoint, multithreaded, fd, 21);
+}
+
void __fuse_teardown(struct fuse *fuse, int fd, char *mountpoint)
{
if (fuse_instance != fuse)
free(mountpoint);
}
-
-int fuse_main(int argc, char *argv[], const struct fuse_operations *op)
+static int fuse_main_common(int argc, char *argv[],
+ const struct fuse_operations *op, size_t op_size,
+ int compat)
{
struct fuse *fuse;
char *mountpoint;
int res;
int fd;
- fuse = __fuse_setup(argc, argv, op, &mountpoint, &multithreaded, &fd);
+ fuse = fuse_setup_common(argc, argv, op, op_size, &mountpoint,
+ &multithreaded, &fd, compat);
if (fuse == NULL)
return 1;
return 0;
}
+int __fuse_main(int argc, char *argv[],const struct fuse_operations *op,
+ size_t op_size)
+{
+ return fuse_main_common(argc, argv, op, op_size, 0);
+}
+
+void _fuse_main_compat1(int argc, char *argv[],
+ const struct _fuse_operations_compat1 *op)
+{
+ fuse_main_common(argc, argv, (struct fuse_operations *) op,
+ sizeof(struct _fuse_operations_compat1), 11);
+}
+
+int _fuse_main_compat2(int argc, char *argv[],
+ const struct _fuse_operations_compat2 *op)
+{
+ return fuse_main_common(argc, argv, (struct fuse_operations *) op,
+ sizeof(struct _fuse_operations_compat2), 21);
+}
+
+__asm__(".symver _fuse_setup_compat2,__fuse_setup@");
+__asm__(".symver _fuse_main_compat2,fuse_main@");
*/
#include "fuse.h"
+#include "fuse_compat.h"
#include <stdio.h>
#include <stdlib.h>
return rv;
}
+
+int _fuse_mount_compat1(const char *mountpoint, const char *args[])
+{
+ /* just ignore mount args for now */
+ (void) args;
+ return fuse_mount(mountpoint, NULL);
+}
projects / qemu-gpiodev / libfuse.git / commitdiff