Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6: (96 commits)
  no need for list_for_each_entry_safe()/resetting with superblock list
  Fix sget() race with failing mount
  vfs: don't hold s_umount over close_bdev_exclusive() call
  sysv: do not mark superblock dirty on remount
  sysv: do not mark superblock dirty on mount
  btrfs: remove junk sb_dirt change
  BFS: clean up the superblock usage
  AFFS: wait for sb synchronization when needed
  AFFS: clean up dirty flag usage
  cifs: truncate fallout
  mbcache: fix shrinker function return value
  mbcache: Remove unused features
  add f_flags to struct statfs(64)
  pass a struct path to vfs_statfs
  update VFS documentation for method changes.
  All filesystems that need invalidate_inode_buffers() are doing that explicitly
  convert remaining ->clear_inode() to ->evict_inode()
  Make ->drop_inode() just return whether inode needs to be dropped
  fs/inode.c:clear_inode() is gone
  fs/inode.c:evict() doesn't care about delete vs. non-delete paths now
  ...

Fix up trivial conflicts in fs/nilfs2/super.c

7 files changed, 80 insertions, 98 deletions

diff --git a/fs/ext2/balloc.c b/fs/ext2/balloc.c
index e8766a396776..c6c684b44ea1 100644
--- a/fs/ext2/balloc.c
+++ b/fs/ext2/balloc.c
@@ -571,7 +571,7 @@ do_more:
 error_return:
         brelse(bitmap_bh);
         release_blocks(sb, freed);
-        dquot_free_block(inode, freed);
+        dquot_free_block_nodirty(inode, freed);
 }
 
 /**
@@ -1418,7 +1418,8 @@ allocated:
 
         *errp = 0;
         brelse(bitmap_bh);
-        dquot_free_block(inode, *count-num);
+        dquot_free_block_nodirty(inode, *count-num);
+        mark_inode_dirty(inode);
         *count = num;
         return ret_block;
 
@@ -1428,8 +1429,10 @@ out:
         /*
          * Undo the block allocation
          */
-        if (!performed_allocation)
-                dquot_free_block(inode, *count);
+        if (!performed_allocation) {
+                dquot_free_block_nodirty(inode, *count);
+                mark_inode_dirty(inode);
+        }
         brelse(bitmap_bh);
         return 0;
 }
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 7516957273ed..764109886ec0 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -448,6 +448,11 @@ ino_t ext2_inode_by_name(struct inode *dir, struct qstr *child)
         return res;
 }
 
+static int ext2_prepare_chunk(struct page *page, loff_t pos, unsigned len)
+{
+        return __block_write_begin(page, pos, len, ext2_get_block);
+}
+
 /* Releases the page */
 void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
                    struct page *page, struct inode *inode, int update_times)
@@ -458,8 +463,7 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
         int err;
 
         lock_page(page);
