+2004-07-16 Miklos Szeredi <miklos@szeredi.hu>
+
+ * Separate directory entry and inode attribute validity timer
+
+ * New write semaphore to stop page writeback during truncate
+
+ * Fsync now waits for all writes to complete before sending the
+ request
+
+ * Optimization: if a page is completely written by
+ fuse_commit_write(), clear the dirty flag and set the uptodate
+ flag for that page
+
2004-07-13 Miklos Szeredi <miklos@szeredi.hu>
* Add FUSE_HARD_REMOVE flag, and '-i' option to fuse main, which
return fc->reqctr;
}
+void fuse_reset_request(struct fuse_req *req)
+{
+ int preallocated = req->preallocated;
+
+ memset(req, 0, sizeof(*req));
+ INIT_LIST_HEAD(&req->list);
+ init_waitqueue_head(&req->waitq);
+ req->preallocated = preallocated;
+}
+
static struct fuse_req *do_get_request(struct fuse_conn *fc)
{
struct fuse_req *req;
req = list_entry(fc->unused_list.next, struct fuse_req, list);
list_del_init(&req->list);
spin_unlock(&fuse_lock);
-
- memset(req, 0, sizeof(*req));
- INIT_LIST_HEAD(&req->list);
- init_waitqueue_head(&req->waitq);
- req->preallocated = 1;
-
+ fuse_reset_request(req);
return req;
}
struct inode *inode = iget(fc->sb, uh->ino);
int err = -ENOENT;
if (inode) {
- if (inode->u.generic_ip) {
+ if (FUSE_FI(inode)) {
invalidate_inode_pages(inode);
err = 0;
}
free_conn(fc);
return NULL;
}
+ req->preallocated = 1;
list_add(&req->list, &fc->unused_list);
}
fc->reqctr = 1;
inode = iget(sb, ino);
if (inode) {
- if (!inode->u.generic_ip) {
- struct fuse_req *req = fuse_request_alloc();
- if (!req) {
+ if (!INO_FI(inode)) {
+ struct fuse_inode *fi = fuse_inode_alloc();
+ if (!fi) {
iput(inode);
inode = NULL;
goto out;
}
- inode->u.generic_ip = req;
+ INO_FI(inode) = fi;
inode->i_generation = generation;
fuse_init_inode(inode, attr);
} else if (inode->i_generation != generation)
if (err && err != -ENOENT)
return err;
- if (inode)
- entry->d_time = time_to_jiffies(outarg.entry_valid,
+ if (inode) {
+ struct fuse_inode *fi = INO_FI(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);
+ }
entry->d_op = &fuse_dentry_operations;
*inodep = inode;
return 0;
}
-static void uncache_dir(struct inode *dir)
+static void fuse_invalidate_attr(struct inode *inode)
{
- struct dentry *entry = d_find_alias(dir);
- if (!entry)
- dir->i_nlink = 0;
- else {
- /* FIXME: this should reset the _attribute_ timeout */
- entry->d_time = jiffies - 1;
- dput(entry);
- }
+ struct fuse_inode *fi = INO_FI(inode);
+ fi->i_time = jiffies - 1;
}
static int lookup_new_entry(struct fuse_conn *fc, struct fuse_req *req,
int mode)
{
struct inode *inode;
+ struct fuse_inode *fi;
inode = fuse_iget(dir->i_sb, outarg->ino, outarg->generation,
&outarg->attr, version);
if (!inode) {
entry->d_time = time_to_jiffies(outarg->entry_valid,
outarg->entry_valid_nsec);
+ fi = INO_FI(inode);
+ fi->i_time = time_to_jiffies(outarg->attr_valid,
+ outarg->attr_valid_nsec);
+
d_instantiate(entry, inode);
- uncache_dir(dir);
+ fuse_invalidate_attr(dir);
return 0;
}
request_send(fc, req);
err = req->out.h.error;
if (!err) {
+ struct inode *inode = entry->d_inode;
+
/* Set nlink to zero so the inode can be cleared, if
the inode does have more links this will be
discovered at the next lookup/getattr */
- /* FIXME: mark inode "not uptodate" */
- entry->d_inode->i_nlink = 0;
- uncache_dir(dir);
+ inode->i_nlink = 0;
+ fuse_invalidate_attr(inode);
+ fuse_invalidate_attr(dir);
}
fuse_put_request(fc, req);
return err;
err = req->out.h.error;
if (!err) {
entry->d_inode->i_nlink = 0;
- uncache_dir(dir);
+ fuse_invalidate_attr(dir);
}
fuse_put_request(fc, req);
return err;
err = req->out.h.error;
fuse_put_request(fc, req);
if (!err) {
- uncache_dir(olddir);
+ fuse_invalidate_attr(olddir);
if (olddir != newdir)
- uncache_dir(newdir);
+ fuse_invalidate_attr(newdir);
}
return err;
}
int fuse_do_getattr(struct inode *inode)
{
+ struct fuse_inode *fi = INO_FI(inode);
struct fuse_conn *fc = INO_FC(inode);
struct fuse_req *req = fuse_get_request(fc);
struct fuse_attr_out arg;
req->out.args[0].value = &arg;
request_send(fc, req);
err = req->out.h.error;
- if (!err)
+ if (!err) {
change_attributes(inode, &arg.attr);
+ fi->i_time = time_to_jiffies(arg.attr_valid,
+ arg.attr_valid_nsec);
+ }
fuse_put_request(fc, req);
return err;
}
static int fuse_revalidate(struct dentry *entry)
{
struct inode *inode = entry->d_inode;
+ struct fuse_inode *fi = INO_FI(inode);
struct fuse_conn *fc = INO_FC(inode);
if (inode->i_ino == FUSE_ROOT_INO) {
if (!(fc->flags & FUSE_ALLOW_OTHER) &&
current->fsuid != fc->uid)
return -EACCES;
- } else if (!entry->d_time || time_before_eq(jiffies, entry->d_time))
+ } else if (!fi->i_time || time_before_eq(jiffies, fi->i_time))
return 0;
return fuse_do_getattr(inode);
{
struct inode *inode = entry->d_inode;
struct fuse_conn *fc = INO_FC(inode);
+ struct fuse_inode *fi = INO_FI(inode);
struct fuse_req *req;
struct fuse_setattr_in inarg;
struct fuse_attr_out outarg;
int err;
+ int is_truncate = 0;
+
+
+ if (attr->ia_valid & ATTR_SIZE) {
+ unsigned long limit;
+ is_truncate = 1;
- /* FIXME: need to fix race between truncate and writepage */
- if (attr->ia_valid & ATTR_SIZE)
- fuse_sync_inode(inode);
+ limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
+ if (limit != RLIM_INFINITY && attr->ia_size > limit) {
+ send_sig(SIGXFSZ, current, 0);
+ return -EFBIG;
+ }
+ //fuse_sync_inode(inode);
+ }
req = fuse_get_request(fc);
if (!req)
return -ERESTARTSYS;
+ if (is_truncate)
+ down_write(&fi->write_sem);
+
memset(&inarg, 0, sizeof(inarg));
inarg.valid = iattr_to_fattr(attr, &inarg.attr);
req->in.h.opcode = FUSE_SETATTR;
req->out.args[0].value = &outarg;
request_send(fc, req);
err = req->out.h.error;
- if (!err) {
- if (attr->ia_valid & ATTR_SIZE &&
- outarg.attr.size < i_size_read(inode))
- vmtruncate(inode, outarg.attr.size);
+ fuse_put_request(fc, req);
+ if (!err) {
+ if (is_truncate) {
+ loff_t origsize = i_size_read(inode);
+ i_size_write(inode, outarg.attr.size);
+ up_write(&fi->write_sem);
+ if (origsize > outarg.attr.size)
+ vmtruncate(inode, outarg.attr.size);
+ }
change_attributes(inode, &outarg.attr);
- }
- fuse_put_request(fc, req);
+ fi->i_time = time_to_jiffies(outarg.attr_valid,
+ outarg.attr_valid_nsec);
+ } else if (is_truncate)
+ up_write(&fi->write_sem);
+
return err;
}
return 0;
else if (entry->d_time && time_after(jiffies, entry->d_time)) {
struct inode *inode = entry->d_inode;
+ struct fuse_inode *fi = INO_FI(inode);
struct fuse_entry_out outarg;
int version;
int ret;
inode->i_version = version;
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);
}
return 1;
}
static int fuse_fsync(struct file *file, struct dentry *de, int datasync)
{
struct inode *inode = de->d_inode;
+ struct fuse_inode *fi = INO_FI(inode);
struct fuse_conn *fc = INO_FC(inode);
struct fuse_req *req;
struct fuse_fsync_in inarg;
req = fuse_get_request(fc);
if (!req)
return -ERESTARTSYS;
-
+
+ /* Make sure all writes to this inode are completed before
+ issuing the FSYNC request */
+ down_write(&fi->write_sem);
+ up_write(&fi->write_sem);
+
memset(&inarg, 0, sizeof(inarg));
inarg.datasync = datasync;
req->in.h.opcode = FUSE_FSYNC;
}
fuse_put_request(fc, req);
return err;
-
- /* FIXME: need to ensure, that all write requests issued
- before this request are completed. Should userspace take
- care of this? */
}
static ssize_t fuse_send_read(struct inode *inode, char *buf, loff_t pos,
struct fuse_conn *fc = INO_FC(inode);
ssize_t res;
- down(&inode->i_sem);
if (fc->flags & FUSE_DIRECT_IO) {
res = fuse_read(file, buf, count, ppos);
}
else {
- if (fc->flags & FUSE_LARGE_READ)
+ if (fc->flags & FUSE_LARGE_READ) {
+ down(&inode->i_sem);
fuse_file_bigread(inode, *ppos, count);
-
+ up(&inode->i_sem);
+ }
res = generic_file_read(file, buf, count, ppos);
}
- up(&inode->i_sem);
return res;
}
-static ssize_t fuse_send_write(struct inode *inode, const char *buf,
- loff_t pos, size_t count)
+static ssize_t fuse_send_write(struct fuse_req *req, struct inode *inode,
+ const char *buf, loff_t pos, size_t count)
{
struct fuse_conn *fc = INO_FC(inode);
- struct fuse_req *req;
struct fuse_write_in inarg;
struct fuse_write_out outarg;
ssize_t res;
- req = fuse_get_request(fc);
- if (!req)
- return -ERESTARTSYS;
-
memset(&inarg, 0, sizeof(inarg));
inarg.offset = pos;
inarg.size = count;
request_send(fc, req);
res = req->out.h.error;
if (!res)
- res = outarg.size;
- fuse_put_request(fc, req);
- return res;
+ return outarg.size;
+ else
+ return res;
}
static int write_buffer(struct inode *inode, struct page *page,
unsigned offset, size_t count)
{
+ struct fuse_conn *fc = INO_FC(inode);
char *buffer;
ssize_t res;
loff_t pos;
+ struct fuse_req *req;
+ req = fuse_get_request(fc);
+ if (!req)
+ return -ERESTARTSYS;
+
pos = ((unsigned long long) page->index << PAGE_CACHE_SHIFT) + offset;
buffer = kmap(page);
- res = fuse_send_write(inode, buffer + offset, pos, count);
+ res = fuse_send_write(req, inode, buffer + offset, pos, count);
+ fuse_put_request(fc, req);
if (res >= 0) {
if (res < count) {
printk("fuse: short write\n");
return count;
}
+
+static int write_page_block(struct inode *inode, struct page *page)
+{
+ struct fuse_conn *fc = INO_FC(inode);
+ struct fuse_inode *fi = INO_FI(inode);
+ char *buffer;
+ ssize_t res;
+ loff_t pos;
+ unsigned count;
+ struct fuse_req *req;
+
+ req = fuse_get_request(fc);
+ if (!req)
+ return -ERESTARTSYS;
+
+ down_read(&fi->write_sem);
+ count = get_write_count(inode, page);
+ res = 0;
+ if (count) {
+ pos = ((unsigned long long) page->index << PAGE_CACHE_SHIFT);
+ buffer = kmap(page);
+ res = fuse_send_write(req, inode, buffer, pos, count);
+ if (res >= 0) {
+ if (res < count) {
+ printk("fuse: short write\n");
+ res = -EPROTO;
+ } else
+ res = 0;
+ }
+ }
+ up_read(&fi->write_sem);
+ fuse_put_request(fc, req);
+ kunmap(page);
+ if (res)
+ SetPageError(page);
+ return res;
+}
+
+
#ifdef KERNEL_2_6
-static void write_buffer_end(struct fuse_conn *fc, struct fuse_req *req)
+
+static void write_page_nonblock_end(struct fuse_conn *fc, struct fuse_req *req)
{
struct page *page = (struct page *) req->data;
+ struct inode *inode = page->mapping->host;
+ struct fuse_inode *fi = INO_FI(inode);
struct fuse_write_out *outarg = req->out.args[0].value;
if (!req->out.h.error && outarg->size != req->in.args[1].size) {
printk("fuse: short write\n");
else
set_bit(AS_EIO, &page->mapping->flags);
}
+ up_read(&fi->write_sem);
+
end_page_writeback(page);
kunmap(page);
fuse_put_request(fc, req);
}
-static int write_buffer_nonblock(struct inode *inode, struct page *page,
- unsigned offset, size_t count)
+static void send_write_nonblock(struct fuse_req *req, struct inode *inode,
+ struct page *page, unsigned count)
{
struct fuse_conn *fc = INO_FC(inode);
- struct fuse_req *req;
struct fuse_write_in *inarg;
char *buffer;
- req = fuse_get_request_nonblock(fc);
- if (!req)
- return -EWOULDBLOCK;
-
inarg = &req->misc.write.in;
buffer = kmap(page);
- inarg->offset = ((unsigned long long) page->index << PAGE_CACHE_SHIFT) + offset;
+ inarg->offset = ((unsigned long long) page->index << PAGE_CACHE_SHIFT);
inarg->size = count;
req->in.h.opcode = FUSE_WRITE;
req->in.h.ino = inode->i_ino;
req->in.args[0].size = sizeof(struct fuse_write_in);
req->in.args[0].value = inarg;
req->in.args[1].size = count;
- req->in.args[1].value = buffer + offset;
+ req->in.args[1].value = buffer;
req->out.numargs = 1;
req->out.args[0].size = sizeof(struct fuse_write_out);
req->out.args[0].value = &req->misc.write.out;
- request_send_nonblock(fc, req, write_buffer_end, page);
- return 0;
+ request_send_nonblock(fc, req, write_page_nonblock_end, page);
}
-static int fuse_writepage(struct page *page, struct writeback_control *wbc)
+static int write_page_nonblock(struct inode *inode, struct page *page)
{
+ struct fuse_conn *fc = INO_FC(inode);
+ struct fuse_inode *fi = INO_FI(inode);
+ struct fuse_req *req;
int err;
- struct inode *inode = page->mapping->host;
- unsigned count = get_write_count(inode, page);
- err = -EINVAL;
- if (count) {
- /* FIXME: check sync_mode, and wait for previous writes (or
- signal userspace to do this) */
- if (wbc->nonblocking) {
- SetPageWriteback(page);
- err = write_buffer_nonblock(inode, page, 0, count);
- if (err)
- ClearPageWriteback(page);
- if (err == -EWOULDBLOCK) {
- redirty_page_for_writepage(wbc, page);
- err = 0;
+ err = -EWOULDBLOCK;
+ req = fuse_get_request_nonblock(fc);
+ if (req) {
+ if (down_read_trylock(&fi->write_sem)) {
+ unsigned count;
+ err = 0;
+ count = get_write_count(inode, page);
+ if (count) {
+ SetPageWriteback(page);
+ send_write_nonblock(req, inode, page, count);
+ return 0;
}
- } else
- err = write_buffer(inode, page, 0, count);
+ up_read(&fi->write_sem);
+ }
+ fuse_put_request(fc, req);
}
+ return err;
+}
+
+static int fuse_writepage(struct page *page, struct writeback_control *wbc)
+{
+ int err;
+ struct inode *inode = page->mapping->host;
+
+ if (wbc->nonblocking) {
+ err = write_page_nonblock(inode, page);
+ if (err == -EWOULDBLOCK) {
+ redirty_page_for_writepage(wbc, page);
+ err = 0;
+ }
+ } else
+ err = write_page_block(inode, page);
unlock_page(page);
return err;
#else
static int fuse_writepage(struct page *page)
{
- int err;
- struct inode *inode = page->mapping->host;
- int count = get_write_count(inode, page);
- err = -EINVAL;
- if (count)
- err = write_buffer(inode, page, 0, count);
-
+ int err = write_page_block(page->mapping->host, page);
unlock_page(page);
return err;
}
loff_t pos = (page->index << PAGE_CACHE_SHIFT) + to;
if (pos > i_size_read(inode))
i_size_write(inode, pos);
+
+ if (offset == 0 && to == PAGE_CACHE_SIZE) {
+ clear_page_dirty(page);
+ SetPageUptodate(page);
+ }
+
}
return err;
}
char *tmpbuf;
ssize_t res = 0;
loff_t pos = *ppos;
+ struct fuse_req *req;
+
+ req = fuse_get_request(fc);
+ if (!req)
+ return -ERESTARTSYS;
tmpbuf = kmalloc(count < fc->max_write ? count : fc->max_write,
GFP_KERNEL);
- if (!tmpbuf)
+ if (!tmpbuf) {
+ fuse_put_request(fc, req);
return -ENOMEM;
+ }
while (count) {
size_t nbytes = count < fc->max_write ? count : fc->max_write;
res = -EFAULT;
break;
}
- res1 = fuse_send_write(inode, tmpbuf, pos, nbytes);
+ res1 = fuse_send_write(req, inode, tmpbuf, pos, nbytes);
if (res1 < 0) {
res = res1;
break;
pos += res1;
if (res1 < nbytes)
break;
+
+ if (count)
+ fuse_reset_request(req);
}
kfree(tmpbuf);
+ fuse_put_request(fc, req);
if (res > 0) {
if (pos > i_size_read(inode))
/** Bypass the page cache for read and write operations */
#define FUSE_DIRECT_IO (1 << 4)
+/** FUSE specific inode data */
+struct fuse_inode {
+ struct fuse_req *forget_req;
+ struct rw_semaphore write_sem;
+ unsigned long i_time;
+};
+
/** One input argument of a request */
struct fuse_in_arg {
unsigned int size;
#define SB_FC(sb) ((sb)->u.generic_sbp)
#endif
#define INO_FC(inode) SB_FC((inode)->i_sb)
-#define DEV_FC(file) ((struct fuse_conn *) (file)->private_data)
+#define DEV_FC(file) ((file)->private_data)
+#define INO_FI(inode) ((inode)->u.generic_ip)
/**
*/
void fuse_request_free(struct fuse_req *req);
+/**
+ * Reinitialize a request, the preallocated flag is left unmodified
+ */
+void fuse_reset_request(struct fuse_req *req);
+
/**
* Reserve a preallocated request
*/
*/
void fuse_sync_inode(struct inode *inode);
+/**
+ * Allocate fuse specific inode data
+ */
+struct fuse_inode *fuse_inode_alloc(void);
+
/*
* Local Variables:
* indent-tabs-mode: t
static int user_allow_other;
+static kmem_cache_t *fuse_inode_cachep;
#ifdef KERNEL_2_6
#include <linux/moduleparam.h>
unsigned int max_read;
};
+struct fuse_inode *fuse_inode_alloc(void)
+{
+ struct fuse_inode *fi;
+
+ fi = kmem_cache_alloc(fuse_inode_cachep, SLAB_KERNEL);
+ if (fi) {
+ memset(fi, 0, sizeof(*fi));
+ fi->forget_req = fuse_request_alloc();
+ if (!fi->forget_req) {
+ kmem_cache_free(fuse_inode_cachep, fi);
+ fi = NULL;
+ } else
+ init_rwsem(&fi->write_sem);
+ }
+
+ return fi;
+}
+
+static void fuse_inode_free(struct fuse_inode *fi)
+{
+ kmem_cache_free(fuse_inode_cachep, fi);
+}
+
static void fuse_read_inode(struct inode *inode)
{
/* No op */
static void fuse_clear_inode(struct inode *inode)
{
struct fuse_conn *fc = INO_FC(inode);
- struct fuse_req *req = inode->u.generic_ip;
+ struct fuse_inode *fi = INO_FI(inode);
- if (fc == NULL) {
- if (req)
- fuse_request_free(req);
- return;
+ if (fi) {
+ if (fc == NULL)
+ fuse_request_free(fi->forget_req);
+ else
+ fuse_send_forget(fc, fi->forget_req, inode->i_ino,
+ inode->i_version);
+ fuse_inode_free(fi);
}
- if (req != NULL)
- fuse_send_forget(fc, req, inode->i_ino, inode->i_version);
}
static void fuse_put_super(struct super_block *sb)
int fuse_fs_init()
{
- int res;
+ int err;
- res = register_filesystem(&fuse_fs_type);
- if (res)
+ err = register_filesystem(&fuse_fs_type);
+ if (err)
printk("fuse: failed to register filesystem\n");
+ else {
+ fuse_inode_cachep = kmem_cache_create("fuse_inode",
+ sizeof(struct fuse_inode),
+ 0, 0, NULL, NULL);
+ if (!fuse_inode_cachep) {
+ unregister_filesystem(&fuse_fs_type);
+ err = -ENOMEM;
+ }
+ }
- return res;
+ return err;
}
void fuse_fs_cleanup()
{
unregister_filesystem(&fuse_fs_type);
+ kmem_cache_destroy(fuse_inode_cachep);
}
/*
projects / qemu-gpiodev / libfuse.git / commitdiff