Merge ../linus

Conflicts:

	drivers/cpufreq/cpufreq.c

6 files changed, 300 insertions, 98 deletions

diff --git a/fs/fuse/control.c b/fs/fuse/control.c
index 16b39c053d..8c58bd4539 100644
--- a/fs/fuse/control.c
+++ b/fs/fuse/control.c
@@ -23,7 +23,7 @@ static struct fuse_conn *fuse_ctl_file_conn_get(struct file *file)
 {
         struct fuse_conn *fc;
         mutex_lock(&fuse_mutex);
-        fc = file->f_dentry->d_inode->i_private;
+        fc = file->f_path.dentry->d_inode->i_private;
         if (fc)
                 fc = fuse_conn_get(fc);
         mutex_unlock(&fuse_mutex);
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 66571eafbb..357764d85f 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -19,7 +19,7 @@
 
 MODULE_ALIAS_MISCDEV(FUSE_MINOR);
 
-static kmem_cache_t *fuse_req_cachep;
+static struct kmem_cache *fuse_req_cachep;
 
 static struct fuse_conn *fuse_get_conn(struct file *file)
 {
@@ -41,7 +41,7 @@ static void fuse_request_init(struct fuse_req *req)
 
 struct fuse_req *fuse_request_alloc(void)
 {
-        struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, SLAB_KERNEL);
+        struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, GFP_KERNEL);
         if (req)
                 fuse_request_init(req);
         return req;
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 8605155db1..40080477ce 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -138,9 +138,8 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
                 struct fuse_entry_out outarg;
                 struct fuse_conn *fc;
                 struct fuse_req *req;
-
-                /* Doesn't hurt to "reset" the validity timeout */
-                fuse_invalidate_entry_cache(entry);
+                struct fuse_req *forget_req;
+                struct dentry *parent;
 
                 /* For negative dentries, always do a fresh lookup */
                 if (!inode)
@@ -151,21 +150,33 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
                 if (IS_ERR(req))
                         return 0;
 
-                fuse_lookup_init(req, entry->d_parent->d_inode, entry, &outarg);
+                forget_req = fuse_get_req(fc);
+                if (IS_ERR(forget_req)) {
+                        fuse_put_request(fc, req);
+                        return 0;
+                }
+
+                parent = dget_parent(entry);
+                fuse_lookup_init(req, parent->d_inode, entry, &outarg);
                 request_send(fc, req);
+                dput(parent);
                 err = req->out.h.error;
+                fuse_put_request(fc, req);
                 /* Zero nodeid is same as -ENOENT */
                 if (!err && !outarg.nodeid)
                         err = -ENOENT;
                 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);
+                                fuse_send_forget(fc, forget_req,
+                                                 outarg.nodeid, 1);
                                 return 0;
                         }
+                        spin_lock(&fc->lock);
                         fi->nlookup ++;
+                        spin_unlock(&fc->lock);
                 }
-                fuse_put_request(fc, req);
+                fuse_put_request(fc, forget_req);
                 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
                         return 0;
 
@@ -175,22 +186,6 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
         return 1;
 }
 
-/*
- * Check if there's already a hashed alias of this directory inode.
- * If yes, then lookup and mkdir must not create a new alias.
- */
-static int dir_alias(struct inode *inode)
-{
-        if (S_ISDIR(inode->i_mode)) {
-                struct dentry *alias = d_find_alias(inode);
-                if (alias) {
-                        dput(alias);
-                        return 1;
-                }
-        }
-        return 0;
-}
-
 static int invalid_nodeid(u64 nodeid)
 {
         return !nodeid || nodeid == FUSE_ROOT_ID;
@@ -206,6 +201,24 @@ static int valid_mode(int m)
                 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
 }
 
