Merge branch 'linux-2.6' into for-2.6.24

33 files changed, 280 insertions, 157 deletions

diff --git a/fs/Kconfig b/fs/Kconfig
index 58a0650293e1..f9eed6d79066 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -441,9 +441,6 @@ config OCFS2_FS
 
           Note: Features which OCFS2 does not support yet:
                   - extended attributes
-                  - shared writeable mmap
-                  - loopback is supported, but data written will not
-                    be cluster coherent.
                   - quotas
                   - cluster aware flock
                   - Directory change notification (F_NOTIFY)
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index a3684dcc76e7..6f8c96fb29eb 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -235,8 +235,8 @@ static void *afs_mntpt_follow_link(struct dentry *dentry, struct nameidata *nd)
         err = do_add_mount(newmnt, nd, MNT_SHRINKABLE, &afs_vfsmounts);
         switch (err) {
         case 0:
-                mntput(nd->mnt);
                 dput(nd->dentry);
+                mntput(nd->mnt);
                 nd->mnt = newmnt;
                 nd->dentry = dget(newmnt->mnt_root);
                 schedule_delayed_work(&afs_mntpt_expiry_timer,
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 5d40ad13ab5c..131954b3fb98 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -357,10 +357,6 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
                 ecryptfs_printk(KERN_DEBUG, "Is a special file; returning\n");
                 goto out;
         }
-        if (special_file(lower_inode->i_mode)) {
-                ecryptfs_printk(KERN_DEBUG, "Is a special file; returning\n");
-                goto out;
-        }
         if (!nd) {
                 ecryptfs_printk(KERN_DEBUG, "We have a NULL nd, just leave"
                                 "as we *think* we are about to unlink\n");
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index e4ab7bc14efe..fd3f94d4a668 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -834,7 +834,8 @@ static void ecryptfs_sync_page(struct page *page)
                 ecryptfs_printk(KERN_DEBUG, "find_lock_page failed\n");
                 return;
         }
-        lower_page->mapping->a_ops->sync_page(lower_page);
+        if (lower_page->mapping->a_ops->sync_page)
+                lower_page->mapping->a_ops->sync_page(lower_page);
         ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16x]\n",
                         lower_page->index);
         unlock_page(lower_page);
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 22cfdd61c060..9537316a0714 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -2578,8 +2578,11 @@ static int ext3_release_dquot(struct dquot *dquot)
 
         handle = ext3_journal_start(dquot_to_inode(dquot),
                                         EXT3_QUOTA_DEL_BLOCKS(dquot->dq_sb));
-        if (IS_ERR(handle))
+        if (IS_ERR(handle)) {
+                /* Release dquot anyway to avoid endless cycle in dqput() */
+                dquot_release(dquot);
                 return PTR_ERR(handle);
+        }
         ret = dquot_release(dquot);
         err = ext3_journal_stop(handle);
         if (!ret)