-        err = __ext2_write_begin(NULL, page->mapping, pos, len,
-                                AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+        err = ext2_prepare_chunk(page, pos, len);
         BUG_ON(err);
         de->inode = cpu_to_le32(inode->i_ino);
         ext2_set_de_type(de, inode);
@@ -542,8 +546,7 @@ int ext2_add_link (struct dentry *dentry, struct inode *inode)
 got_it:
         pos = page_offset(page) +
                 (char*)de - (char*)page_address(page);
-        err = __ext2_write_begin(NULL, page->mapping, pos, rec_len, 0,
-                                                        &page, NULL);
+        err = ext2_prepare_chunk(page, pos, rec_len);
         if (err)
                 goto out_unlock;
         if (de->inode) {
@@ -576,8 +579,7 @@ out_unlock:
  */
 int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
 {
-        struct address_space *mapping = page->mapping;
-        struct inode *inode = mapping->host;
+        struct inode *inode = page->mapping->host;
         char *kaddr = page_address(page);
         unsigned from = ((char*)dir - kaddr) & ~(ext2_chunk_size(inode)-1);
         unsigned to = ((char *)dir - kaddr) +
@@ -601,8 +603,7 @@ int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
                 from = (char*)pde - (char*)page_address(page);
         pos = page_offset(page) + from;
         lock_page(page);
-        err = __ext2_write_begin(NULL, page->mapping, pos, to - from, 0,
-                                                        &page, NULL);
+        err = ext2_prepare_chunk(page, pos, to - from);
         BUG_ON(err);
         if (pde)
                 pde->rec_len = ext2_rec_len_to_disk(to - from);
@@ -621,8 +622,7 @@ out:
  */
 int ext2_make_empty(struct inode *inode, struct inode *parent)
 {
-        struct address_space *mapping = inode->i_mapping;
-        struct page *page = grab_cache_page(mapping, 0);
+        struct page *page = grab_cache_page(inode->i_mapping, 0);
         unsigned chunk_size = ext2_chunk_size(inode);
         struct ext2_dir_entry_2 * de;
         int err;
@@ -631,8 +631,7 @@ int ext2_make_empty(struct inode *inode, struct inode *parent)
         if (!page)
                 return -ENOMEM;
 
-        err = __ext2_write_begin(NULL, page->mapping, 0, chunk_size, 0,
-                                                        &page, NULL);
+        err = ext2_prepare_chunk(page, 0, chunk_size);
         if (err) {
                 unlock_page(page);
                 goto fail;
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 52b34f1d2738..416daa62242c 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -119,7 +119,7 @@ extern unsigned long ext2_count_free (struct buffer_head *, unsigned);
 /* inode.c */
 extern struct inode *ext2_iget (struct super_block *, unsigned long);
 extern int ext2_write_inode (struct inode *, struct writeback_control *);
-extern void ext2_delete_inode (struct inode *);
+extern void ext2_evict_inode(struct inode *);
 extern int ext2_sync_inode (struct inode *);
 extern int ext2_get_block(struct inode *, sector_t, struct buffer_head *, int);
 extern int ext2_setattr (struct dentry *, struct iattr *);
@@ -127,9 +127,6 @@ extern void ext2_set_inode_flags(struct inode *inode);
 extern void ext2_get_inode_flags(struct ext2_inode_info *);
 extern int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                        u64 start, u64 len);
-int __ext2_write_begin(struct file *file, struct address_space *mapping,
-                loff_t pos, unsigned len, unsigned flags,
-                struct page **pagep, void **fsdata);
 
 /* ioctl.c */
 extern long ext2_ioctl(struct file *, unsigned int, unsigned long);
diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index 938dbc739d00..ad70479aabff 100644
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -118,19 +118,14 @@ void ext2_free_inode (struct inode * inode)
          * Note: we must free any quota before locking the superblock,
          * as writing the quota to disk may need the lock as well.
          */
-        if (!is_bad_inode(inode)) {
-                /* Quota is already initialized in iput() */
-                ext2_xattr_delete_inode(inode);
-                dquot_free_inode(inode);
-                dquot_drop(inode);
-        }
+        /* Quota is already initialized in iput() */
+        ext2_xattr_delete_inode(inode);
+        dquot_free_inode(inode);
+        dquot_drop(inode);
 
         es = EXT2_SB(sb)->s_es;
         is_directory = S_ISDIR(inode->i_mode);
 
-        /* Do this BEFORE marking the inode not in use or returning an error */
-        clear_inode (inode);
-
         if (ino < EXT2_FIRST_INO(sb) ||
             ino > le32_to_cpu(es->s_inodes_count)) {
                 ext2_error (sb, "ext2_free_inode",
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 3675088cb88c..940c96168868 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -69,26 +69,42 @@ static void ext2_write_failed(struct address_space *mapping, loff_t to)
 /*
  * Called at the last iput() if i_nlink is zero.
  */
-void ext2_delete_inode (struct inode * inode)
+void ext2_evict_inode(struct inode * inode)
 {
-        if (!is_bad_inode(inode))
+        struct ext2_block_alloc_info *rsv;
+        int want_delete = 0;
+
+        if (!inode->i_nlink && !is_bad_inode(inode)) {
+                want_delete = 1;
                 dquot_initialize(inode);
+        } else {
+                dquot_drop(inode);
+        }
+
         truncate_inode_pages(&inode->i_data, 0);
 
-        if (is_bad_inode(inode))
-                goto no_delete;
-        EXT2_I(inode)->i_dtime  = get_seconds();
-        mark_inode_dirty(inode);
-        __ext2_write_inode(inode, inode_needs_sync(inode));
+        if (want_delete) {
+                /* set dtime */
+                EXT2_I(inode)->i_dtime  = get_seconds();
+                mark_inode_dirty(inode);
+                __ext2_write_inode(inode, inode_needs_sync(inode));
+                /* truncate to 0 */
+                inode->i_size = 0;
+                if (inode->i_blocks)
+                        ext2_truncate_blocks(inode, 0);
+        }
 
-        inode->i_size = 0;
-        if (inode->i_blocks)
-                ext2_truncate_blocks(inode, 0);
-        ext2_free_inode (inode);
+        invalidate_inode_buffers(inode);
+        end_writeback(inode);
 
-        return;
-no_delete:
-        clear_inode(inode);     /* We must guarantee clearing of inode... */
+        ext2_discard_reservation(inode);
+        rsv = EXT2_I(inode)->i_block_alloc_info;
+        EXT2_I(inode)->i_block_alloc_info = NULL;
+        if (unlikely(rsv))
+                kfree(rsv);
+
+        if (want_delete)
+                ext2_free_inode(inode);
 }
 
 typedef struct {
@@ -423,6 +439,8 @@ static int ext2_alloc_blocks(struct inode *inode,
 failed_out:
         for (i = 0; i <index; i++)
                 ext2_free_blocks(inode, new_blocks[i], 1);
+        if (index)
+                mark_inode_dirty(inode);
         return ret;
 }
 
@@ -765,14 +783,6 @@ ext2_readpages(struct file *file, struct address_space *mapping,
         return mpage_readpages(mapping, pages, nr_pages, ext2_get_block);
 }
 
-int __ext2_write_begin(struct file *file, struct address_space *mapping,
-                loff_t pos, unsigned len, unsigned flags,
-                struct page **pagep, void **fsdata)
-{
-        return block_write_begin_newtrunc(file, mapping, pos, len, flags,
-                                        pagep, fsdata, ext2_get_block);
-}
-
 static int
 ext2_write_begin(struct file *file, struct address_space *mapping,
                 loff_t pos, unsigned len, unsigned flags,
@@ -780,8 +790,8 @@ ext2_write_begin(struct file *file, struct address_space *mapping,
 {
         int ret;
 
-        *pagep = NULL;
-        ret = __ext2_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
+        ret = block_write_begin(mapping, pos, len, flags, pagep,
+                                ext2_get_block);
         if (ret < 0)
                 ext2_write_failed(mapping, pos + len);
         return ret;
@@ -806,13 +816,8 @@ ext2_nobh_write_begin(struct file *file, struct address_space *mapping,
 {
         int ret;
 
-        /*
-         * Dir-in-pagecache still uses ext2_write_begin. Would have to rework
-         * directory handling code to pass around offsets rather than struct
-         * pages in order to make this work easily.
-         */
-        ret = nobh_write_begin_newtrunc(file, mapping, pos, len, flags, pagep,
-                                                fsdata, ext2_get_block);
+        ret = nobh_write_begin(mapping, pos, len, flags, pagep, fsdata,
+                               ext2_get_block);
         if (ret < 0)
                 ext2_write_failed(mapping, pos + len);
         return ret;
@@ -838,7 +843,7 @@ ext2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
         struct inode *inode = mapping->host;
         ssize_t ret;
 
-        ret = blockdev_direct_IO_newtrunc(rw, iocb, inode, inode->i_sb->s_bdev,
+        ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev,
                                 iov, offset, nr_segs, ext2_get_block, NULL);
         if (ret < 0 && (rw & WRITE))
                 ext2_write_failed(mapping, offset + iov_length(iov, nr_segs));
@@ -1006,8 +1011,8 @@ static inline void ext2_free_data(struct inode *inode, __le32 *p, __le32 *q)
                         else if (block_to_free == nr - count)
                                 count++;
                         else {
-                                mark_inode_dirty(inode);
                                 ext2_free_blocks (inode, block_to_free, count);
+                                mark_inode_dirty(inode);
                         free_this:
                                 block_to_free = nr;
                                 count = 1;
@@ -1015,8 +1020,8 @@ static inline void ext2_free_data(struct inode *inode, __le32 *p, __le32 *q)
                 }
         }
         if (count > 0) {
-                mark_inode_dirty(inode);
                 ext2_free_blocks (inode, block_to_free, count);
+                mark_inode_dirty(inode);
         }
 }
 
@@ -1169,15 +1174,10 @@ static void ext2_truncate_blocks(struct inode *inode, loff_t offset)
         __ext2_truncate_blocks(inode, offset);
 }
 
-int ext2_setsize(struct inode *inode, loff_t newsize)
+static int ext2_setsize(struct inode *inode, loff_t newsize)
 {
-        loff_t oldsize;
         int error;
 
-        error = inode_newsize_ok(inode, newsize);
-        if (error)
-                return error;
-
         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
             S_ISLNK(inode->i_mode)))
                 return -EINVAL;
@@ -1197,10 +1197,7 @@ int ext2_setsize(struct inode *inode, loff_t newsize)
         if (error)
                 return error;
 
-        oldsize = inode->i_size;
-        i_size_write(inode, newsize);
-        truncate_pagecache(inode, oldsize, newsize);
-
+        truncate_setsize(inode, newsize);
         __ext2_truncate_blocks(inode, newsize);
 
         inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
@@ -1557,7 +1554,7 @@ int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
                 if (error)
                         return error;
         }
-        generic_setattr(inode, iattr);
+        setattr_copy(inode, iattr);
         if (iattr->ia_valid & ATTR_MODE)
                 error = ext2_acl_chmod(inode);
         mark_inode_dirty(inode);
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 7ff43f4a59cd..1ec602673ea8 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -195,17 +195,6 @@ static void destroy_inodecache(void)
         kmem_cache_destroy(ext2_inode_cachep);
 }
 
-static void ext2_clear_inode(struct inode *inode)
-{
-        struct ext2_block_alloc_info *rsv = EXT2_I(inode)->i_block_alloc_info;
-
-        dquot_drop(inode);
-        ext2_discard_reservation(inode);
-        EXT2_I(inode)->i_block_alloc_info = NULL;
-        if (unlikely(rsv))
-                kfree(rsv);
-}
-
 static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
 {
         struct super_block *sb = vfs->mnt_sb;
@@ -299,13 +288,12 @@ static const struct super_operations ext2_sops = {
         .alloc_inode    = ext2_alloc_inode,
         .destroy_inode  = ext2_destroy_inode,
         .write_inode    = ext2_write_inode,
-        .delete_inode   = ext2_delete_inode,
+        .evict_inode    = ext2_evict_inode,
         .put_super      = ext2_put_super,
         .write_super    = ext2_write_super,
         .sync_fs        = ext2_sync_fs,
         .statfs         = ext2_statfs,
         .remount_fs     = ext2_remount,
-        .clear_inode    = ext2_clear_inode,
         .show_options   = ext2_show_options,
 #ifdef CONFIG_QUOTA
         .quota_read     = ext2_quota_read,
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index 7c3915780b19..8c29ae15129e 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -674,6 +674,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                         new_bh = sb_getblk(sb, block);
                         if (!new_bh) {
                                 ext2_free_blocks(inode, block, 1);
+                                mark_inode_dirty(inode);
                                 error = -EIO;
                                 goto cleanup;
                         }
@@ -703,8 +704,10 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                  * written (only some dirty data were not) so we just proceed
                  * as if nothing happened and cleanup the unused block */
                 if (error && error != -ENOSPC) {
-                        if (new_bh && new_bh != old_bh)
-                                dquot_free_block(inode, 1);
+                        if (new_bh && new_bh != old_bh) {
+                                dquot_free_block_nodirty(inode, 1);
+                                mark_inode_dirty(inode);
+                        }
                         goto cleanup;
                 }
         } else
@@ -727,6 +730,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                                 mb_cache_entry_free(ce);
                         ea_bdebug(old_bh, "freeing");
                         ext2_free_blocks(inode, old_bh->b_blocknr, 1);
+                        mark_inode_dirty(inode);
                         /* We let our caller release old_bh, so we
                          * need to duplicate the buffer before. */
                         get_bh(old_bh);
@@ -736,7 +740,8 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                         le32_add_cpu(&HDR(old_bh)->h_refcount, -1);
                         if (ce)
                                 mb_cache_entry_release(ce);
-                        dquot_free_block(inode, 1);
+                        dquot_free_block_nodirty(inode, 1);
+                        mark_inode_dirty(inode);
                         mark_buffer_dirty(old_bh);
                         ea_bdebug(old_bh, "refcount now=%d",
                                 le32_to_cpu(HDR(old_bh)->h_refcount));
@@ -799,7 +804,7 @@ ext2_xattr_delete_inode(struct inode *inode)
                 mark_buffer_dirty(bh);
                 if (IS_SYNC(inode))
                         sync_dirty_buffer(bh);
-                dquot_free_block(inode, 1);
+                dquot_free_block_nodirty(inode, 1);
         }
         EXT2_I(inode)->i_file_acl = 0;
 
@@ -838,7 +843,7 @@ ext2_xattr_cache_insert(struct buffer_head *bh)
         ce = mb_cache_entry_alloc(ext2_xattr_cache, GFP_NOFS);
         if (!ce)
                 return -ENOMEM;
-        error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, &hash);
+        error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, hash);
         if (error) {
                 mb_cache_entry_free(ce);
                 if (error == -EBUSY) {
@@ -912,8 +917,8 @@ ext2_xattr_cache_find(struct inode *inode, struct ext2_xattr_header *header)
                 return NULL;  /* never share */
         ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
 again:
-        ce = mb_cache_entry_find_first(ext2_xattr_cache, 0,
-                                       inode->i_sb->s_bdev, hash);
+        ce = mb_cache_entry_find_first(ext2_xattr_cache, inode->i_sb->s_bdev,
+                                       hash);
         while (ce) {
                 struct buffer_head *bh;
 
@@ -945,7 +950,7 @@ again:
                         unlock_buffer(bh);
                         brelse(bh);
                 }
-                ce = mb_cache_entry_find_next(ce, 0, inode->i_sb->s_bdev, hash);
+                ce = mb_cache_entry_find_next(ce, inode->i_sb->s_bdev, hash);
         }
         return NULL;
 }
@@ -1021,9 +1026,7 @@ static void ext2_xattr_rehash(struct ext2_xattr_header *header,
 int __init
 init_ext2_xattr(void)
 {
-        ext2_xattr_cache = mb_cache_create("ext2_xattr", NULL,
-                sizeof(struct mb_cache_entry) +
-                sizeof(((struct mb_cache_entry *) 0)->e_indexes[0]), 1, 6);
+        ext2_xattr_cache = mb_cache_create("ext2_xattr", 6);
         if (!ext2_xattr_cache)
                 return -ENOMEM;
         return 0;