+/*
+ * Add a directory inode to a dentry, ensuring that no other dentry
+ * refers to this inode.  Called with fc->inst_mutex.
+ */
+static int fuse_d_add_directory(struct dentry *entry, struct inode *inode)
+{
+        struct dentry *alias = d_find_alias(inode);
+        if (alias) {
+                /* This tries to shrink the subtree below alias */
+                fuse_invalidate_entry(alias);
+                dput(alias);
+                if (!list_empty(&inode->i_dentry))
+                        return -EBUSY;
+        }
+        d_add(entry, inode);
+        return 0;
+}
+
 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
                                   struct nameidata *nd)
 {
@@ -214,6 +227,7 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
         struct inode *inode = NULL;
         struct fuse_conn *fc = get_fuse_conn(dir);
         struct fuse_req *req;
+        struct fuse_req *forget_req;
 
         if (entry->d_name.len > FUSE_NAME_MAX)
                 return ERR_PTR(-ENAMETOOLONG);
@@ -222,9 +236,16 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
         if (IS_ERR(req))
                 return ERR_PTR(PTR_ERR(req));
 
+        forget_req = fuse_get_req(fc);
+        if (IS_ERR(forget_req)) {
+                fuse_put_request(fc, req);
+                return ERR_PTR(PTR_ERR(forget_req));
+        }
+
         fuse_lookup_init(req, dir, entry, &outarg);
         request_send(fc, req);
         err = req->out.h.error;
+        fuse_put_request(fc, req);
         /* Zero nodeid is same as -ENOENT, but with valid timeout */
         if (!err && outarg.nodeid &&
             (invalid_nodeid(outarg.nodeid) || !valid_mode(outarg.attr.mode)))
@@ -233,19 +254,25 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
                 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
                                   &outarg.attr);
                 if (!inode) {
-                        fuse_send_forget(fc, req, outarg.nodeid, 1);
+                        fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
                         return ERR_PTR(-ENOMEM);
                 }
         }
-        fuse_put_request(fc, req);
+        fuse_put_request(fc, forget_req);
         if (err && err != -ENOENT)
                 return ERR_PTR(err);
 
-        if (inode && dir_alias(inode)) {
-                iput(inode);
-                return ERR_PTR(-EIO);
-        }
-        d_add(entry, inode);
+        if (inode && S_ISDIR(inode->i_mode)) {
+                mutex_lock(&fc->inst_mutex);
+                err = fuse_d_add_directory(entry, inode);
+                mutex_unlock(&fc->inst_mutex);
+                if (err) {
+                        iput(inode);
+                        return ERR_PTR(err);
+                }
+        } else
+                d_add(entry, inode);
+
         entry->d_op = &fuse_dentry_operations;
         if (!err)
                 fuse_change_timeout(entry, &outarg);
@@ -375,6 +402,13 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
         struct fuse_entry_out outarg;
         struct inode *inode;
         int err;
+        struct fuse_req *forget_req;
+
+        forget_req = fuse_get_req(fc);
+        if (IS_ERR(forget_req)) {
+                fuse_put_request(fc, req);
+                return PTR_ERR(forget_req);
+        }
 
         req->in.h.nodeid = get_node_id(dir);
         req->out.numargs = 1;
@@ -382,37 +416,47 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
         req->out.args[0].value = &outarg;
         request_send(fc, req);
         err = req->out.h.error;
-        if (err) {
-                fuse_put_request(fc, req);
-                return err;
-        }
+        fuse_put_request(fc, req);
+        if (err)
+                goto out_put_forget_req;
+
         err = -EIO;
         if (invalid_nodeid(outarg.nodeid))
-                goto out_put_request;
+                goto out_put_forget_req;
 
         if ((outarg.attr.mode ^ mode) & S_IFMT)
-                goto out_put_request;
+                goto out_put_forget_req;
 
         inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
                           &outarg.attr);
         if (!inode) {
-                fuse_send_forget(fc, req, outarg.nodeid, 1);
+                fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
                 return -ENOMEM;
         }
-        fuse_put_request(fc, req);
+        fuse_put_request(fc, forget_req);
 
-        if (dir_alias(inode)) {
-                iput(inode);
-                return -EIO;
-        }
+        if (S_ISDIR(inode->i_mode)) {
+                struct dentry *alias;
+                mutex_lock(&fc->inst_mutex);
+                alias = d_find_alias(inode);
+                if (alias) {
+                        /* New directory must have moved since mkdir */
+                        mutex_unlock(&fc->inst_mutex);
+                        dput(alias);
+                        iput(inode);
+                        return -EBUSY;
+                }
+                d_instantiate(entry, inode);
+                mutex_unlock(&fc->inst_mutex);
+        } else
+                d_instantiate(entry, inode);
 