@@ -2712,6 +2715,12 @@ static ssize_t ext3_quota_write(struct super_block *sb, int type,
         struct buffer_head *bh;
         handle_t *handle = journal_current_handle();
 
+        if (!handle) {
+                printk(KERN_WARNING "EXT3-fs: Quota write (off=%Lu, len=%Lu)"
+                        " cancelled because transaction is not started.\n",
+                        (unsigned long long)off, (unsigned long long)len);
+                return -EIO;
+        }
         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
         while (towrite > 0) {
                 tocopy = sb->s_blocksize - offset < towrite ?
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 4550b83ab1c9..3c1397fa83df 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -2698,8 +2698,11 @@ static int ext4_release_dquot(struct dquot *dquot)
 
         handle = ext4_journal_start(dquot_to_inode(dquot),
                                         EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
-        if (IS_ERR(handle))
+        if (IS_ERR(handle)) {
+                /* Release dquot anyway to avoid endless cycle in dqput() */
+                dquot_release(dquot);
                 return PTR_ERR(handle);
+        }
         ret = dquot_release(dquot);
         err = ext4_journal_stop(handle);
         if (!ret)
@@ -2832,6 +2835,12 @@ static ssize_t ext4_quota_write(struct super_block *sb, int type,
         struct buffer_head *bh;
         handle_t *handle = journal_current_handle();
 
+        if (!handle) {
+                printk(KERN_WARNING "EXT4-fs: Quota write (off=%Lu, len=%Lu)"
+                        " cancelled because transaction is not started.\n",
+                        (unsigned long long)off, (unsigned long long)len);
+                return -EIO;
+        }
         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
         while (towrite > 0) {
                 tocopy = sb->s_blocksize - offset < towrite ?
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index c848a191525d..950c2fbb815b 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -82,14 +82,19 @@ static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
         int ret;
 
         /*
-         * vma alignment has already been checked by prepare_hugepage_range.
-         * If you add any error returns here, do so after setting VM_HUGETLB,
-         * so is_vm_hugetlb_page tests below unmap_region go the right way
-         * when do_mmap_pgoff unwinds (may be important on powerpc and ia64).
+         * vma address alignment (but not the pgoff alignment) has
+         * already been checked by prepare_hugepage_range.  If you add
+         * any error returns here, do so after setting VM_HUGETLB, so
+         * is_vm_hugetlb_page tests below unmap_region go the right
+         * way when do_mmap_pgoff unwinds (may be important on powerpc
+         * and ia64).
          */
         vma->vm_flags |= VM_HUGETLB | VM_RESERVED;
         vma->vm_ops = &hugetlb_vm_ops;
 
+        if (vma->vm_pgoff & ~(HPAGE_MASK >> PAGE_SHIFT))
+                return -EINVAL;
+
         vma_len = (loff_t)(vma->vm_end - vma->vm_start);
 
         mutex_lock(&inode->i_mutex);
@@ -132,7 +137,7 @@ hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
                 return -ENOMEM;
 
         if (flags & MAP_FIXED) {
-                if (prepare_hugepage_range(addr, len, pgoff))
+                if (prepare_hugepage_range(addr, len))
                         return -EINVAL;
                 return addr;
         }
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 1d3b7a9fc828..8bc727b71696 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -627,7 +627,7 @@ unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
         struct inode *inode = OFNI_EDONI_2SFFJ(f);
         struct page *pg;
 
-        pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
+        pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
                              (void *)jffs2_do_readpage_unlock, inode);
         if (IS_ERR(pg))
                 return (void *)pg;
diff --git a/fs/locks.c b/fs/locks.c
index 50857d2d3404..c795eaaf6c4c 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -782,7 +782,7 @@ find_conflict:
         if (request->fl_flags & FL_ACCESS)
                 goto out;
         locks_copy_lock(new_fl, request);
-        locks_insert_lock(&inode->i_flock, new_fl);
+        locks_insert_lock(before, new_fl);
         new_fl = NULL;
         error = 0;
 
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index c87dc713b5d7..579cf8a7d4a7 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -316,7 +316,7 @@ static void nfs_invalidate_page(struct page *page, unsigned long offset)
         if (offset != 0)
                 return;
         /* Cancel any unstarted writes on this page */
-        nfs_wb_page_priority(page->mapping->host, page, FLUSH_INVALIDATE);
+        nfs_wb_page_cancel(page->mapping->host, page);
 }
 
 static int nfs_release_page(struct page *page, gfp_t gfp)
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index aea76d0e5fbd..acfc56f9edc0 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -176,7 +176,7 @@ static void nfs_expire_automounts(struct work_struct *work)
 void nfs_release_automount_timer(void)
 {
         if (list_empty(&nfs_automount_list))
-                cancel_delayed_work_sync(&nfs_automount_task);
+                cancel_delayed_work(&nfs_automount_task);
 }
 
 /*
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 62b3ae280310..4b90e17555a9 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -646,7 +646,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state
         rcu_read_lock();
         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
         if (delegation != NULL && (delegation->flags & NFS_DELEGATION_NEED_RECLAIM) != 0)
-                delegation_type = delegation->flags;
+                delegation_type = delegation->type;
         rcu_read_unlock();
         opendata->o_arg.u.delegation_type = delegation_type;
         status = nfs4_open_recover(opendata, state);
@@ -1434,7 +1434,7 @@ nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         }
         res = d_add_unique(dentry, igrab(state->inode));
         if (res != NULL)
-                dentry = res;
+                path.dentry = res;
         nfs4_intent_set_file(nd, &path, state);
         return res;
 }
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index b2a851c1b8cb..8ed593766f16 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -911,13 +911,13 @@ static int nfs_parse_mount_options(char *raw,
                         kfree(string);
 
                         switch (token) {
-                        case Opt_udp:
+                        case Opt_xprt_udp:
                                 mnt->flags &= ~NFS_MOUNT_TCP;
                                 mnt->nfs_server.protocol = IPPROTO_UDP;
                                 mnt->timeo = 7;
                                 mnt->retrans = 5;
                                 break;
-                        case Opt_tcp:
+                        case Opt_xprt_tcp:
                                 mnt->flags |= NFS_MOUNT_TCP;
                                 mnt->nfs_server.protocol = IPPROTO_TCP;
                                 mnt->timeo = 600;
@@ -936,10 +936,10 @@ static int nfs_parse_mount_options(char *raw,
                         kfree(string);
 
                         switch (token) {
-                        case Opt_udp:
+                        case Opt_xprt_udp:
                                 mnt->mount_server.protocol = IPPROTO_UDP;
                                 break;
-                        case Opt_tcp:
+                        case Opt_xprt_tcp:
                                 mnt->mount_server.protocol = IPPROTO_TCP;
                                 break;
                         default:
@@ -1153,20 +1153,20 @@ static int nfs_validate_mount_data(struct nfs_mount_data **options,
                 c = strchr(dev_name, ':');
                 if (c == NULL)
                         return -EINVAL;
-                len = c - dev_name - 1;
+                len = c - dev_name;
                 if (len > sizeof(data->hostname))
-                        return -EINVAL;
+                        return -ENAMETOOLONG;
                 strncpy(data->hostname, dev_name, len);
                 args.nfs_server.hostname = data->hostname;
 
                 c++;
                 if (strlen(c) > NFS_MAXPATHLEN)
-                        return -EINVAL;
+                        return -ENAMETOOLONG;
                 args.nfs_server.export_path = c;
 
                 status = nfs_try_mount(&args, mntfh);
                 if (status)
-                        return -EINVAL;
+                        return status;
 
                 /*
                  * Translate to nfs_mount_data, which nfs_fill_super
@@ -1303,34 +1303,6 @@ static void nfs_clone_super(struct super_block *sb,
         nfs_initialise_sb(sb);
 }
 
-static int nfs_set_super(struct super_block *s, void *_server)
-{
-        struct nfs_server *server = _server;
-        int ret;
-
-        s->s_fs_info = server;
-        ret = set_anon_super(s, server);
-        if (ret == 0)
-                server->s_dev = s->s_dev;
-        return ret;
-}
-
-static int nfs_compare_super(struct super_block *sb, void *data)
-{
-        struct nfs_server *server = data, *old = NFS_SB(sb);
-
-        if (memcmp(&old->nfs_client->cl_addr,
-                                &server->nfs_client->cl_addr,
-                                sizeof(old->nfs_client->cl_addr)) != 0)
-                return 0;
-        /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
-        if (old->flags & NFS_MOUNT_UNSHARED)
-                return 0;
-        if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
-                return 0;
-        return 1;
-}
-
 #define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
 
 static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
@@ -1359,9 +1331,46 @@ static int nfs_compare_mount_options(const struct super_block *s, const struct n
                 goto Ebusy;
         if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
                 goto Ebusy;
-        return 0;
+        return 1;
 Ebusy:
-        return -EBUSY;
+        return 0;
+}
+
+struct nfs_sb_mountdata {
+        struct nfs_server *server;
+        int mntflags;
+};
+
+static int nfs_set_super(struct super_block *s, void *data)
+{
+        struct nfs_sb_mountdata *sb_mntdata = data;
+        struct nfs_server *server = sb_mntdata->server;
+        int ret;
+
+        s->s_flags = sb_mntdata->mntflags;
+        s->s_fs_info = server;
+        ret = set_anon_super(s, server);
+        if (ret == 0)
+                server->s_dev = s->s_dev;
+        return ret;
+}
+
+static int nfs_compare_super(struct super_block *sb, void *data)
+{
+        struct nfs_sb_mountdata *sb_mntdata = data;
+        struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
+        int mntflags = sb_mntdata->mntflags;
+
+        if (memcmp(&old->nfs_client->cl_addr,
+                                &server->nfs_client->cl_addr,
+                                sizeof(old->nfs_client->cl_addr)) != 0)
+                return 0;
+        /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
+        if (old->flags & NFS_MOUNT_UNSHARED)
+                return 0;
+        if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
+                return 0;
+        return nfs_compare_mount_options(sb, server, mntflags);
 }
 
 static int nfs_get_sb(struct file_system_type *fs_type,
@@ -1373,6 +1382,9 @@ static int nfs_get_sb(struct file_system_type *fs_type,
         struct nfs_mount_data *data = raw_data;
         struct dentry *mntroot;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         /* Validate the mount data */
@@ -1386,28 +1398,25 @@ static int nfs_get_sb(struct file_system_type *fs_type,
                 error = PTR_ERR(server);
                 goto out;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(fs_type, compare_super, nfs_set_super, server);
+        s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
         }
 
         if (s->s_fs_info != server) {
-                error = nfs_compare_mount_options(s, server, flags);
                 nfs_free_server(server);
                 server = NULL;
-                if (error < 0)
-                        goto error_splat_super;
         }
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs_fill_super(s, data);
         }
 
@@ -1460,6 +1469,9 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
         struct nfs_server *server;
         struct dentry *mntroot;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         dprintk("--> nfs_xdev_get_sb()\n");
@@ -1470,28 +1482,25 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
                 error = PTR_ERR(server);
                 goto out_err_noserver;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
         }
 
         if (s->s_fs_info != server) {
-                error = nfs_compare_mount_options(s, server, flags);
                 nfs_free_server(server);
                 server = NULL;
-                if (error < 0)
-                        goto error_splat_super;
         }
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs_clone_super(s, data->sb);
         }
 
