* Block TERM, INT, HUP and QUIT signals in all but the main
thread. According to POSIX it's not specified which thread will
receive these signals.
-
+
+ * Kernel changes:
+
+ * Check for directory aliasing on mkdir, not just on lookup
+
+ * Check for special node ID values in create+open operation
+
+ * Sync with -mm: readv, writev, aio_read and aio_write methods
+ added to file operations
+
+ * Cleanups: lookup code, page offset calculation
+
+ * ABI stepped to 7.4, changes:
+
+ * frsize member added to fuse_kstatfs structure
+
+ * added support for negative entry caching: on lowlevel API if
+ fuse_entry_param::ino is set to zero in reply to a lookup request,
+ the kernel will cache the dentry for the specified amount of time.
+
+ * libfuse: added 'negative_timeout' option: specifies how much
+ negative entries should be cached. Default is zero, to be
+ compatible with prior versions.
+
2005-11-22 Miklos Szeredi <miklos@szeredi.hu>
* Add detection of mainline FUSE code in running kernel
/** Directory entry parameters supplied to fuse_reply_entry() */
struct fuse_entry_param {
- /** Unique inode number */
+ /** 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;
/** The ino/generation pair should be unique for the filesystem's
if (req->misc.init_in_out.major != FUSE_KERNEL_VERSION)
fc->conn_error = 1;
+ fc->minor = req->misc.init_in_out.minor;
+
/* After INIT reply is received other requests can go
out. So do (FUSE_MAX_OUTSTANDING - 1) number of
up()s on outstanding_sem. The last up() is done in
return jiffies + timespec_to_jiffies(&ts);
}
+static void fuse_change_timeout(struct dentry *entry, struct fuse_entry_out *o)
+{
+ entry->d_time = time_to_jiffies(o->entry_valid, o->entry_valid_nsec);
+ if (entry->d_inode)
+ get_fuse_inode(entry->d_inode)->i_time =
+ time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
+}
+
+void fuse_invalidate_attr(struct inode *inode)
+{
+ get_fuse_inode(inode)->i_time = jiffies - 1;
+}
+
+static void fuse_invalidate_entry_cache(struct dentry *entry)
+{
+ entry->d_time = jiffies - 1;
+}
+
+static void fuse_invalidate_entry(struct dentry *entry)
+{
+ d_invalidate(entry);
+ fuse_invalidate_entry_cache(entry);
+}
+
static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
struct dentry *entry,
struct fuse_entry_out *outarg)
static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
{
- if (!entry->d_inode || is_bad_inode(entry->d_inode))
+ struct inode *inode = entry->d_inode;
+
+ if (inode && is_bad_inode(inode))
return 0;
else if (time_after(jiffies, entry->d_time)) {
int err;
struct fuse_entry_out outarg;
- struct inode *inode = entry->d_inode;
- struct fuse_inode *fi = get_fuse_inode(inode);
- struct fuse_conn *fc = get_fuse_conn(inode);
- struct fuse_req *req = fuse_get_request(fc);
+ struct fuse_conn *fc;
+ struct fuse_req *req;
+
+ fuse_invalidate_entry_cache(entry);
+ if (!inode)
+ return 0;
+
+ fc = get_fuse_conn(inode);
+ req = fuse_get_request(fc);
if (!req)
return 0;
request_send(fc, req);
err = req->out.h.error;
if (!err) {
+ struct fuse_inode *fi = get_fuse_inode(inode);
if (outarg.nodeid != get_node_id(inode)) {
fuse_send_forget(fc, req, outarg.nodeid, 1);
return 0;
return 0;
fuse_change_attributes(inode, &outarg.attr);
- entry->d_time = time_to_jiffies(outarg.entry_valid,
- outarg.entry_valid_nsec);
- fi->i_time = time_to_jiffies(outarg.attr_valid,
- outarg.attr_valid_nsec);
+ fuse_change_timeout(entry, &outarg);
}
return 1;
}
+
+static int dir_alias(struct inode *inode)
+{
+ if (S_ISDIR(inode->i_mode)) {
+ /* Don't allow creating an alias to a directory */
+ struct dentry *alias = d_find_alias(inode);
+#if defined(FUSE_MAINLINE) || !defined(KERNEL_2_6)
+ if (alias) {
+ dput(alias);
+ return 1;
+ }
+#else
+ if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
+ dput(alias);
+ return 1;
+ }
+ dput(alias);
+#endif
+ }
+ return 0;
+}
+
+static inline int invalid_nodeid(u64 nodeid)
+{
+ return !nodeid || nodeid == FUSE_ROOT_ID;
+}
#ifndef KERNEL_2_6
static int fuse_dentry_revalidate_2_4(struct dentry *entry, int flags)
{
#endif
};
-static int fuse_lookup_iget(struct inode *dir, struct dentry *entry,
- struct inode **inodep)
+static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
+ struct nameidata *nd)
{
int err;
struct fuse_entry_out outarg;
struct inode *inode = NULL;
struct fuse_conn *fc = get_fuse_conn(dir);
struct fuse_req *req;
+#if !defined(FUSE_MAINLINE) && defined(KERNEL_2_6)
+ struct dentry *newent;
+#endif
if (entry->d_name.len > FUSE_NAME_MAX)
- return -ENAMETOOLONG;
+ return ERR_PTR(-ENAMETOOLONG);
req = fuse_get_request(fc);
if (!req)
- return -EINTR;
+ return ERR_PTR(-EINTR);
fuse_lookup_init(req, dir, entry, &outarg);
request_send(fc, req);
err = req->out.h.error;
- if (!err && (!outarg.nodeid || outarg.nodeid == FUSE_ROOT_ID))
+ if (!err && outarg.nodeid && invalid_nodeid(outarg.nodeid))
err = -EIO;
- if (!err) {
+ if (!err && outarg.nodeid) {
inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
&outarg.attr);
if (!inode) {
fuse_send_forget(fc, req, outarg.nodeid, 1);
- return -ENOMEM;
+ return ERR_PTR(-ENOMEM);
}
}
fuse_put_request(fc, req);
if (err && err != -ENOENT)
- return err;
+ return ERR_PTR(err);
- if (inode) {
- struct fuse_inode *fi = get_fuse_inode(inode);
- entry->d_time = time_to_jiffies(outarg.entry_valid,
- outarg.entry_valid_nsec);
- fi->i_time = time_to_jiffies(outarg.attr_valid,
- outarg.attr_valid_nsec);
+ if (inode && dir_alias(inode)) {
+ iput(inode);
+ return ERR_PTR(-EIO);
}
-
+#if defined(FUSE_MAINLINE) || !defined(KERNEL_2_6)
+ d_add(entry, inode);
+#else
+ newent = d_splice_alias(inode, entry);
+ entry = newent ? newent : entry;
+#endif
entry->d_op = &fuse_dentry_operations;
- *inodep = inode;
- return 0;
-}
-
-void fuse_invalidate_attr(struct inode *inode)
-{
- get_fuse_inode(inode)->i_time = jiffies - 1;
-}
-
-static void fuse_invalidate_entry(struct dentry *entry)
-{
- d_invalidate(entry);
- entry->d_time = jiffies - 1;
+ if (!err)
+ fuse_change_timeout(entry, &outarg);
+ else
+ fuse_invalidate_entry_cache(entry);
+#if defined(FUSE_MAINLINE) || !defined(KERNEL_2_6)
+ return NULL;
+#else
+ return newent;
+#endif
}
#ifdef HAVE_LOOKUP_INSTANTIATE_FILP
struct fuse_open_in inarg;
struct fuse_open_out outopen;
struct fuse_entry_out outentry;
- struct fuse_inode *fi;
struct fuse_file *ff;
struct file *file;
int flags = nd->intent.open.flags - 1;
req->out.args[1].value = &outopen;
request_send(fc, req);
err = req->out.h.error;
+ ff->fh = outopen.fh;
if (err) {
if (err == -ENOSYS)
fc->no_create = 1;
}
err = -EIO;
- if (!S_ISREG(outentry.attr.mode))
+ if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
goto out_free_ff;
inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
err = -ENOMEM;
if (!inode) {
flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
- ff->fh = outopen.fh;
fuse_send_release(fc, ff, outentry.nodeid, NULL, flags, 0);
goto out_put_request;
}
fuse_put_request(fc, req);
- entry->d_time = time_to_jiffies(outentry.entry_valid,
- outentry.entry_valid_nsec);
- fi = get_fuse_inode(inode);
- fi->i_time = time_to_jiffies(outentry.attr_valid,
- outentry.attr_valid_nsec);
d_instantiate(entry, inode);
+ fuse_change_timeout(entry, &outentry);
file = lookup_instantiate_filp(nd, entry, generic_file_open);
if (IS_ERR(file)) {
- ff->fh = outopen.fh;
fuse_send_release(fc, ff, outentry.nodeid, inode, flags, 0);
return PTR_ERR(file);
}
{
struct fuse_entry_out outarg;
struct inode *inode;
- struct fuse_inode *fi;
int err;
req->in.h.nodeid = get_node_id(dir);
fuse_put_request(fc, req);
return err;
}
- if (!outarg.nodeid || outarg.nodeid == FUSE_ROOT_ID) {
+ if (invalid_nodeid(outarg.nodeid)) {
fuse_put_request(fc, req);
return -EIO;
}
fuse_put_request(fc, req);
/* Don't allow userspace to do really stupid things... */
- if ((inode->i_mode ^ mode) & S_IFMT) {
+ if (((inode->i_mode ^ mode) & S_IFMT) || dir_alias(inode)) {
iput(inode);
return -EIO;
}
- entry->d_time = time_to_jiffies(outarg.entry_valid,
- outarg.entry_valid_nsec);
-
- fi = get_fuse_inode(inode);
- fi->i_time = time_to_jiffies(outarg.attr_valid,
- outarg.attr_valid_nsec);
-
d_instantiate(entry, inode);
+ fuse_change_timeout(entry, &outarg);
fuse_invalidate_attr(dir);
return 0;
}
inode->i_nlink = 0;
fuse_invalidate_attr(inode);
fuse_invalidate_attr(dir);
+ fuse_invalidate_entry_cache(entry);
} else if (err == -EINTR)
fuse_invalidate_entry(entry);
return err;
if (!err) {
entry->d_inode->i_nlink = 0;
fuse_invalidate_attr(dir);
+ fuse_invalidate_entry_cache(entry);
} else if (err == -EINTR)
fuse_invalidate_entry(entry);
return err;
fuse_invalidate_attr(olddir);
if (olddir != newdir)
fuse_invalidate_attr(newdir);
+
+ /* newent will end up negative */
+ fuse_invalidate_entry_cache(newent);
} else if (err == -EINTR) {
/* If request was interrupted, DEITY only knows if the
rename actually took place. If the invalidation
return err;
}
-
-static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
- struct nameidata *nd)
-{
- struct inode *inode;
- int err = fuse_lookup_iget(dir, entry, &inode);
- if (err)
- return ERR_PTR(err);
- if (inode && S_ISDIR(inode->i_mode)) {
- /* Don't allow creating an alias to a directory */
- struct dentry *alias = d_find_alias(inode);
- if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
- dput(alias);
- iput(inode);
- return ERR_PTR(-EIO);
- }
- dput(alias);
- }
- return d_splice_alias(inode, entry);
-}
#else /* KERNEL_2_6 */
-static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry)
+static struct dentry *fuse_lookup_2_4(struct inode *dir, struct dentry *entry)
{
- struct inode *inode;
- struct dentry *alias;
-
- int err = fuse_lookup_iget(dir, entry, &inode);
- if (err)
- return ERR_PTR(err);
-
- if (inode && S_ISDIR(inode->i_mode) &&
- (alias = d_find_alias(inode)) != NULL) {
- dput(alias);
- iput(inode);
- return ERR_PTR(-EIO);
- }
-
- d_add(entry, inode);
- return NULL;
+ return fuse_lookup(dir, entry, NULL);
}
static int fuse_mknod_2_4(struct inode *dir, struct dentry *entry, int mode,
{
struct inode *inode = page->mapping->host;
struct fuse_conn *fc = get_fuse_conn(inode);
- loff_t pos = (loff_t) page->index << PAGE_CACHE_SHIFT;
struct fuse_req *req = fuse_get_request(fc);
int err = -EINTR;
if (!req)
req->out.page_zeroing = 1;
req->num_pages = 1;
req->pages[0] = page;
- fuse_send_read(req, file, inode, pos, PAGE_CACHE_SIZE);
+ fuse_send_read(req, file, inode, page_offset(page), PAGE_CACHE_SIZE);
err = req->out.h.error;
fuse_put_request(fc, req);
if (!err)
static int fuse_send_readpages(struct fuse_req *req, struct file *file,
struct inode *inode)
{
- loff_t pos = (loff_t) req->pages[0]->index << PAGE_CACHE_SHIFT;
+ loff_t pos = page_offset(req->pages[0]);
size_t count = req->num_pages << PAGE_CACHE_SHIFT;
unsigned i;
req->out.page_zeroing = 1;
unsigned count = to - offset;
struct inode *inode = page->mapping->host;
struct fuse_conn *fc = get_fuse_conn(inode);
- loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + offset;
+ loff_t pos = page_offset(page) + offset;
struct fuse_req *req = fuse_get_request(fc);
if (!req)
return -EINTR;
static struct file_operations fuse_file_operations = {
.llseek = generic_file_llseek,
#ifdef KERNEL_2_6
- .read = generic_file_read,
+ .read = do_sync_read,
+ .write = do_sync_write,
+ .readv = generic_file_readv,
+ .writev = generic_file_writev,
+ .aio_read = generic_file_aio_read,
+ .aio_write = generic_file_aio_write,
#else
.read = fuse_file_read,
-#endif
.write = generic_file_write,
+#endif
.mmap = fuse_file_mmap,
.open = fuse_open,
.flush = fuse_flush,
/** Is create not implemented by fs? */
unsigned no_create : 1;
+ /** Negotiated minor version */
+ unsigned minor;
+
#ifdef KERNEL_2_6
/** Backing dev info */
struct backing_dev_info bdi;
See the file COPYING.
*/
+/* This file defines the kernel interface of FUSE */
+
+#ifdef __FreeBSD__
/*
This -- and only this -- header file may also be distributed under
the terms of the BSD Licence as follows:
SUCH DAMAGE.
*/
-/* This file defines the kernel interface of FUSE */
-
-#ifdef __FreeBSD__
#include <sys/types.h>
#define __u64 uint64_t
#define __u32 uint32_t
#define FUSE_KERNEL_VERSION 7
/** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 3
+#define FUSE_KERNEL_MINOR_VERSION 4
/** The node ID of the root inode */
#define FUSE_ROOT_ID 1
__u64 ffree;
__u32 bsize;
__u32 namelen;
+ __u32 frsize;
+ __u32 padding;
+ __u32 spare[6];
};
#define FATTR_MODE (1 << 0)
__u32 padding;
};
+#define FUSE_COMPAT_STATFS_SIZE 12
+
struct fuse_statfs_out {
struct fuse_kstatfs st;
};
{
stbuf->f_type = FUSE_SUPER_MAGIC;
stbuf->f_bsize = attr->bsize;
+ stbuf->f_frsize = attr->frsize;
stbuf->f_blocks = attr->blocks;
stbuf->f_bfree = attr->bfree;
stbuf->f_bavail = attr->bavail;
if (!req)
return -EINTR;
+ memset(&outarg, 0, sizeof(outarg));
req->in.numargs = 0;
req->in.h.opcode = FUSE_STATFS;
req->out.numargs = 1;
- req->out.args[0].size = sizeof(outarg);
+ req->out.args[0].size =
+ fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
req->out.args[0].value = &outarg;
request_send(fc, req);
err = req->out.h.error;
unsigned int gid;
unsigned int umask;
double entry_timeout;
+ double negative_timeout;
double attr_timeout;
};
fflush(stdout);
}
err = -ENOSYS;
- if (f->op.getattr)
+ if (f->op.getattr) {
err = lookup_path(f, parent, name, path, &e, NULL);
+ if (err == -ENOENT && f->negative_timeout != 0.0) {
+ e.ino = 0;
+ e.entry_timeout = f->negative_timeout;
+ err = 0;
+ }
+ }
free(path);
}
pthread_rwlock_unlock(&f->tree_lock);
begins_with(opt, "uid=") ||
begins_with(opt, "gid=") ||
begins_with(opt, "entry_timeout=") ||
- begins_with(opt, "attr_timeout="))
+ begins_with(opt, "attr_timeout=") ||
+ begins_with(opt, "negative_timeout="))
return 1;
else
return 0;
/* nop */;
else if (sscanf(opt, "attr_timeout=%lf", &f->attr_timeout) == 1)
/* nop */;
+ else if (sscanf(opt, "negative_timeout=%lf",
+ &f->negative_timeout) == 1)
+ /* nop */;
else
fprintf(stderr, "fuse: warning: unknown option `%s'\n", opt);
}
f->entry_timeout = 1.0;
f->attr_timeout = 1.0;
+ f->negative_timeout = 0.0;
if (parse_lib_opts(f, opts, &llopts) == -1)
goto out_free;
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;
{
struct fuse_entry_out arg;
+ /* before ABI 7.4 e->ino == 0 was invalid, only ENOENT meant
+ negative entry */
+ if (!e->ino && req->f->minor < 4)
+ return fuse_reply_err(req, ENOENT);
+
memset(&arg, 0, sizeof(arg));
fill_entry(&arg, e);
return send_reply_ok(req, &arg, sizeof(arg));
int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
{
struct fuse_statfs_out arg;
+ size_t size = req->f->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(arg);
memset(&arg, 0, sizeof(arg));
convert_statfs(stbuf, &arg.st);
- return send_reply_ok(req, &arg, sizeof(arg));
+ return send_reply_ok(req, &arg, size);
}
int fuse_reply_xattr(fuse_req_t req, size_t count)
f->op.init(f->userdata);
f->major = FUSE_KERNEL_VERSION;
- f->minor = FUSE_KERNEL_MINOR_VERSION;
+ f->minor = arg->minor;
memset(&outarg, 0, sizeof(outarg));
outarg.major = f->major;
- outarg.minor = f->minor;
+ outarg.minor = FUSE_KERNEL_MINOR_VERSION;
if (f->debug) {
printf(" INIT: %u.%u\n", outarg.major, outarg.minor);
arg->open_flags |= FOPEN_KEEP_CACHE;
}
-static void convert_statfs_compat(const struct statfs *stbuf,
- struct fuse_kstatfs *kstatfs)
+static void convert_statfs_compat(const struct statfs *compatbuf,
+ struct statvfs *buf)
{
- kstatfs->bsize = stbuf->f_bsize;
- 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_namelen;
+ buf->f_bsize = compatbuf->f_bsize;
+ buf->f_blocks = compatbuf->f_blocks;
+ buf->f_bfree = compatbuf->f_bfree;
+ buf->f_bavail = compatbuf->f_bavail;
+ buf->f_files = compatbuf->f_files;
+ buf->f_ffree = compatbuf->f_ffree;
+ buf->f_namemax = compatbuf->f_namelen;
}
int fuse_reply_open_compat(fuse_req_t req,
int fuse_reply_statfs_compat(fuse_req_t req, const struct statfs *stbuf)
{
- struct fuse_statfs_out arg;
+ struct statvfs newbuf;
- memset(&arg, 0, sizeof(arg));
- convert_statfs_compat(stbuf, &arg.st);
+ memset(&newbuf, 0, sizeof(newbuf));
+ convert_statfs_compat(stbuf, &newbuf);
- return send_reply_ok(req, &arg, sizeof(arg));
+ return fuse_reply_statfs(req, &newbuf);
}
__asm__(".symver fuse_reply_statfs_compat,fuse_reply_statfs@FUSE_2.4");
__asm__(".symver fuse_reply_open_compat,fuse_reply_open@FUSE_2.4");
-#endif __FreeBSD__
+#endif /* __FreeBSD__ */
projects / qemu-gpiodev / libfuse.git / commitdiff