-        d_instantiate(entry, inode);
         fuse_change_timeout(entry, &outarg);
         fuse_invalidate_attr(dir);
         return 0;
 
- out_put_request:
-        fuse_put_request(fc, req);
+ out_put_forget_req:
+        fuse_put_request(fc, forget_req);
         return err;
 }
 
@@ -812,7 +856,7 @@ static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
         int err;
         size_t nbytes;
         struct page *page;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_req *req;
 
@@ -935,14 +979,30 @@ static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
         }
 }
 
+static void fuse_vmtruncate(struct inode *inode, loff_t offset)
+{
+        struct fuse_conn *fc = get_fuse_conn(inode);
+        int need_trunc;
+
+        spin_lock(&fc->lock);
+        need_trunc = inode->i_size > offset;
+        i_size_write(inode, offset);
+        spin_unlock(&fc->lock);
+
+        if (need_trunc) {
+                struct address_space *mapping = inode->i_mapping;
+                unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
+                truncate_inode_pages(mapping, offset);
+        }
+}
+
 /*
  * Set attributes, and at the same time refresh them.
  *
  * Truncation is slightly complicated, because the 'truncate' request
  * may fail, in which case we don't want to touch the mapping.
- * vmtruncate() doesn't allow for this case.  So do the rlimit
- * checking by hand and call vmtruncate() only after the file has
- * actually been truncated.
+ * vmtruncate() doesn't allow for this case, so do the rlimit checking
+ * and the actual truncation by hand.
  */
 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
 {
@@ -964,6 +1024,8 @@ static int fuse_setattr(struct dentry *entry, struct iattr *attr)
         if (attr->ia_valid & ATTR_SIZE) {
                 unsigned long limit;
                 is_truncate = 1;
+                if (IS_SWAPFILE(inode))
+                        return -ETXTBSY;
                 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
                 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
                         send_sig(SIGXFSZ, current, 0);
@@ -993,12 +1055,8 @@ static int fuse_setattr(struct dentry *entry, struct iattr *attr)
                         make_bad_inode(inode);
                         err = -EIO;
                 } else {
-                        if (is_truncate) {
-                                loff_t origsize = i_size_read(inode);
-                                i_size_write(inode, outarg.attr.size);
-                                if (origsize > outarg.attr.size)
-                                        vmtruncate(inode, outarg.attr.size);
-                        }
+                        if (is_truncate)
+                                fuse_vmtruncate(inode, outarg.attr.size);
                         fuse_change_attributes(inode, &outarg.attr);
                         fi->i_time = time_to_jiffies(outarg.attr_valid,
                                                      outarg.attr_valid_nsec);
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 183626868e..1387749201 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -141,8 +141,8 @@ int fuse_release_common(struct inode *inode, struct file *file, int isdir)
                                         isdir ? FUSE_RELEASEDIR : FUSE_RELEASE);
 
                 /* Hold vfsmount and dentry until release is finished */
-                req->vfsmount = mntget(file->f_vfsmnt);
-                req->dentry = dget(file->f_dentry);
+                req->vfsmount = mntget(file->f_path.mnt);
+                req->dentry = dget(file->f_path.dentry);
                 request_send_background(fc, req);
         }
 
@@ -184,7 +184,7 @@ static u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id)
 
 static int fuse_flush(struct file *file, fl_owner_t id)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_file *ff = file->private_data;
         struct fuse_req *req;