@@ -1668,7 +1677,7 @@ static int nfs4_validate_mount_data(struct nfs4_mount_data **options,
                 /* while calculating len, pretend ':' is '\0' */
                 len = c - dev_name;
                 if (len > NFS4_MAXNAMLEN)
-                        return -EINVAL;
+                        return -ENAMETOOLONG;
                 *hostname = kzalloc(len, GFP_KERNEL);
                 if (*hostname == NULL)
                         return -ENOMEM;
@@ -1677,7 +1686,7 @@ static int nfs4_validate_mount_data(struct nfs4_mount_data **options,
                 c++;                    /* step over the ':' */
                 len = strlen(c);
                 if (len > NFS4_MAXPATHLEN)
-                        return -EINVAL;
+                        return -ENAMETOOLONG;
                 *mntpath = kzalloc(len + 1, GFP_KERNEL);
                 if (*mntpath == NULL)
                         return -ENOMEM;
@@ -1729,6 +1738,9 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
         struct dentry *mntroot;
         char *mntpath = NULL, *hostname = NULL, *ip_addr = NULL;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         /* Validate the mount data */
@@ -1744,12 +1756,13 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
                 error = PTR_ERR(server);
                 goto out;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS4_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(fs_type, compare_super, nfs_set_super, server);
+        s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_free;
@@ -1762,7 +1775,6 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs4_fill_super(s);
         }
 
@@ -1816,6 +1828,9 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
         struct nfs_server *server;
         struct dentry *mntroot;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         dprintk("--> nfs4_xdev_get_sb()\n");
@@ -1826,12 +1841,13 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
                 error = PTR_ERR(server);
                 goto out_err_noserver;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS4_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
@@ -1844,7 +1860,6 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs4_clone_super(s, data->sb);
         }
 
@@ -1887,6 +1902,9 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
         struct dentry *mntroot;
         struct nfs_fh mntfh;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
+        struct nfs_sb_mountdata sb_mntdata = {
+                .mntflags = flags,
+        };
         int error;
 
         dprintk("--> nfs4_referral_get_sb()\n");
@@ -1897,12 +1915,13 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
                 error = PTR_ERR(server);
                 goto out_err_noserver;
         }
+        sb_mntdata.server = server;
 
         if (server->flags & NFS4_MOUNT_UNSHARED)
                 compare_super = NULL;
 
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
@@ -1915,7 +1934,6 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                s->s_flags = flags;
                 nfs4_fill_super(s);
         }
 
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index ef97e0c0f5b1..0d7a77cc394b 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1396,6 +1396,50 @@ out:
         return ret;
 }
 
