+2004-01-26 Miklos Szeredi <mszeredi@inf.bme.hu>
+
+ * Fix typo (thanks Marcos Dione)
+
+2004-01-23 Miklos Szeredi <mszeredi@inf.bme.hu>
+
+ * Fix CONFIG_MODVERSIONS compile on 2.6
+
+2004-01-22 Miklos Szeredi <mszeredi@inf.bme.hu>
+
+ * Write all pending data before a RELEASE operation
+
+ * Suppress 'Bad file descriptor' warning on exit
+
+ * Replaced fusermount option '-d xxx' with '-n xxx' so it doesn't
+ get confused with '-d' of fuse_main() (sorry for the change)
+
+ * New fusermount option '-l' which enables big reads
+
+ * fuse_main() can accept fusermount arguments after a '--'
+
2004-01-19 Miklos Szeredi <mszeredi@inf.bme.hu>
* Support for exporting filesystem over NFS (see README.NFS)
-For the moment NFS exporting is supported on kernels versions >=
-2.6.0.
+NFS exporting is supported on kernels versions >= 2.6.0. For 2.4.X
+kernels the exporting infrastructure is not refined enough, so don't
+expect this to work.
You need to add an fsid=NNN option to /etc/exports to make exporting a
FUSE directory work.
You may get ESTALE (Stale NFS file handle) errors with this. This is
because the current FUSE kernel API and the userspace library cannot
-handle a situation where the kernel forgets about a dentry which is
+handle a situation where the kernel forgets about an inode which is
still referenced by the remote NFS client. This problem will be
addressed in a later version.
stbuf->st_nlink = 1;
stbuf->st_uid = getuid();
stbuf->st_gid = getgid();
- stbuf->st_size = (1 << 30); /* 1G */
+ stbuf->st_size = (1ULL << 32); /* 4G */
stbuf->st_blocks = 0;
stbuf->st_atime = stbuf->st_mtime = stbuf->st_ctime = time(NULL);
*
* - read(), write() are not passed a filehandle, but rather a
* pathname. The offset of the read and write is passed as the last
- * argument, like the pread() and pwrite() system calls.
+ * argument, like the pread() and pwrite() system calls. (NOTE:
+ * read() should always return the number of bytes requested, except
+ * at end of file)
*
* - release() is called when an open file has:
* 1) all file descriptors closed
* main() function.
*
* This function does the following:
- * - mounts the filesystem
+ * - parses command line options (-d -s and -h)
+ * - passes all options after '--' to the fusermount program
+ * - mounts the filesystem by calling fusermount
* - installs signal handlers for INT, HUP, TERM and PIPE
* - registers an exit handler to unmount the filesystem on program exit
- * - parses command line options (-d -s and -h)
* - creates a fuse handle
* - registers the operations
* - calls either the single-threaded or the multi-threaded event loop
#define FUSE_KERNEL_VERSION 2
/** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 1
+#define FUSE_KERNEL_MINOR_VERSION 2
/** The inode number of the root indode */
#define FUSE_ROOT_INO 1
until the INVALIDATE operation is invoked */
#define FUSE_KERNEL_CACHE (1 << 2)
+/** Allow FUSE to combine reads into 64k chunks. This is useful if
+ the filesystem is better at handling large chunks. NOTE: in
+ current implementation the raw throughput is worse for large reads
+ than for small. */
+#define FUSE_LARGE_READ (1 << 3)
+
struct fuse_attr {
unsigned int mode;
unsigned int nlink;
if(ret < 0) {
req->out->h.error = -EPROTO;
req->finished = 1;
- }
- else {
+ } else {
list_add_tail(&req->list, &fc->processing);
req->sent = 1;
}
static struct file_operations fuse_dir_operations;
-static struct dentry_operations fuse_dentry_opertations;
+static struct dentry_operations fuse_dentry_operations;
/* FIXME: This should be user configurable */
#define FUSE_REVALIDATE_TIME (1 * HZ)
return err;
entry->d_time = jiffies;
- entry->d_op = &fuse_dentry_opertations;
+ entry->d_op = &fuse_dentry_operations;
*inodep = inode;
return 0;
}
#endif
};
-static struct dentry_operations fuse_dentry_opertations = {
+static struct dentry_operations fuse_dentry_operations = {
.d_revalidate = fuse_dentry_revalidate,
};
struct fuse_open_in *inarg = NULL;
unsigned int s = sizeof(struct fuse_in) + sizeof(struct fuse_open_in);
+ if(file->f_mode & FMODE_WRITE)
+ filemap_fdatawrite(inode->i_mapping);
+
in = kmalloc(s, GFP_NOFS);
if(!in)
return -ENOMEM;
char *buffer;
page = grab_cache_page(mapping, index);
-
if (!page)
return -1;
return out.h.error;
}
-static ssize_t fuse_file_read(struct file *filp, char *buf,
- size_t count, loff_t * ppos)
+static void fuse_file_bigread(struct address_space *mapping,
+ struct inode *inode, loff_t pos, size_t count)
{
- struct address_space *mapping = filp->f_dentry->d_inode->i_mapping;
- struct inode *inode = mapping->host;
-
- size_t bl_index = *ppos >> FUSE_BLOCK_SHIFT;
- size_t bl_end_index = (*ppos + count) >> FUSE_BLOCK_SHIFT;
+ size_t bl_index = pos >> FUSE_BLOCK_SHIFT;
+ size_t bl_end_index = (pos + count) >> FUSE_BLOCK_SHIFT;
size_t bl_file_end_index = inode->i_size >> FUSE_BLOCK_SHIFT;
-
+
if (bl_end_index > bl_file_end_index)
bl_end_index = bl_file_end_index;
-
+
while (bl_index <= bl_end_index) {
int res;
char *bl_buf = kmalloc(FUSE_BLOCK_SIZE, GFP_NOFS);
-
if (!bl_buf)
break;
-
res = fuse_is_block_uptodate(mapping, inode, bl_index);
-
if (!res)
res = fuse_file_read_block(inode, bl_buf, bl_index);
-
if (!res)
fuse_cache_block(mapping, inode, bl_buf, bl_index);
-
kfree(bl_buf);
-
bl_index++;
}
+}
+
+static ssize_t fuse_file_read(struct file *filp, char *buf,
+ size_t count, loff_t * ppos)
+{
+ struct address_space *mapping = filp->f_dentry->d_inode->i_mapping;
+ struct inode *inode = mapping->host;
+ struct fuse_conn *fc = INO_FC(inode);
+
+ if(fc->flags & FUSE_LARGE_READ)
+ fuse_file_bigread(mapping, inode, *ppos, count);
return generic_file_read(filp, buf, count, ppos);
}
void fuse_init_file_inode(struct inode *inode)
{
- inode->i_fop = &fuse_file_operations;
- inode->i_data.a_ops = &fuse_file_aops;
#ifdef KERNEL_2_6
- inode->i_mapping->backing_dev_info->ra_pages = 0;
+ struct fuse_conn *fc = INO_FC(inode);
+ /* Readahead somehow defeats big reads on 2.6 (says Michael
+ Grigoriev) */
+ if(fc->flags & FUSE_LARGE_READ)
+ inode->i_mapping->backing_dev_info->ra_pages = 0;
#endif
+ inode->i_fop = &fuse_file_operations;
+ inode->i_data.a_ops = &fuse_file_aops;
}
/*
#include <linux/fuse.h>
+#include <linux/version.h>
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) && LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
+#error Kernel version 2.5.* not supported
+#endif
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+#define KERNEL_2_6
+#endif
+
+#ifndef KERNEL_2_6
#include <linux/config.h>
#ifdef CONFIG_MODVERSIONS
#define MODVERSIONS
#include <linux/modversions.h>
#endif
+#endif
#include <linux/kernel.h>
#include <linux/module.h>
-#include <linux/version.h>
#include <linux/fs.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#define FUSE_BLOCK_PAGE_SHIFT (FUSE_BLOCK_SHIFT - PAGE_CACHE_SHIFT)
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) && LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
-#error Kernel version 2.5.* not supported
-#endif
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
-#define KERNEL_2_6
-#endif
-
-
/**
* A Fuse connection.
*
sb->s_export_op = &fuse_export_operations;
#endif
- root = get_root_inode(sb, d->rootmode);
- if(root == NULL) {
- printk("fuse_read_super: failed to get root inode\n");
- return -EINVAL;
- }
-
- spin_lock(&fuse_lock);
fc = get_conn(d);
if(fc == NULL)
- goto err;
-
+ return -EINVAL;
+ spin_lock(&fuse_lock);
if(fc->sb != NULL) {
printk("fuse_read_super: connection already mounted\n");
- goto err;
+ spin_unlock(&fuse_lock);
+ return -EINVAL;
}
-
- SB_FC(sb) = fc;
- sb->s_root = d_alloc_root(root);
- if(!sb->s_root)
- goto err;
-
fc->sb = sb;
fc->flags = d->flags;
fc->uid = d->uid;
spin_unlock(&fuse_lock);
- return 0;
+ /* fc is needed in fuse_init_file_inode which could be called
+ from get_root_inode */
+ SB_FC(sb) = fc;
- err:
- spin_unlock(&fuse_lock);
- iput(root);
- return -EINVAL;
+ root = get_root_inode(sb, d->rootmode);
+ if(root == NULL) {
+ printk("fuse_read_super: failed to get root inode\n");
+ return -EINVAL;
+ }
+
+ sb->s_root = d_alloc_root(root);
+ if(!sb->s_root)
+ return -EINVAL;
+
+ return 0;
}
#ifdef KERNEL_2_6
res = read(f->fd, cmd->buf, FUSE_MAX_IN);
if(res == -1) {
free_cmd(cmd);
- if(errno == EINTR)
+ if(f->exited || errno == EINTR)
return NULL;
/* ENODEV means we got unmounted, so we silenty return failure */
static void usage(char *progname)
{
fprintf(stderr,
- "usage: %s mountpoint [options] \n"
+ "usage: %s mountpoint [options] [-- [fusermount options]]\n"
"Options:\n"
" -d enable debug output\n"
" -s disable multithreaded operation\n"
- " -h print help\n",
+ " -h print help\n"
+ "\n"
+ "Fusermount options:\n"
+ " see 'fusermount -h'\n",
progname);
exit(1);
}
+static void invalid_option(char *argv[], int argctr)
+{
+ fprintf(stderr, "invalid option: %s\n", argv[argctr]);
+ usage(argv[0]);
+}
+
static void exit_handler()
{
if(fuse != NULL)
int fuse_fd;
char *fuse_mountpoint = NULL;
char umount_cmd[1024] = "";
-
- if(isreexec == NULL) {
+ char **fusermount_args = NULL;
+
+ if(!isreexec) {
if(argc < 2 || argv[1][0] == '-')
usage(argv[0]);
+ argctr ++;
+ }
+ flags = 0;
+ multithreaded = 1;
+ for(; argctr < argc && !fusermount_args; argctr ++) {
+ if(argv[argctr][0] == '-' && strlen(argv[argctr]) == 2)
+ switch(argv[argctr][1]) {
+ case 'd':
+ flags |= FUSE_DEBUG;
+ break;
+
+ case 's':
+ multithreaded = 0;
+ break;
+
+ case 'h':
+ usage(argv[0]);
+ break;
+
+ case '-':
+ if(!isreexec)
+ fusermount_args = &argv[argctr+1];
+ else
+ invalid_option(argv, argctr);
+ break;
+
+ default:
+ invalid_option(argv, argctr);
+ }
+ else
+ invalid_option(argv, argctr);
+ }
+
+ if(!isreexec) {
fuse_mountpoint = strdup(argv[1]);
- fuse_fd = fuse_mount(fuse_mountpoint, NULL);
+ fuse_fd = fuse_mount(fuse_mountpoint, (const char **) fusermount_args);
if(fuse_fd == -1)
exit(1);
-
- argctr++;
- }
- else {
+ } else {
char *tmpstr;
/* Old (obsolescent) way of doing the mount:
set_signal_handlers();
- flags = 0;
- multithreaded = 1;
- for(; argctr < argc && argv[argctr][0] == '-'; argctr ++) {
- switch(argv[argctr][1]) {
- case 'd':
- flags |= FUSE_DEBUG;
- break;
-
- case 's':
- multithreaded = 0;
- break;
-
- case 'h':
- usage(argv[0]);
- break;
-
- default:
- fprintf(stderr, "invalid option: %s\n", argv[argctr]);
- exit(1);
- }
- }
- if(argctr != argc) {
- fprintf(stderr, "missing or surplus argument\n");
- exit(1);
- }
-
fuse = fuse_new(fuse_fd, flags, op);
if(multithreaded)
" -p check default permissions on files\n"
" -c cache in kernel space if possible\n"
" -x allow other users to access the files (only for root)\n"
- " -d name add 'name' as the filesystem name to mtab\n",
+ " -n name add 'name' as the filesystem name to mtab\n"
+ " -l issue large reads\n",
progname);
exit(1);
}
flags |= FUSE_ALLOW_OTHER;
break;
- case 'd':
+ case 'n':
a++;
if(a == argc) {
- fprintf(stderr, "%s: Missing argument to -d\n", progname);
+ fprintf(stderr, "%s: Missing argument to -n\n", progname);
exit(1);
}
fsname = argv[a];
break;
+ case 'l':
+ flags |= FUSE_LARGE_READ;
+ break;
+
default:
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[a]);
exit(1);
projects / qemu-gpiodev / libfuse.git / commitdiff