convert remaining ->clear_inode() to ->evict_inode()
Al Viro [Mon, 7 Jun 2010 18:34:48 +0000 (14:34 -0400)]
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

34 files changed:
fs/9p/v9fs_vfs.h
fs/9p/vfs_inode.c
fs/9p/vfs_super.c
fs/afs/inode.c
fs/afs/internal.h
fs/afs/super.c
fs/binfmt_misc.c
fs/block_dev.c
fs/cifs/cifsfs.c
fs/coda/inode.c
fs/ecryptfs/super.c
fs/freevxfs/vxfs_extern.h
fs/freevxfs/vxfs_inode.c
fs/freevxfs/vxfs_super.c
fs/fuse/inode.c
fs/hfs/hfs_fs.h
fs/hfs/inode.c
fs/hfs/super.c
fs/hfsplus/super.c
fs/inode.c
fs/jffs2/fs.c
fs/jffs2/os-linux.h
fs/jffs2/super.c
fs/jffs2/xattr.c
fs/nfs/inode.c
fs/nfs/internal.h
fs/nfs/super.c
fs/ntfs/inode.c
fs/ntfs/inode.h
fs/ntfs/super.c
fs/ocfs2/dlmfs/dlmfs.c
fs/xfs/linux-2.6/xfs_super.c
fs/xfs/linux-2.6/xfs_trace.h
include/linux/fs.h

index 32ef400..3d056fe 100644 (file)
@@ -52,7 +52,7 @@ void v9fs_destroy_inode(struct inode *inode);
 #endif
 
 struct inode *v9fs_get_inode(struct super_block *sb, int mode);
-void v9fs_clear_inode(struct inode *inode);
+void v9fs_evict_inode(struct inode *inode);
 ino_t v9fs_qid2ino(struct p9_qid *qid);
 void v9fs_stat2inode(struct p9_wstat *, struct inode *, struct super_block *);
 int v9fs_dir_release(struct inode *inode, struct file *filp);
index 4b3ad6a..b81ce20 100644 (file)
@@ -387,8 +387,10 @@ error:
  * @inode: inode to release
  *
  */