+int nfs_wb_page_cancel(struct inode *inode, struct page *page)
+{
+        struct nfs_page *req;
+        loff_t range_start = page_offset(page);
+        loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
+        struct writeback_control wbc = {
+                .bdi = page->mapping->backing_dev_info,
+                .sync_mode = WB_SYNC_ALL,
+                .nr_to_write = LONG_MAX,
+                .range_start = range_start,
+                .range_end = range_end,
+        };
+        int ret = 0;
+
+        BUG_ON(!PageLocked(page));
+        for (;;) {
+                req = nfs_page_find_request(page);
+                if (req == NULL)
+                        goto out;
+                if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) {
+                        nfs_release_request(req);
+                        break;
+                }
+                if (nfs_lock_request_dontget(req)) {
+                        nfs_inode_remove_request(req);
+                        /*
+                         * In case nfs_inode_remove_request has marked the
+                         * page as being dirty
+                         */
+                        cancel_dirty_page(page, PAGE_CACHE_SIZE);
+                        nfs_unlock_request(req);
+                        break;
+                }
+                ret = nfs_wait_on_request(req);
+                if (ret < 0)
+                        goto out;
+        }
+        if (!PagePrivate(page))
+                return 0;
+        ret = nfs_sync_mapping_wait(page->mapping, &wbc, FLUSH_INVALIDATE);
+out:
+        return ret;
+}
+
 int nfs_wb_page_priority(struct inode *inode, struct page *page, int how)
 {
         loff_t range_start = page_offset(page);
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 0eb464a39aae..7011d62acfc8 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -566,13 +566,23 @@ enum fsid_source fsid_source(struct svc_fh *fhp)
         case FSID_DEV:
         case FSID_ENCODE_DEV:
         case FSID_MAJOR_MINOR:
-                return FSIDSOURCE_DEV;
+                if (fhp->fh_export->ex_dentry->d_inode->i_sb->s_type->fs_flags
+                    & FS_REQUIRES_DEV)
+                        return FSIDSOURCE_DEV;
+                break;
         case FSID_NUM:
-                return FSIDSOURCE_FSID;
-        default:
                 if (fhp->fh_export->ex_flags & NFSEXP_FSID)
                         return FSIDSOURCE_FSID;
-                else
-                        return FSIDSOURCE_UUID;
+                break;
+        default:
+                break;
         }