@@ -397,14 +397,14 @@ static int fuse_readpages(struct file *file, struct address_space *mapping,
 
         err = -EIO;
         if (is_bad_inode(inode))
-                goto clean_pages_up;
+                goto out;
 
         data.file = file;
         data.inode = inode;
         data.req = fuse_get_req(fc);
         err = PTR_ERR(data.req);
         if (IS_ERR(data.req))
-                goto clean_pages_up;
+                goto out;
 
         err = read_cache_pages(mapping, pages, fuse_readpages_fill, &data);
         if (!err) {
@@ -413,10 +413,7 @@ static int fuse_readpages(struct file *file, struct address_space *mapping,
                 else
                         fuse_put_request(fc, data.req);
         }
-        return err;
-
-clean_pages_up:
-        put_pages_list(pages);
+out:
         return err;
 }
 
@@ -481,8 +478,10 @@ static int fuse_commit_write(struct file *file, struct page *page,
                 err = -EIO;
         if (!err) {
                 pos += count;
-                if (pos > i_size_read(inode))
+                spin_lock(&fc->lock);
+                if (pos > inode->i_size)
                         i_size_write(inode, pos);
+                spin_unlock(&fc->lock);
 
                 if (offset == 0 && to == PAGE_CACHE_SIZE) {
                         clear_page_dirty(page);
@@ -534,7 +533,7 @@ static int fuse_get_user_pages(struct fuse_req *req, const char __user *buf,
 static ssize_t fuse_direct_io(struct file *file, const char __user *buf,
                               size_t count, loff_t *ppos, int write)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         size_t nmax = write ? fc->max_write : fc->max_read;
         loff_t pos = *ppos;
@@ -586,8 +585,12 @@ static ssize_t fuse_direct_io(struct file *file, const char __user *buf,
         }
         fuse_put_request(fc, req);
         if (res > 0) {
-                if (write && pos > i_size_read(inode))
-                        i_size_write(inode, pos);
+                if (write) {
+                        spin_lock(&fc->lock);
+                        if (pos > inode->i_size)
+                                i_size_write(inode, pos);
+                        spin_unlock(&fc->lock);
+                }
                 *ppos = pos;
         }
         fuse_invalidate_attr(inode);
@@ -604,7 +607,7 @@ static ssize_t fuse_direct_read(struct file *file, char __user *buf,
 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;
+        struct inode *inode = file->f_path.dentry->d_inode;
         ssize_t res;
         /* Don't allow parallel writes to the same file */
         mutex_lock(&inode->i_mutex);
@@ -659,7 +662,7 @@ static int convert_fuse_file_lock(const struct fuse_file_lock *ffl,
 static void fuse_lk_fill(struct fuse_req *req, struct file *file,
                          const struct file_lock *fl, int opcode, pid_t pid)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_file *ff = file->private_data;
         struct fuse_lk_in *arg = &req->misc.lk_in;
@@ -679,7 +682,7 @@ static void fuse_lk_fill(struct fuse_req *req, struct file *file,
 
 static int fuse_getlk(struct file *file, struct file_lock *fl)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_req *req;
         struct fuse_lk_out outarg;
@@ -704,7 +707,7 @@ static int fuse_getlk(struct file *file, struct file_lock *fl)
 
 static int fuse_setlk(struct file *file, struct file_lock *fl)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_req *req;
         int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK;
@@ -731,7 +734,7 @@ static int fuse_setlk(struct file *file, struct file_lock *fl)
 
 static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         int err;
 
@@ -751,6 +754,42 @@ static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl)
         return err;
 }
 
+static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
+{
+        struct inode *inode = mapping->host;
+        struct fuse_conn *fc = get_fuse_conn(inode);
+        struct fuse_req *req;
+        struct fuse_bmap_in inarg;
+        struct fuse_bmap_out outarg;
+        int err;
+
+        if (!inode->i_sb->s_bdev || fc->no_bmap)
+                return 0;
+
+        req = fuse_get_req(fc);
+        if (IS_ERR(req))
+                return 0;
+
+        memset(&inarg, 0, sizeof(inarg));
+        inarg.block = block;
+        inarg.blocksize = inode->i_sb->s_blocksize;
+        req->in.h.opcode = FUSE_BMAP;
+        req->in.h.nodeid = get_node_id(inode);
+        req->in.numargs = 1;
+        req->in.args[0].size = sizeof(inarg);
+        req->in.args[0].value = &inarg;
+        req->out.numargs = 1;
+        req->out.args[0].size = sizeof(outarg);
+        req->out.args[0].value = &outarg;
+        request_send(fc, req);
+        err = req->out.h.error;
+        fuse_put_request(fc, req);
+        if (err == -ENOSYS)
+                fc->no_bmap = 1;
+
+        return err ? 0 : outarg.block;
+}
+
 static const struct file_operations fuse_file_operations = {
         .llseek         = generic_file_llseek,
         .read           = do_sync_read,
@@ -784,6 +823,7 @@ static const struct address_space_operations fuse_file_aops  = {
         .commit_write   = fuse_commit_write,
         .readpages      = fuse_readpages,
         .set_page_dirty = fuse_set_page_dirty,
+        .bmap           = fuse_bmap,
 };
 
 void fuse_init_file_inode(struct inode *inode)
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 69c7750d55..b98b20de74 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -239,6 +239,9 @@ struct fuse_conn {
         /** Lock protecting accessess to  members of this structure */
         spinlock_t lock;
 
+        /** Mutex protecting against directory alias creation */
+        struct mutex inst_mutex;
+
         /** Refcount */
         atomic_t count;
 
@@ -295,6 +298,9 @@ struct fuse_conn {
             reply, before any other request, and never cleared */
         unsigned conn_error : 1;
 
+        /** Connection successful.  Only set in INIT */
+        unsigned conn_init : 1;
+
         /** Do readpages asynchronously?  Only set in INIT */
         unsigned async_read : 1;
 
@@ -336,6 +342,9 @@ struct fuse_conn {
         /** Is interrupt not implemented by fs? */
         unsigned no_interrupt : 1;
 
+        /** Is bmap not implemented by fs? */
+        unsigned no_bmap : 1;
+
         /** The number of requests waiting for completion */
         atomic_t num_waiting;
 
@@ -362,6 +371,9 @@ struct fuse_conn {
 
         /** Key for lock owner ID scrambling */
         u32 scramble_key[4];
+
+        /** Reserved request for the DESTROY message */
+        struct fuse_req *destroy_req;
 };
 
 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 7d0a9aee01..12450d2b32 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -22,7 +22,7 @@ MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
 MODULE_DESCRIPTION("Filesystem in Userspace");
 MODULE_LICENSE("GPL");
 
-static kmem_cache_t *fuse_inode_cachep;
+static struct kmem_cache *fuse_inode_cachep;
 struct list_head fuse_conn_list;
 DEFINE_MUTEX(fuse_mutex);
 
@@ -39,6 +39,7 @@ struct fuse_mount_data {
         unsigned group_id_present : 1;
         unsigned flags;
         unsigned max_read;
+        unsigned blksize;
 };
 
 static struct inode *fuse_alloc_inode(struct super_block *sb)
@@ -46,7 +47,7 @@ static struct inode *fuse_alloc_inode(struct super_block *sb)
         struct inode *inode;
         struct fuse_inode *fi;
 
-        inode = kmem_cache_alloc(fuse_inode_cachep, SLAB_KERNEL);
+        inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
         if (!inode)
                 return NULL;
 
@@ -109,6 +110,7 @@ static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
 
 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
 {
+        struct fuse_conn *fc = get_fuse_conn(inode);
         if (S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size)
                 invalidate_inode_pages(inode->i_mapping);
 
@@ -117,7 +119,9 @@ void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
         inode->i_nlink   = attr->nlink;
         inode->i_uid     = attr->uid;
         inode->i_gid     = attr->gid;
+        spin_lock(&fc->lock);
         i_size_write(inode, attr->size);
+        spin_unlock(&fc->lock);
         inode->i_blocks  = attr->blocks;
         inode->i_atime.tv_sec   = attr->atime;
         inode->i_atime.tv_nsec  = attr->atimensec;
@@ -130,7 +134,7 @@ void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
 static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
 {
         inode->i_mode = attr->mode & S_IFMT;
-        i_size_write(inode, attr->size);
+        inode->i_size = attr->size;
         if (S_ISREG(inode->i_mode)) {
                 fuse_init_common(inode);
                 fuse_init_file_inode(inode);
@@ -169,7 +173,6 @@ struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,
         struct inode *inode;
         struct fuse_inode *fi;
         struct fuse_conn *fc = get_fuse_conn_super(sb);
-        int retried = 0;
 
  retry:
         inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);
@@ -183,16 +186,16 @@ struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,
                 fuse_init_inode(inode, attr);
                 unlock_new_inode(inode);
         } else if ((inode->i_mode ^ attr->mode) & S_IFMT) {
-                BUG_ON(retried);
                 /* Inode has changed type, any I/O on the old should fail */
                 make_bad_inode(inode);
                 iput(inode);
-                retried = 1;
                 goto retry;
         }
 
         fi = get_fuse_inode(inode);
+        spin_lock(&fc->lock);
         fi->nlookup ++;
+        spin_unlock(&fc->lock);
         fuse_change_attributes(inode, attr);
         return inode;
 }
@@ -203,10 +206,23 @@ static void fuse_umount_begin(struct vfsmount *vfsmnt, int flags)
                 fuse_abort_conn(get_fuse_conn_super(vfsmnt->mnt_sb));
 }
 
+static void fuse_send_destroy(struct fuse_conn *fc)
+{
+        struct fuse_req *req = fc->destroy_req;
+        if (req && fc->conn_init) {
+                fc->destroy_req = NULL;
+                req->in.h.opcode = FUSE_DESTROY;
+                req->force = 1;
+                request_send(fc, req);
+                fuse_put_request(fc, req);
+        }
+}
+
 static void fuse_put_super(struct super_block *sb)
 {
         struct fuse_conn *fc = get_fuse_conn_super(sb);
 
+        fuse_send_destroy(fc);
         spin_lock(&fc->lock);
         fc->connected = 0;
         fc->blocked = 0;
@@ -272,6 +288,7 @@ enum {
         OPT_DEFAULT_PERMISSIONS,
         OPT_ALLOW_OTHER,
         OPT_MAX_READ,
+        OPT_BLKSIZE,
         OPT_ERR
 };
 
@@ -283,14 +300,16 @@ static match_table_t tokens = {
         {OPT_DEFAULT_PERMISSIONS,       "default_permissions"},
         {OPT_ALLOW_OTHER,               "allow_other"},
         {OPT_MAX_READ,                  "max_read=%u"},
+        {OPT_BLKSIZE,                   "blksize=%u"},
         {OPT_ERR,                       NULL}
 };
 
-static int parse_fuse_opt(char *opt, struct fuse_mount_data *d)
+static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
 {
         char *p;
         memset(d, 0, sizeof(struct fuse_mount_data));
         d->max_read = ~0;
+        d->blksize = 512;
 
         while ((p = strsep(&opt, ",")) != NULL) {
                 int token;
@@ -343,6 +362,12 @@ static int parse_fuse_opt(char *opt, struct fuse_mount_data *d)
                         d->max_read = value;
                         break;
 
+                case OPT_BLKSIZE:
+                        if (!is_bdev || match_int(&args[0], &value))
+                                return 0;
+                        d->blksize = value;
+                        break;
+
                 default:
                         return 0;
                 }
@@ -377,6 +402,7 @@ static struct fuse_conn *new_conn(void)
         fc = kzalloc(sizeof(*fc), GFP_KERNEL);
         if (fc) {
                 spin_lock_init(&fc->lock);
+                mutex_init(&fc->inst_mutex);
                 atomic_set(&fc->count, 1);
                 init_waitqueue_head(&fc->waitq);
                 init_waitqueue_head(&fc->blocked_waitq);
@@ -396,8 +422,12 @@ static struct fuse_conn *new_conn(void)
 
 void fuse_conn_put(struct fuse_conn *fc)
 {
-        if (atomic_dec_and_test(&fc->count))
+        if (atomic_dec_and_test(&fc->count)) {
+                if (fc->destroy_req)
+                        fuse_request_free(fc->destroy_req);
+                mutex_destroy(&fc->inst_mutex);
                 kfree(fc);
+        }
 }
 
 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
@@ -451,6 +481,7 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
                 fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
                 fc->minor = arg->minor;
                 fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
+                fc->conn_init = 1;
         }
         fuse_put_request(fc, req);
         fc->blocked = 0;
@@ -495,15 +526,23 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
         struct dentry *root_dentry;
         struct fuse_req *init_req;
         int err;
+        int is_bdev = sb->s_bdev != NULL;
 
         if (sb->s_flags & MS_MANDLOCK)
                 return -EINVAL;
 
-        if (!parse_fuse_opt((char *) data, &d))
+        if (!parse_fuse_opt((char *) data, &d, is_bdev))
                 return -EINVAL;
 
-        sb->s_blocksize = PAGE_CACHE_SIZE;
-        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        if (is_bdev) {
+#ifdef CONFIG_BLOCK
+                if (!sb_set_blocksize(sb, d.blksize))
+                        return -EINVAL;
+#endif
+        } else {
+                sb->s_blocksize = PAGE_CACHE_SIZE;
+                sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        }
         sb->s_magic = FUSE_SUPER_MAGIC;
         sb->s_op = &fuse_super_operations;
         sb->s_maxbytes = MAX_LFS_FILESIZE;
@@ -542,6 +581,12 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
         if (!init_req)
                 goto err_put_root;
 
+        if (is_bdev) {
+                fc->destroy_req = fuse_request_alloc();
+                if (!fc->destroy_req)
+                        goto err_put_root;
+        }
+
         mutex_lock(&fuse_mutex);
         err = -EINVAL;
         if (file->private_data)
@@ -593,10 +638,47 @@ static struct file_system_type fuse_fs_type = {
         .kill_sb        = kill_anon_super,
 };
 
+#ifdef CONFIG_BLOCK
+static int fuse_get_sb_blk(struct file_system_type *fs_type,
+                           int flags, const char *dev_name,
+                           void *raw_data, struct vfsmount *mnt)
+{
+        return get_sb_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super,
+                           mnt);
+}
+
+static struct file_system_type fuseblk_fs_type = {
+        .owner          = THIS_MODULE,
+        .name           = "fuseblk",
+        .get_sb         = fuse_get_sb_blk,
+        .kill_sb        = kill_block_super,
+        .fs_flags       = FS_REQUIRES_DEV,
+};
+
+static inline int register_fuseblk(void)
+{
+        return register_filesystem(&fuseblk_fs_type);
+}
+
+static inline void unregister_fuseblk(void)
+{
+        unregister_filesystem(&fuseblk_fs_type);
+}
+#else
+static inline int register_fuseblk(void)
+{
+        return 0;
+}
+
+static inline void unregister_fuseblk(void)
+{
+}
+#endif
+
 static decl_subsys(fuse, NULL, NULL);
 static decl_subsys(connections, NULL, NULL);
 
-static void fuse_inode_init_once(void *foo, kmem_cache_t *cachep,
+static void fuse_inode_init_once(void *foo, struct kmem_cache *cachep,
                                  unsigned long flags)
 {
         struct inode * inode = foo;
@@ -612,24 +694,34 @@ static int __init fuse_fs_init(void)
 
         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, SLAB_HWCACHE_ALIGN,
-                                                      fuse_inode_init_once, NULL);
-                if (!fuse_inode_cachep) {
-                        unregister_filesystem(&fuse_fs_type);
-                        err = -ENOMEM;
-                }
-        }
+                goto out;
+
+        err = register_fuseblk();
+        if (err)
+                goto out_unreg;
 
+        fuse_inode_cachep = kmem_cache_create("fuse_inode",
+                                              sizeof(struct fuse_inode),
+                                              0, SLAB_HWCACHE_ALIGN,
+                                              fuse_inode_init_once, NULL);
+        err = -ENOMEM;
+        if (!fuse_inode_cachep)
+                goto out_unreg2;
+
+        return 0;
+
+ out_unreg2:
+        unregister_fuseblk();
+ out_unreg:
+        unregister_filesystem(&fuse_fs_type);
+ out:
         return err;
 }
 
 static void fuse_fs_cleanup(void)
 {
         unregister_filesystem(&fuse_fs_type);
+        unregister_fuseblk();
         kmem_cache_destroy(fuse_inode_cachep);
 }