-void v9fs_clear_inode(struct inode *inode)
+void v9fs_evict_inode(struct inode *inode)
 {
+       truncate_inode_pages(inode->i_mapping, 0);
+       end_writeback(inode);
        filemap_fdatawrite(inode->i_mapping);
 
 #ifdef CONFIG_9P_FSCACHE
index be74d02..c6122bf 100644 (file)
@@ -257,7 +257,7 @@ static const struct super_operations v9fs_super_ops = {
        .destroy_inode = v9fs_destroy_inode,
 #endif
        .statfs = simple_statfs,
-       .clear_inode = v9fs_clear_inode,
+       .evict_inode = v9fs_evict_inode,
        .show_options = generic_show_options,
        .umount_begin = v9fs_umount_begin,
 };
@@ -268,7 +268,7 @@ static const struct super_operations v9fs_super_ops_dotl = {
        .destroy_inode = v9fs_destroy_inode,
 #endif
        .statfs = v9fs_statfs,
-       .clear_inode = v9fs_clear_inode,
+       .evict_inode = v9fs_evict_inode,
        .show_options = generic_show_options,
        .umount_begin = v9fs_umount_begin,
 };
index d00b312..320ffef 100644 (file)
@@ -316,7 +316,7 @@ int afs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 /*
  * clear an AFS inode
  */
-void afs_clear_inode(struct inode *inode)
+void afs_evict_inode(struct inode *inode)
 {
        struct afs_permits *permits;
        struct afs_vnode *vnode;
@@ -335,6 +335,9 @@ void afs_clear_inode(struct inode *inode)
 
        ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode);
 
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
+
        afs_give_up_callback(vnode);
 
        if (vnode->server) {
index 5f679b7..8679089 100644 (file)
@@ -565,7 +565,7 @@ extern void afs_zap_data(struct afs_vnode *);
 extern int afs_validate(struct afs_vnode *, struct key *);
 extern int afs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 extern int afs_setattr(struct dentry *, struct iattr *);
-extern void afs_clear_inode(struct inode *);
+extern void afs_evict_inode(struct inode *);
 
 /*
  * main.c
index e932e5a..9cf80f0 100644 (file)
@@ -49,7 +49,7 @@ static const struct super_operations afs_super_ops = {
        .statfs         = afs_statfs,
        .alloc_inode    = afs_alloc_inode,
        .destroy_inode  = afs_destroy_inode,
-       .clear_inode    = afs_clear_inode,
+       .evict_inode    = afs_evict_inode,
        .put_super      = afs_put_super,
        .show_options   = generic_show_options,
 };
index c4e8353..9e60fd2 100644 (file)
@@ -502,8 +502,9 @@ static struct inode *bm_get_inode(struct super_block *sb, int mode)
        return inode;
 }
 
-static void bm_clear_inode(struct inode *inode)
+static void bm_evict_inode(struct inode *inode)
 {
+       end_writeback(inode);
        kfree(inode->i_private);
 }
 
@@ -685,7 +686,7 @@ static const struct file_operations bm_status_operations = {
 
 static const struct super_operations s_ops = {
        .statfs         = simple_statfs,
-       .clear_inode    = bm_clear_inode,
+       .evict_inode    = bm_evict_inode,
 };
 
 static int bm_fill_super(struct super_block * sb, void * data, int silent)
index 63c9d60..de7b4d0 100644 (file)
@@ -426,10 +426,13 @@ static inline void __bd_forget(struct inode *inode)
        inode->i_mapping = &inode->i_data;
 }
 
-static void bdev_clear_inode(struct inode *inode)
+static void bdev_evict_inode(struct inode *inode)
 {
        struct block_device *bdev = &BDEV_I(inode)->bdev;
        struct list_head *p;
+       truncate_inode_pages(&inode->i_data, 0);
+       invalidate_inode_buffers(inode); /* is it needed here? */
+       end_writeback(inode);
        spin_lock(&bdev_lock);
        while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
                __bd_forget(list_entry(p, struct inode, i_devices));
@@ -443,7 +446,7 @@ static const struct super_operations bdev_sops = {
        .alloc_inode = bdev_alloc_inode,
        .destroy_inode = bdev_destroy_inode,
        .drop_inode = generic_delete_inode,
-       .clear_inode = bdev_clear_inode,
+       .evict_inode = bdev_evict_inode,
 };
 
 static int bd_get_sb(struct file_system_type *fs_type,
index 20914f5..5574a42 100644 (file)
@@ -330,8 +330,10 @@ cifs_destroy_inode(struct inode *inode)
 }
 
 static void
-cifs_clear_inode(struct inode *inode)
+cifs_evict_inode(struct inode *inode)
 {
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        cifs_fscache_release_inode_cookie(inode);
 }
 
@@ -495,7 +497,7 @@ static const struct super_operations cifs_super_ops = {
        .alloc_inode = cifs_alloc_inode,
        .destroy_inode = cifs_destroy_inode,
        .drop_inode     = cifs_drop_inode,
-       .clear_inode    = cifs_clear_inode,
+       .evict_inode    = cifs_evict_inode,
 /*     .delete_inode   = cifs_delete_inode,  */  /* Do not need above
        function unless later we add lazy close of inodes or unless the
        kernel forgets to call us with the same number of releases (closes)
index d97f993..6526e6f 100644 (file)
@@ -35,7 +35,7 @@
 #include "coda_int.h"
 
 /* VFS super_block ops */
-static void coda_clear_inode(struct inode *);
+static void coda_evict_inode(struct inode *);
 static void coda_put_super(struct super_block *);
 static int coda_statfs(struct dentry *dentry, struct kstatfs *buf);
 
@@ -93,7 +93,7 @@ static const struct super_operations coda_super_operations =
 {
        .alloc_inode    = coda_alloc_inode,
        .destroy_inode  = coda_destroy_inode,
-       .clear_inode    = coda_clear_inode,
+       .evict_inode    = coda_evict_inode,
        .put_super      = coda_put_super,
        .statfs         = coda_statfs,
        .remount_fs     = coda_remount,
@@ -224,8 +224,10 @@ static void coda_put_super(struct super_block *sb)
        printk("Coda: Bye bye.\n");
 }
 
-static void coda_clear_inode(struct inode *inode)
+static void coda_evict_inode(struct inode *inode)
 {
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        coda_cache_clear_inode(inode);
 }
 
index 0435886..4b5de6c 100644 (file)
@@ -122,7 +122,7 @@ static int ecryptfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 }
 
 /**
- * ecryptfs_clear_inode
+ * ecryptfs_evict_inode
  * @inode - The ecryptfs inode
  *
  * Called by iput() when the inode reference count reached zero
@@ -131,8 +131,10 @@ static int ecryptfs_statfs(struct dentry *dentry, struct kstatfs *buf)
  * on the inode free list. We use this to drop out reference to the
  * lower inode.
  */
-static void ecryptfs_clear_inode(struct inode *inode)
+static void ecryptfs_evict_inode(struct inode *inode)
 {
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        iput(ecryptfs_inode_to_lower(inode));
 }
 
@@ -184,6 +186,6 @@ const struct super_operations ecryptfs_sops = {
        .drop_inode = generic_delete_inode,
        .statfs = ecryptfs_statfs,
        .remount_fs = NULL,
-       .clear_inode = ecryptfs_clear_inode,
+       .evict_inode = ecryptfs_evict_inode,
        .show_options = ecryptfs_show_options
 };
index 50ab5ee..881aa3d 100644 (file)
@@ -63,7 +63,7 @@ extern void                   vxfs_put_fake_inode(struct inode *);
 extern struct vxfs_inode_info *        vxfs_blkiget(struct super_block *, u_long, ino_t);
 extern struct vxfs_inode_info *        vxfs_stiget(struct super_block *, ino_t);
 extern struct inode *          vxfs_iget(struct super_block *, ino_t);
-extern void                    vxfs_clear_inode(struct inode *);
+extern void                    vxfs_evict_inode(struct inode *);
 
 /* vxfs_lookup.c */
 extern const struct inode_operations   vxfs_dir_inode_ops;
index 03a6ea5..79d1b4e 100644 (file)
@@ -337,15 +337,17 @@ vxfs_iget(struct super_block *sbp, ino_t ino)
 }
 
 /**
- * vxfs_clear_inode - remove inode from main memory
+ * vxfs_evict_inode - remove inode from main memory
  * @ip:                inode to discard.
  *
  * Description:
- *  vxfs_clear_inode() is called on the final iput and frees the private
+ *  vxfs_evict_inode() is called on the final iput and frees the private
  *  inode area.
  */
 void
-vxfs_clear_inode(struct inode *ip)
+vxfs_evict_inode(struct inode *ip)
 {
+       truncate_inode_pages(&ip->i_data, 0);
+       end_writeback(ip);
        kmem_cache_free(vxfs_inode_cachep, ip->i_private);
 }
index 1e8af93..1f3ffd9 100644 (file)
@@ -61,7 +61,7 @@ static int            vxfs_statfs(struct dentry *, struct kstatfs *);
 static int             vxfs_remount(struct super_block *, int *, char *);
 
 static const struct super_operations vxfs_super_ops = {
-       .clear_inode =          vxfs_clear_inode,
+       .evict_inode =          vxfs_evict_inode,
        .put_super =            vxfs_put_super,
        .statfs =               vxfs_statfs,
        .remount_fs =           vxfs_remount,
index ec14d19..da9e6e1 100644 (file)
@@ -122,8 +122,10 @@ void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
        fuse_request_send_noreply(fc, req);
 }
 
-static void fuse_clear_inode(struct inode *inode)
+static void fuse_evict_inode(struct inode *inode)
 {
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        if (inode->i_sb->s_flags & MS_ACTIVE) {
                struct fuse_conn *fc = get_fuse_conn(inode);
                struct fuse_inode *fi = get_fuse_inode(inode);
@@ -736,7 +738,7 @@ static const struct export_operations fuse_export_operations = {
 static const struct super_operations fuse_super_operations = {
        .alloc_inode    = fuse_alloc_inode,
        .destroy_inode  = fuse_destroy_inode,
-       .clear_inode    = fuse_clear_inode,
+       .evict_inode    = fuse_evict_inode,
        .drop_inode     = generic_delete_inode,
        .remount_fs     = fuse_remount_fs,
        .put_super      = fuse_put_super,
index fe35e3b..4f55651 100644 (file)
@@ -193,7 +193,7 @@ extern int hfs_inode_setattr(struct dentry *, struct iattr *);
 extern void hfs_inode_read_fork(struct inode *inode, struct hfs_extent *ext,
                        __be32 log_size, __be32 phys_size, u32 clump_size);
 extern struct inode *hfs_iget(struct super_block *, struct hfs_cat_key *, hfs_cat_rec *);
-extern void hfs_clear_inode(struct inode *);
+extern void hfs_evict_inode(struct inode *);
 extern void hfs_delete_inode(struct inode *);
 
 /* attr.c */
index 93ceec8..397b7ad 100644 (file)
@@ -531,8 +531,10 @@ out:
        return NULL;
 }
 
-void hfs_clear_inode(struct inode *inode)
+void hfs_evict_inode(struct inode *inode)
 {
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        if (HFS_IS_RSRC(inode) && HFS_I(inode)->rsrc_inode) {
                HFS_I(HFS_I(inode)->rsrc_inode)->rsrc_inode = NULL;
                iput(HFS_I(inode)->rsrc_inode);
index 0a81eb7..34235d4 100644 (file)
@@ -181,7 +181,7 @@ static const struct super_operations hfs_super_operations = {
        .alloc_inode    = hfs_alloc_inode,
        .destroy_inode  = hfs_destroy_inode,
        .write_inode    = hfs_write_inode,
-       .clear_inode    = hfs_clear_inode,
+       .evict_inode    = hfs_evict_inode,
        .put_super      = hfs_put_super,
        .write_super    = hfs_write_super,
        .sync_fs        = hfs_sync_fs,
index a32c241..3b55c05 100644 (file)
@@ -145,9 +145,11 @@ static int hfsplus_write_inode(struct inode *inode,
        return ret;
 }
 
-static void hfsplus_clear_inode(struct inode *inode)
+static void hfsplus_evict_inode(struct inode *inode)
 {
-       dprint(DBG_INODE, "hfsplus_clear_inode: %lu\n", inode->i_ino);
+       dprint(DBG_INODE, "hfsplus_evict_inode: %lu\n", inode->i_ino);
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        if (HFSPLUS_IS_RSRC(inode)) {
                HFSPLUS_I(HFSPLUS_I(inode).rsrc_inode).rsrc_inode = NULL;
                iput(HFSPLUS_I(inode).rsrc_inode);
@@ -293,7 +295,7 @@ static const struct super_operations hfsplus_sops = {
        .alloc_inode    = hfsplus_alloc_inode,
        .destroy_inode  = hfsplus_destroy_inode,
        .write_inode    = hfsplus_write_inode,
-       .clear_inode    = hfsplus_clear_inode,
+       .evict_inode    = hfsplus_evict_inode,
        .put_super      = hfsplus_put_super,
        .write_super    = hfsplus_write_super,
        .sync_fs        = hfsplus_sync_fs,
index 0e07761..5daeb0b 100644 (file)
@@ -317,8 +317,6 @@ static void evict(struct inode *inode)
                        truncate_inode_pages(&inode->i_data, 0);
                invalidate_inode_buffers(inode);
                end_writeback(inode);
-               if (op->clear_inode)
-                       op->clear_inode(inode);
        }
        if (S_ISBLK(inode->i_mode) && inode->i_bdev)
                bd_forget(inode);
index 1b24266..ac0638f 100644 (file)
@@ -225,7 +225,7 @@ int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 }
 
 
-void jffs2_clear_inode (struct inode *inode)
+void jffs2_evict_inode (struct inode *inode)
 {
        /* We can forget about this inode for now - drop all
         *  the nodelists associated with it, etc.
@@ -233,7 +233,9 @@ void jffs2_clear_inode (struct inode *inode)
        struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 
-       D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
+       D1(printk(KERN_DEBUG "jffs2_evict_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        jffs2_do_clear_inode(c, f);
 }
 
index 4791aac..00bae7c 100644 (file)
@@ -171,7 +171,7 @@ extern const struct inode_operations jffs2_symlink_inode_operations;
 int jffs2_setattr (struct dentry *, struct iattr *);
 int jffs2_do_setattr (struct inode *, struct iattr *);
 struct inode *jffs2_iget(struct super_block *, unsigned long);
-void jffs2_clear_inode (struct inode *);
+void jffs2_evict_inode (struct inode *);
 void jffs2_dirty_inode(struct inode *inode);
 struct inode *jffs2_new_inode (struct inode *dir_i, int mode,
                               struct jffs2_raw_inode *ri);
index 511e2d6..662bba0 100644 (file)
@@ -135,7 +135,7 @@ static const struct super_operations jffs2_super_operations =
        .write_super =  jffs2_write_super,
        .statfs =       jffs2_statfs,
        .remount_fs =   jffs2_remount_fs,
-       .clear_inode =  jffs2_clear_inode,
+       .evict_inode =  jffs2_evict_inode,
        .dirty_inode =  jffs2_dirty_inode,
        .sync_fs =      jffs2_sync_fs,
 };
index d258e26..9b572ca 100644 (file)
@@ -588,7 +588,7 @@ static void delete_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *re
 
 void jffs2_xattr_delete_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
 {
-       /* It's called from jffs2_clear_inode() on inode removing.
+       /* It's called from jffs2_evict_inode() on inode removing.
           When an inode with XATTR is removed, those XATTRs must be removed. */
        struct jffs2_xattr_ref *ref, *_ref;
 
index 099b351..c211b81 100644 (file)
@@ -98,7 +98,7 @@ u64 nfs_compat_user_ino64(u64 fileid)
        return ino;
 }
 
-void nfs_clear_inode(struct inode *inode)
+static void nfs_clear_inode(struct inode *inode)
 {
        /*
         * The following should never happen...
@@ -110,6 +110,13 @@ void nfs_clear_inode(struct inode *inode)
        nfs_fscache_release_inode_cookie(inode);
 }
 
+void nfs_evict_inode(struct inode *inode)
+{
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
+       nfs_clear_inode(inode);
+}
+
 /**
  * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
  */
@@ -1338,8 +1345,10 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  * to open() calls that passed nfs_atomic_lookup, but failed to call
  * nfs_open().
  */
-void nfs4_clear_inode(struct inode *inode)
+void nfs4_evict_inode(struct inode *inode)
 {
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        /* If we are holding a delegation, return it! */
        nfs_inode_return_delegation_noreclaim(inode);
        /* First call standard NFS clear_inode() code */
index e70f44b..f168ebd 100644 (file)
@@ -213,9 +213,9 @@ extern struct workqueue_struct *nfsiod_workqueue;
 extern struct inode *nfs_alloc_inode(struct super_block *sb);
 extern void nfs_destroy_inode(struct inode *);
 extern int nfs_write_inode(struct inode *, struct writeback_control *);
-extern void nfs_clear_inode(struct inode *);
+extern void nfs_evict_inode(struct inode *);
 #ifdef CONFIG_NFS_V4
-extern void nfs4_clear_inode(struct inode *);
+extern void nfs4_evict_inode(struct inode *);
 #endif
 void nfs_zap_acl_cache(struct inode *inode);
 extern int nfs_wait_bit_killable(void *word);
index f9df16d..ef2b7e4 100644 (file)
@@ -270,7 +270,7 @@ static const struct super_operations nfs_sops = {
        .write_inode    = nfs_write_inode,
        .put_super      = nfs_put_super,
        .statfs         = nfs_statfs,
-       .clear_inode    = nfs_clear_inode,
+       .evict_inode    = nfs_evict_inode,
        .umount_begin   = nfs_umount_begin,
        .show_options   = nfs_show_options,
        .show_stats     = nfs_show_stats,
@@ -340,7 +340,7 @@ static const struct super_operations nfs4_sops = {
        .write_inode    = nfs_write_inode,
        .put_super      = nfs_put_super,
        .statfs         = nfs_statfs,
-       .clear_inode    = nfs4_clear_inode,
+       .evict_inode    = nfs4_evict_inode,
        .umount_begin   = nfs_umount_begin,
        .show_options   = nfs_show_options,
        .show_stats     = nfs_show_stats,
index fdef8f7..93622b1 100644 (file)
@@ -2238,7 +2238,7 @@ void ntfs_clear_extent_inode(ntfs_inode *ni)
 }
 
 /**
- * ntfs_clear_big_inode - clean up the ntfs specific part of an inode
+ * ntfs_evict_big_inode - clean up the ntfs specific part of an inode
  * @vi:                vfs inode pending annihilation
  *
  * When the VFS is going to remove an inode from memory, ntfs_clear_big_inode()
@@ -2247,10 +2247,13 @@ void ntfs_clear_extent_inode(ntfs_inode *ni)
  *
  * If the MFT record is dirty, we commit it before doing anything else.
  */
-void ntfs_clear_big_inode(struct inode *vi)
+void ntfs_evict_big_inode(struct inode *vi)
 {
        ntfs_inode *ni = NTFS_I(vi);
 
+       truncate_inode_pages(&vi->i_data, 0);
+       end_writeback(vi);
+
 #ifdef NTFS_RW
        if (NInoDirty(ni)) {
                bool was_bad = (is_bad_inode(vi));
index 9a11354..2dabf81 100644 (file)
@@ -279,7 +279,7 @@ extern struct inode *ntfs_index_iget(struct inode *base_vi, ntfschar *name,
 
 extern struct inode *ntfs_alloc_big_inode(struct super_block *sb);
 extern void ntfs_destroy_big_inode(struct inode *inode);
-extern void ntfs_clear_big_inode(struct inode *vi);
+extern void ntfs_evict_big_inode(struct inode *vi);
 
 extern void __ntfs_init_inode(struct super_block *sb, ntfs_inode *ni);
 
index 0de1db6..5128061 100644 (file)
@@ -2700,7 +2700,7 @@ static const struct super_operations ntfs_sops = {
        .put_super      = ntfs_put_super,       /* Syscall: umount. */
        .statfs         = ntfs_statfs,          /* Syscall: statfs */
        .remount_fs     = ntfs_remount,         /* Syscall: mount -o remount. */
-       .clear_inode    = ntfs_clear_big_inode, /* VFS: Called when an inode is
+       .evict_inode    = ntfs_evict_big_inode, /* VFS: Called when an inode is
                                                   removed from memory. */
        //.umount_begin = NULL,                 /* Forced umount. */
        .show_options   = ntfs_show_options,    /* Show mount options in
index 85e4cca..a43ebb1 100644 (file)
@@ -357,13 +357,12 @@ static void dlmfs_destroy_inode(struct inode *inode)
        kmem_cache_free(dlmfs_inode_cache, DLMFS_I(inode));
 }
 
-static void dlmfs_clear_inode(struct inode *inode)
+static void dlmfs_evict_inode(struct inode *inode)
 {
        int status;
        struct dlmfs_inode_private *ip;
 
-       if (!inode)
-               return;
+       end_writeback(inode);
 
        mlog(0, "inode %lu\n", inode->i_ino);
 
@@ -633,7 +632,7 @@ static const struct super_operations dlmfs_ops = {
        .statfs         = simple_statfs,
        .alloc_inode    = dlmfs_alloc_inode,
        .destroy_inode  = dlmfs_destroy_inode,
-       .clear_inode    = dlmfs_clear_inode,
+       .evict_inode    = dlmfs_evict_inode,
        .drop_inode     = generic_delete_inode,
 };
 
index 758df94..15c35b6 100644 (file)
@@ -1100,13 +1100,15 @@ xfs_fs_write_inode(
 }
 
 STATIC void
-xfs_fs_clear_inode(
+xfs_fs_evict_inode(
        struct inode            *inode)
 {
        xfs_inode_t             *ip = XFS_I(inode);
 
-       trace_xfs_clear_inode(ip);
+       trace_xfs_evict_inode(ip);
 
+       truncate_inode_pages(&inode->i_data, 0);
+       end_writeback(inode);
        XFS_STATS_INC(vn_rele);
        XFS_STATS_INC(vn_remove);
        XFS_STATS_DEC(vn_active);
@@ -1622,7 +1624,7 @@ static const struct super_operations xfs_super_operations = {
        .destroy_inode          = xfs_fs_destroy_inode,
        .dirty_inode            = xfs_fs_dirty_inode,
        .write_inode            = xfs_fs_write_inode,
-       .clear_inode            = xfs_fs_clear_inode,
+       .evict_inode            = xfs_fs_evict_inode,
        .put_super              = xfs_fs_put_super,
        .sync_fs                = xfs_fs_sync_fs,
        .freeze_fs              = xfs_fs_freeze,
index c657cdc..be5dffd 100644 (file)
@@ -581,7 +581,7 @@ DEFINE_INODE_EVENT(xfs_ioctl_setattr);
 DEFINE_INODE_EVENT(xfs_file_fsync);
 DEFINE_INODE_EVENT(xfs_destroy_inode);
 DEFINE_INODE_EVENT(xfs_write_inode);
-DEFINE_INODE_EVENT(xfs_clear_inode);
+DEFINE_INODE_EVENT(xfs_evict_inode);
 
 DEFINE_INODE_EVENT(xfs_dquot_dqalloc);
 DEFINE_INODE_EVENT(xfs_dquot_dqdetach);
index 8553adb..dec9ac5 100644 (file)
@@ -1571,7 +1571,6 @@ struct super_operations {
        int (*unfreeze_fs) (struct super_block *);
        int (*statfs) (struct dentry *, struct kstatfs *);
        int (*remount_fs) (struct super_block *, int *, char *);
-       void (*clear_inode) (struct inode *);
        void (*umount_begin) (struct super_block *);
 
        int (*show_options)(struct seq_file *, struct vfsmount *);
@@ -1616,7 +1615,7 @@ struct super_operations {
  * I_FREEING           Set when inode is about to be freed but still has dirty
  *                     pages or buffers attached or the inode itself is still
  *                     dirty.
- * I_CLEAR             Added by clear_inode().  In this state the inode is clean
+ * I_CLEAR             Added by end_writeback().  In this state the inode is clean
  *                     and can be destroyed.  Inode keeps I_FREEING.
  *
  *                     Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are