+        /* either a UUID type filehandle, or the filehandle doesn't
+         * match the export.
+         */
+        if (fhp->fh_export->ex_flags & NFSEXP_FSID)
+                return FSIDSOURCE_FSID;
+        if (fhp->fh_export->ex_uuid)
+                return FSIDSOURCE_UUID;
+        return FSIDSOURCE_DEV;
 }
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index a0c2b253818b..7867151ebb83 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -115,7 +115,8 @@ nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp,
 
         exp2 = rqst_exp_get_by_name(rqstp, mnt, mounts);
         if (IS_ERR(exp2)) {
-                err = PTR_ERR(exp2);
+                if (PTR_ERR(exp2) != -ENOENT)
+                        err = PTR_ERR(exp2);
                 dput(mounts);
                 mntput(mnt);
                 goto out;
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index 4f517665c9a0..778a850b4634 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -5602,6 +5602,7 @@ static int ocfs2_do_truncate(struct ocfs2_super *osb,
                                       clusters_to_del;
         spin_unlock(&OCFS2_I(inode)->ip_lock);
         le32_add_cpu(&fe->i_clusters, -clusters_to_del);
+        inode->i_blocks = ocfs2_inode_sector_count(inode);
 
         status = ocfs2_trim_tree(inode, path, handle, tc,
                                  clusters_to_del, &delete_blk);
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 460d440310f2..50cd8a209012 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -855,6 +855,7 @@ static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp,
                                   struct ocfs2_super *osb, loff_t pos,
                                   unsigned len, struct buffer_head *di_bh)
 {
+        u32 cend;
         struct ocfs2_write_ctxt *wc;
 
         wc = kzalloc(sizeof(struct ocfs2_write_ctxt), GFP_NOFS);
@@ -862,7 +863,8 @@ static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp,
                 return -ENOMEM;
 
         wc->w_cpos = pos >> osb->s_clustersize_bits;
-        wc->w_clen = ocfs2_clusters_for_bytes(osb->sb, len);
+        cend = (pos + len - 1) >> osb->s_clustersize_bits;
+        wc->w_clen = cend - wc->w_cpos + 1;
         get_bh(di_bh);
         wc->w_di_bh = di_bh;
 
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 4ffa715be09c..7e34e66159c6 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -314,7 +314,6 @@ static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
         }
 
         i_size_write(inode, new_i_size);
-        inode->i_blocks = ocfs2_align_bytes_to_sectors(new_i_size);
         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
 
         di = (struct ocfs2_dinode *) fe_bh->b_data;
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index f2fc9a795deb..c034b5129c1e 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -81,8 +81,15 @@ static struct dentry *ocfs2_debugfs_root = NULL;
 MODULE_AUTHOR("Oracle");
 MODULE_LICENSE("GPL");
 
+struct mount_options
+{
+        unsigned long   mount_opt;
+        unsigned int    atime_quantum;
+        signed short    slot;
+};
+
 static int ocfs2_parse_options(struct super_block *sb, char *options,
-                               unsigned long *mount_opt, s16 *slot,
+                               struct mount_options *mopt,
                                int is_remount);
 static void ocfs2_put_super(struct super_block *sb);
 static int ocfs2_mount_volume(struct super_block *sb);
@@ -367,24 +374,23 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
 {
         int incompat_features;
         int ret = 0;
-        unsigned long parsed_options;
-        s16 slot;
+        struct mount_options parsed_options;
         struct ocfs2_super *osb = OCFS2_SB(sb);
 
-        if (!ocfs2_parse_options(sb, data, &parsed_options, &slot, 1)) {
+        if (!ocfs2_parse_options(sb, data, &parsed_options, 1)) {
                 ret = -EINVAL;
                 goto out;
         }
 
         if ((osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) !=
-            (parsed_options & OCFS2_MOUNT_HB_LOCAL)) {
+            (parsed_options.mount_opt & OCFS2_MOUNT_HB_LOCAL)) {
                 ret = -EINVAL;
                 mlog(ML_ERROR, "Cannot change heartbeat mode on remount\n");
                 goto out;
         }
 
         if ((osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) !=
-            (parsed_options & OCFS2_MOUNT_DATA_WRITEBACK)) {
+            (parsed_options.mount_opt & OCFS2_MOUNT_DATA_WRITEBACK)) {
                 ret = -EINVAL;
                 mlog(ML_ERROR, "Cannot change data mode on remount\n");
                 goto out;
@@ -435,7 +441,9 @@ unlock_osb:
 
                 /* Only save off the new mount options in case of a successful
                  * remount. */
-                osb->s_mount_opt = parsed_options;
+                osb->s_mount_opt = parsed_options.mount_opt;
+                osb->s_atime_quantum = parsed_options.atime_quantum;
+                osb->preferred_slot = parsed_options.slot;
         }
 out:
         return ret;
@@ -547,8 +555,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
 {
         struct dentry *root;
         int status, sector_size;
-        unsigned long parsed_opt;
-        s16 slot;
+        struct mount_options parsed_options;
         struct inode *inode = NULL;
         struct ocfs2_super *osb = NULL;
         struct buffer_head *bh = NULL;
@@ -556,14 +563,14 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
 
         mlog_entry("%p, %p, %i", sb, data, silent);
 
-        if (!ocfs2_parse_options(sb, data, &parsed_opt, &slot, 0)) {
+        if (!ocfs2_parse_options(sb, data, &parsed_options, 0)) {
                 status = -EINVAL;
                 goto read_super_error;
         }
 
         /* for now we only have one cluster/node, make sure we see it
          * in the heartbeat universe */
-        if (parsed_opt & OCFS2_MOUNT_HB_LOCAL) {
+        if (parsed_options.mount_opt & OCFS2_MOUNT_HB_LOCAL) {
                 if (!o2hb_check_local_node_heartbeating()) {
                         status = -EINVAL;
                         goto read_super_error;
@@ -585,8 +592,9 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
         }
         brelse(bh);
         bh = NULL;
-        osb->s_mount_opt = parsed_opt;
-        osb->preferred_slot = slot;
+        osb->s_mount_opt = parsed_options.mount_opt;
+        osb->s_atime_quantum = parsed_options.atime_quantum;
+        osb->preferred_slot = parsed_options.slot;
 
         sb->s_magic = OCFS2_SUPER_MAGIC;
 
@@ -728,8 +736,7 @@ static struct file_system_type ocfs2_fs_type = {
 
 static int ocfs2_parse_options(struct super_block *sb,
                                char *options,
-                               unsigned long *mount_opt,
-                               s16 *slot,
+                               struct mount_options *mopt,
                                int is_remount)
 {
         int status;
@@ -738,8 +745,9 @@ static int ocfs2_parse_options(struct super_block *sb,
         mlog_entry("remount: %d, options: \"%s\"\n", is_remount,
                    options ? options : "(none)");
 
-        *mount_opt = 0;
-        *slot = OCFS2_INVALID_SLOT;
+        mopt->mount_opt = 0;
+        mopt->atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
+        mopt->slot = OCFS2_INVALID_SLOT;
 
         if (!options) {
                 status = 1;
@@ -749,7 +757,6 @@ static int ocfs2_parse_options(struct super_block *sb,
         while ((p = strsep(&options, ",")) != NULL) {
                 int token, option;
                 substring_t args[MAX_OPT_ARGS];
-                struct ocfs2_super * osb = OCFS2_SB(sb);
 
                 if (!*p)
                         continue;
@@ -757,10 +764,10 @@ static int ocfs2_parse_options(struct super_block *sb,
                 token = match_token(p, tokens, args);
                 switch (token) {
                 case Opt_hb_local:
-                        *mount_opt |= OCFS2_MOUNT_HB_LOCAL;
+                        mopt->mount_opt |= OCFS2_MOUNT_HB_LOCAL;
                         break;
                 case Opt_hb_none:
-                        *mount_opt &= ~OCFS2_MOUNT_HB_LOCAL;
+                        mopt->mount_opt &= ~OCFS2_MOUNT_HB_LOCAL;
                         break;
                 case Opt_barrier:
                         if (match_int(&args[0], &option)) {
@@ -768,27 +775,27 @@ static int ocfs2_parse_options(struct super_block *sb,
                                 goto bail;
                         }
                         if (option)
-                                *mount_opt |= OCFS2_MOUNT_BARRIER;
+                                mopt->mount_opt |= OCFS2_MOUNT_BARRIER;
                         else
-                                *mount_opt &= ~OCFS2_MOUNT_BARRIER;
+                                mopt->mount_opt &= ~OCFS2_MOUNT_BARRIER;
                         break;
                 case Opt_intr:
-                        *mount_opt &= ~OCFS2_MOUNT_NOINTR;
+                        mopt->mount_opt &= ~OCFS2_MOUNT_NOINTR;
                         break;
                 case Opt_nointr:
-                        *mount_opt |= OCFS2_MOUNT_NOINTR;
+                        mopt->mount_opt |= OCFS2_MOUNT_NOINTR;
                         break;
                 case Opt_err_panic:
-                        *mount_opt |= OCFS2_MOUNT_ERRORS_PANIC;
+                        mopt->mount_opt |= OCFS2_MOUNT_ERRORS_PANIC;
                         break;
                 case Opt_err_ro:
-                        *mount_opt &= ~OCFS2_MOUNT_ERRORS_PANIC;
+                        mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_PANIC;
                         break;
                 case Opt_data_ordered:
-                        *mount_opt &= ~OCFS2_MOUNT_DATA_WRITEBACK;
+                        mopt->mount_opt &= ~OCFS2_MOUNT_DATA_WRITEBACK;
                         break;
                 case Opt_data_writeback:
-                        *mount_opt |= OCFS2_MOUNT_DATA_WRITEBACK;
+                        mopt->mount_opt |= OCFS2_MOUNT_DATA_WRITEBACK;
                         break;
                 case Opt_atime_quantum:
                         if (match_int(&args[0], &option)) {
@@ -796,9 +803,7 @@ static int ocfs2_parse_options(struct super_block *sb,
                                 goto bail;
                         }
                         if (option >= 0)
-                                osb->s_atime_quantum = option;
-                        else
-                                osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
+                                mopt->atime_quantum = option;
                         break;
                 case Opt_slot:
                         option = 0;
@@ -807,7 +812,7 @@ static int ocfs2_parse_options(struct super_block *sb,
                                 goto bail;
                         }
                         if (option)
-                                *slot = (s16)option;
+                                mopt->slot = (s16)option;
                         break;
                 default:
                         mlog(ML_ERROR,
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index a5b0dfd89a17..0e4d37c93eea 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -11,6 +11,7 @@
 #include <linux/string.h>
 #include <linux/stat.h>
 #include <linux/completion.h>
+#include <linux/poll.h>
 #include <linux/file.h>
 #include <linux/limits.h>
 #include <linux/init.h>
@@ -232,7 +233,7 @@ static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t
 static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
 {
         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
-        unsigned int rv = 0;
+        unsigned int rv = DEFAULT_POLLMASK;
         unsigned int (*poll)(struct file *, struct poll_table_struct *);
 
         spin_lock(&pde->pde_unload_lock);
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 5b68dd3f191a..a005451930b7 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -1915,8 +1915,11 @@ static int reiserfs_release_dquot(struct dquot *dquot)
         ret =
             journal_begin(&th, dquot->dq_sb,
                           REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
-        if (ret)
+        if (ret) {
+                /* Release dquot anyway to avoid endless cycle in dqput() */
+                dquot_release(dquot);
                 goto out;
+        }
         ret = dquot_release(dquot);
         err =
             journal_end(&th, dquot->dq_sb,
@@ -2067,6 +2070,12 @@ static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
         size_t towrite = len;
         struct buffer_head tmp_bh, *bh;
 
+        if (!current->journal_info) {
+                printk(KERN_WARNING "reiserfs: Quota write (off=%Lu, len=%Lu)"
+                        " cancelled because transaction is not started.\n",
+                        (unsigned long long)off, (unsigned long long)len);
+                return -EIO;
+        }
         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
         while (towrite > 0) {
                 tocopy = sb->s_blocksize - offset < towrite ?
@@ -2098,7 +2107,7 @@ static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
                 data += tocopy;
                 blk++;
         }
-      out:
+out:
         if (len == towrite)
                 return err;
         if (inode->i_size < off + len - towrite)
diff --git a/fs/select.c b/fs/select.c
index a974082b0824..46dca31c607a 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -26,8 +26,6 @@
 
 #include <asm/uaccess.h>
 
-#define DEFAULT_POLLMASK (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)
-
 struct poll_table_page {
         struct poll_table_page * next;
         struct poll_table_entry * entry;
diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
index 276f7207a564..87e87dcd3f9c 100644
--- a/fs/udf/balloc.c
+++ b/fs/udf/balloc.c
@@ -540,26 +540,24 @@ static void udf_table_free_blocks(struct super_block *sb,
                         if (epos.offset + adsize > sb->s_blocksize) {
                                 loffset = epos.offset;
                                 aed->lengthAllocDescs = cpu_to_le32(adsize);
-                                sptr = UDF_I_DATA(inode) + epos.offset -
-                                        udf_file_entry_alloc_offset(inode) +
-                                        UDF_I_LENEATTR(inode) - adsize;
+                                sptr = UDF_I_DATA(table) + epos.offset - adsize;
                                 dptr = epos.bh->b_data + sizeof(struct allocExtDesc);
                                 memcpy(dptr, sptr, adsize);
                                 epos.offset = sizeof(struct allocExtDesc) + adsize;
                         } else {
                                 loffset = epos.offset + adsize;
                                 aed->lengthAllocDescs = cpu_to_le32(0);
-                                sptr = oepos.bh->b_data + epos.offset;
-                                epos.offset = sizeof(struct allocExtDesc);
-
                                 if (oepos.bh) {
+                                        sptr = oepos.bh->b_data + epos.offset;
                                         aed = (struct allocExtDesc *)oepos.bh->b_data;
                                         aed->lengthAllocDescs =
                                                 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
                                 } else {
+                                        sptr = UDF_I_DATA(table) + epos.offset;
                                         UDF_I_LENALLOC(table) += adsize;
                                         mark_inode_dirty(table);
                                 }
+                                epos.offset = sizeof(struct allocExtDesc);
                         }
                         if (UDF_SB_UDFREV(sb) >= 0x0200)
                                 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 382be7be5ae3..c68a6e730b97 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -89,7 +89,7 @@ static int udf_find_fileset(struct super_block *, kernel_lb_addr *,
 static void udf_load_pvoldesc(struct super_block *, struct buffer_head *);
 static void udf_load_fileset(struct super_block *, struct buffer_head *,
                              kernel_lb_addr *);
-static void udf_load_partdesc(struct super_block *, struct buffer_head *);
+static int udf_load_partdesc(struct super_block *, struct buffer_head *);
 static void udf_open_lvid(struct super_block *);
 static void udf_close_lvid(struct super_block *);
 static unsigned int udf_count_free(struct super_block *);
@@ -877,7 +877,7 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
                   root->logicalBlockNum, root->partitionReferenceNum);
 }
 
-static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
+static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
 {
         struct partitionDesc *p;
         int i;
@@ -912,6 +912,11 @@ static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
 
                                         UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table =
                                                 udf_iget(sb, loc);
+                                        if (!UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table) {
+                                                udf_debug("cannot load unallocSpaceTable (part %d)\n",
+                                                        i);
+                                                return 1;
+                                        }
                                         UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_TABLE;
                                         udf_debug("unallocSpaceTable (part %d) @ %ld\n",
                                                   i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table->i_ino);
@@ -938,6 +943,11 @@ static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
 
                                         UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table =
                                                 udf_iget(sb, loc);
+                                        if (!UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table) {
+                                                udf_debug("cannot load freedSpaceTable (part %d)\n",
+                                                        i);
+                                                return 1;
+                                        }
                                         UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_TABLE;
                                         udf_debug("freedSpaceTable (part %d) @ %ld\n",
                                                   i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table->i_ino);
@@ -966,6 +976,7 @@ static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
                           le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb,i),
                           UDF_SB_PARTROOT(sb,i), UDF_SB_PARTLEN(sb,i));
         }
+        return 0;
 }
 
 static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
@@ -1177,12 +1188,19 @@ static int udf_process_sequence(struct super_block *sb, long block, long lastblo
                                 udf_load_logicalvol(sb, bh, fileset);
                         } else if (i == VDS_POS_PARTITION_DESC) {
                                 struct buffer_head *bh2 = NULL;
-                                udf_load_partdesc(sb, bh);
+                                if (udf_load_partdesc(sb, bh)) {
+                                        brelse(bh);
+                                        return 1;
+                                }
                                 for (j = vds[i].block + 1; j <  vds[VDS_POS_TERMINATING_DESC].block; j++) {
                                         bh2 = udf_read_tagged(sb, j, j, &ident);
                                         gd = (struct generic_desc *)bh2->b_data;
                                         if (ident == TAG_IDENT_PD)
-                                                udf_load_partdesc(sb, bh2);
+                                                if (udf_load_partdesc(sb, bh2)) {
+                                                        brelse(bh);
+                                                        brelse(bh2);
+                                                        return 1;
+                                                }
                                         brelse(bh2);
                                 }
                         }
diff --git a/fs/xfs/linux-2.6/kmem.h b/fs/xfs/linux-2.6/kmem.h
index b4acc7f3c374..e6ea293f303c 100644
--- a/fs/xfs/linux-2.6/kmem.h
+++ b/fs/xfs/linux-2.6/kmem.h
@@ -103,7 +103,7 @@ extern void *kmem_zone_zalloc(kmem_zone_t *, unsigned int __nocast);
 static inline int
 kmem_shake_allow(gfp_t gfp_mask)
 {
-        return (gfp_mask & __GFP_WAIT);
+        return (gfp_mask & __GFP_WAIT) != 0;
 }
 
 #endif /* __XFS_SUPPORT_KMEM_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index fd4105d662e0..d9c40fe64195 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -652,7 +652,7 @@ xfs_probe_cluster(
 
                 for (i = 0; i < pagevec_count(&pvec); i++) {
                         struct page *page = pvec.pages[i];
-                        size_t pg_offset, len = 0;
+                        size_t pg_offset, pg_len = 0;
 
                         if (tindex == tlast) {
                                 pg_offset =
@@ -665,16 +665,16 @@ xfs_probe_cluster(
                                 pg_offset = PAGE_CACHE_SIZE;
 
                         if (page->index == tindex && !TestSetPageLocked(page)) {
-                                len = xfs_probe_page(page, pg_offset, mapped);
+                                pg_len = xfs_probe_page(page, pg_offset, mapped);
                                 unlock_page(page);
                         }
 
-                        if (!len) {
+                        if (!pg_len) {
                                 done = 1;
                                 break;
                         }
 
-                        total += len;
+                        total += pg_len;
                         tindex++;
                 }
 
diff --git a/fs/xfs/linux-2.6/xfs_globals.c b/fs/xfs/linux-2.6/xfs_globals.c
index bb72c3d4141f..81565dea9af7 100644
--- a/fs/xfs/linux-2.6/xfs_globals.c
+++ b/fs/xfs/linux-2.6/xfs_globals.c
@@ -46,7 +46,7 @@ xfs_param_t xfs_params = {
         .inherit_nosym  = {     0,              0,              1       },
         .rotorstep      = {     1,              1,              255     },
         .inherit_nodfrg = {     0,              1,              1       },
-        .fstrm_timer    = {     1,              50,             3600*100},
+        .fstrm_timer    = {     1,              30*100,         3600*100},
 };
 
 /*
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 2d274b23ade5..6ff0f4de1630 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -120,7 +120,8 @@ xfs_Gqm_init(void)
          * Initialize the dquot hash tables.
          */
         udqhash = kmem_zalloc_greedy(&hsize,
-                                     XFS_QM_HASHSIZE_LOW, XFS_QM_HASHSIZE_HIGH,
+                                     XFS_QM_HASHSIZE_LOW * sizeof(xfs_dqhash_t),
+                                     XFS_QM_HASHSIZE_HIGH * sizeof(xfs_dqhash_t),
                                      KM_SLEEP | KM_MAYFAIL | KM_LARGE);
         gdqhash = kmem_zalloc(hsize, KM_SLEEP | KM_LARGE);
         hsize /= sizeof(xfs_dqhash_t);
diff --git a/fs/xfs/support/debug.h b/fs/xfs/support/debug.h
index a27a7c8c0526..855da0408647 100644
--- a/fs/xfs/support/debug.h
+++ b/fs/xfs/support/debug.h
@@ -34,10 +34,10 @@ extern void cmn_err(int, char *, ...)
 extern void assfail(char *expr, char *f, int l);
 
 #define ASSERT_ALWAYS(expr)     \
-        (unlikely((expr) != 0) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
+        (unlikely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
 
 #ifndef DEBUG
-# define ASSERT(expr)   ((void)0)
+#define ASSERT(expr)    ((void)0)
 
 #ifndef STATIC
 # define STATIC static noinline
@@ -49,8 +49,10 @@ extern void assfail(char *expr, char *f, int l);
 
 #else /* DEBUG */
 
-# define ASSERT(expr)   ASSERT_ALWAYS(expr)
-# include <linux/random.h>
+#include <linux/random.h>
+
+#define ASSERT(expr)    \
+        (unlikely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
 
 #ifndef STATIC
 # define STATIC noinline
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index aea37df4aa62..26d09e2e1a7f 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -1975,7 +1975,6 @@ xfs_da_do_buf(
                 error = mappedbno == -2 ? 0 : XFS_ERROR(EFSCORRUPTED);
                 if (unlikely(error == EFSCORRUPTED)) {
                         if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
-                                int     i;
                                 cmn_err(CE_ALERT, "xfs_da_do_buf: bno %lld\n",
                                         (long long)bno);
                                 cmn_err(CE_ALERT, "dir: inode %lld\n",
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 9d4c4fbeb3ee..9bfb69e1e885 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -2185,13 +2185,13 @@ xlog_state_do_callback(
                         }
                         cb = iclog->ic_callback;
 
-                        while (cb != 0) {
+                        while (cb) {
                                 iclog->ic_callback_tail = &(iclog->ic_callback);
                                 iclog->ic_callback = NULL;
                                 LOG_UNLOCK(log, s);
 
                                 /* perform callbacks in the order given */
-                                for (; cb != 0; cb = cb_next) {
+                                for (; cb; cb = cb_next) {
                                         cb_next = cb->cb_next;
                                         cb->cb_func(cb->cb_arg, aborted);
                                 }
@@ -2202,7 +2202,7 @@ xlog_state_do_callback(
                         loopdidcallbacks++;
                         funcdidcallbacks++;
 
-                        ASSERT(iclog->ic_callback == 0);
+                        ASSERT(iclog->ic_callback == NULL);
                         if (!(iclog->ic_state & XLOG_STATE_IOERROR))
                                 iclog->ic_state = XLOG_STATE_DIRTY;
 
@@ -3242,10 +3242,10 @@ xlog_ticket_put(xlog_t		*log,
 #else
         /* When we debug, it is easier if tickets are cycled */
         ticket->t_next     = NULL;
-        if (log->l_tail != 0) {
+        if (log->l_tail) {
                 log->l_tail->t_next = ticket;
         } else {
-                ASSERT(log->l_freelist == 0);
+                ASSERT(log->l_freelist == NULL);
                 log->l_freelist = ticket;
         }
         log->l_tail         = ticket;
@@ -3463,7 +3463,7 @@ xlog_verify_iclog(xlog_t	 *log,
         s = LOG_LOCK(log);
         icptr = log->l_iclog;
         for (i=0; i < log->l_iclog_bufs; i++) {
-                if (icptr == 0)
+                if (icptr == NULL)
                         xlog_panic("xlog_verify_iclog: invalid ptr");
                 icptr = icptr->ic_next;
         }
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index fddbb091a86f..8ae6e8e5f3db 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -1366,7 +1366,7 @@ xlog_recover_add_to_cont_trans(
         int                     old_len;
 
         item = trans->r_itemq;
-        if (item == 0) {
+        if (item == NULL) {
                 /* finish copying rest of trans header */
                 xlog_recover_add_item(&trans->r_itemq);
                 ptr = (xfs_caddr_t) &trans->r_theader +
@@ -1412,7 +1412,7 @@ xlog_recover_add_to_trans(
         if (!len)
                 return 0;
         item = trans->r_itemq;
-        if (item == 0) {
+        if (item == NULL) {
                 ASSERT(*(uint *)dp == XFS_TRANS_HEADER_MAGIC);
                 if (len == sizeof(xfs_trans_header_t))
                         xlog_recover_add_item(&trans->r_itemq);
@@ -1467,12 +1467,12 @@ xlog_recover_unlink_tid(
         xlog_recover_t          *tp;
         int                     found = 0;
 
-        ASSERT(trans != 0);
+        ASSERT(trans != NULL);
         if (trans == *q) {
                 *q = (*q)->r_next;
         } else {
                 tp = *q;
-                while (tp != 0) {
+                while (tp) {
                         if (tp->r_next == trans) {
                                 found = 1;
                                 break;
@@ -1495,7 +1495,7 @@ xlog_recover_insert_item_backq(
         xlog_recover_item_t     **q,
         xlog_recover_item_t     *item)
 {
-        if (*q == 0) {
+        if (*q == NULL) {
                 item->ri_prev = item->ri_next = item;
                 *q = item;
         } else {
@@ -1899,7 +1899,7 @@ xlog_recover_do_reg_buffer(
                         break;
                 nbits = xfs_contig_bits(data_map, map_size, bit);
                 ASSERT(nbits > 0);
-                ASSERT(item->ri_buf[i].i_addr != 0);
+                ASSERT(item->ri_buf[i].i_addr != NULL);
                 ASSERT(item->ri_buf[i].i_len % XFS_BLI_CHUNK == 0);
                 ASSERT(XFS_BUF_COUNT(bp) >=
                        ((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT));