filesystems. A good example is sshfs: a secure network filesystem
using the sftp protocol.
+Mount options
+~~~~~~~~~~~~~
+
+'default_permissions'
+
+ By default FUSE doesn't check file access permissions, the
+ filesystem is free to implement it's access policy or leave it to
+ the underlying file access mechanism (e.g. in case of network
+ filesystems). This option enables permission checking, restricting
+ access based on file mode. This is option is usually useful
+ together with the 'allow_other' mount option.
+
+'allow_other'
+
+ This option overrides the security measure restricting file access
+ to the user mounting the filesystem. This option is by default only
+ allowed to root, but this restriction can be removed with a
+ (userspace) configuration option.
+
+'kernel_cache'
+
+ This option disables flushing the cache of the file contents on
+ every open(). 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(), so a read() system call will not
+ always initiate a read operation.
+
+'direct_io'
+
+ This option disables the use of page cache (file content cache) in
+ the kernel for this filesystem. This has several affects:
+
+ - Each read() or write() system call will initiate one or more
+ read or write operations, data will not be cached in the
+ kernel.
+
+ - 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).
+
+'max_read=N'
+
+ With this option the maximum size of read operations can be set.
+ The default is infinite. Note that the size of read requests is
+ limited anyway to 32 pages (which is 128kbyte on i386).
+
How do non-privileged mounts work?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
return res;
}
-static ssize_t fuse_file_read(struct file *file, char __user *buf,
- size_t count, loff_t *ppos)
+static ssize_t fuse_direct_read(struct file *file, char __user *buf,
+ size_t count, loff_t *ppos)
{
- struct inode *inode = file->f_dentry->d_inode;
- struct fuse_conn *fc = get_fuse_conn(inode);
+ return fuse_direct_io(file, buf, count, ppos, 0);
+}
- if (fc->flags & FUSE_DIRECT_IO)
- return fuse_direct_io(file, buf, count, ppos, 0);
-#ifndef KERNEL_2_6
- else {
- if (fc->flags & FUSE_LARGE_READ) {
- int res;
- down(&inode->i_sem);
- res = fuse_file_bigread(file, inode, *ppos, count);
- up(&inode->i_sem);
- if (res)
- return res;
- }
- return generic_file_read(file, buf, count, ppos);
- }
-#else
- else
- return generic_file_read(file, buf, count, ppos);
-#endif
+static ssize_t fuse_direct_write(struct file *file, const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct inode *inode = file->f_dentry->d_inode;
+ ssize_t res;
+ /* Don't allow parallel writes to the same file */
+ down(&inode->i_sem);
+ res = fuse_direct_io(file, buf, count, ppos, 1);
+ up(&inode->i_sem);
+ return res;
}
-static ssize_t fuse_file_write(struct file *file, const char __user *buf,
- size_t count, loff_t *ppos)
+#ifndef KERNEL_2_6
+static ssize_t fuse_file_read(struct file *file, char __user *buf,
+ size_t count, loff_t *ppos)
{
struct inode *inode = file->f_dentry->d_inode;
struct fuse_conn *fc = get_fuse_conn(inode);
- if (fc->flags & FUSE_DIRECT_IO) {
- ssize_t res;
- /* Don't allow parallel writes to the same file */
+ if (fc->flags & FUSE_LARGE_READ) {
+ int res;
down(&inode->i_sem);
- res = fuse_direct_io(file, buf, count, ppos, 1);
+ res = fuse_file_bigread(file, inode, *ppos, count);
up(&inode->i_sem);
- return res;
+ if (res)
+ return res;
}
- else
- return generic_file_write(file, buf, count, ppos);
+ return generic_file_read(file, buf, count, ppos);
}
-
+#endif
static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma)
{
- struct inode *inode = file->f_dentry->d_inode;
- struct fuse_conn *fc = get_fuse_conn(inode);
-
- if (fc->flags & FUSE_DIRECT_IO)
- return -ENODEV;
-
if ((vma->vm_flags & VM_SHARED)) {
if ((vma->vm_flags & VM_WRITE))
return -ENODEV;
}
#ifdef KERNEL_2_6
-static ssize_t fuse_file_sendfile(struct file *file, loff_t *ppos,
- size_t count, read_actor_t actor,
- void *target)
-{
- struct fuse_conn *fc = get_fuse_conn(file->f_dentry->d_inode);
- if (fc->flags & FUSE_DIRECT_IO)
- return -EINVAL;
- else
- return generic_file_sendfile(file, ppos, count, actor, target);
-}
-
static int fuse_set_page_dirty(struct page *page)
{
printk("fuse_set_page_dirty: should not happen\n");
static struct file_operations fuse_file_operations = {
.llseek = generic_file_llseek,
+#ifdef KERNEL_2_6
+ .read = generic_file_read,
+#else
.read = fuse_file_read,
- .write = fuse_file_write,
+#endif
+ .write = generic_file_write,
.mmap = fuse_file_mmap,
.open = fuse_open,
.flush = fuse_flush,
.release = fuse_release,
.fsync = fuse_fsync,
#ifdef KERNEL_2_6
- .sendfile = fuse_file_sendfile,
+ .sendfile = generic_file_sendfile,
#endif
};
+static struct file_operations fuse_direct_io_file_operations = {
+ .llseek = generic_file_llseek,
+ .read = fuse_direct_read,
+ .write = fuse_direct_write,
+ .open = fuse_open,
+ .flush = fuse_flush,
+ .release = fuse_release,
+ .fsync = fuse_fsync,
+ /* no mmap and sendfile */
+};
+
static struct address_space_operations fuse_file_aops = {
.readpage = fuse_readpage,
.prepare_write = fuse_prepare_write,
void fuse_init_file_inode(struct inode *inode)
{
- inode->i_fop = &fuse_file_operations;
- inode->i_data.a_ops = &fuse_file_aops;
+ struct fuse_conn *fc = get_fuse_conn(inode);
+
+ if (fc->flags & FUSE_DIRECT_IO)
+ inode->i_fop = &fuse_direct_io_file_operations;
+ else {
+ inode->i_fop = &fuse_file_operations;
+ inode->i_data.a_ops = &fuse_file_aops;
+ }
}
projects / qemu-gpiodev / libfuse.git / commitdiff