1 files changed, 5 insertions, 83 deletions

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 0d9de41a7151..bdaf4cb9f4a2 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -868,67 +868,14 @@ xfs_fs_inode_init_once(
                      "xfsino", ip->i_ino);
 }
 
-/*
- * This is called by the VFS when dirtying inode metadata.  This can happen
- * for a few reasons, but we only care about timestamp updates, given that
- * we handled the rest ourselves.  In theory no other calls should happen,
- * but for example generic_write_end() keeps dirtying the inode after
- * updating i_size.  Thus we check that the flags are exactly I_DIRTY_SYNC,
- * and skip this call otherwise.
- *
- * We'll hopefull get a different method just for updating timestamps soon,
- * at which point this hack can go away, and maybe we'll also get real
- * error handling here.
- */
-STATIC void
-xfs_fs_dirty_inode(
-        struct inode            *inode,
-        int                     flags)
-{
-        struct xfs_inode        *ip = XFS_I(inode);
-        struct xfs_mount        *mp = ip->i_mount;
-        struct xfs_trans        *tp;
-        int                     error;
-
-        if (flags != I_DIRTY_SYNC)
-                return;
-
-        trace_xfs_dirty_inode(ip);
-
-        tp = xfs_trans_alloc(mp, XFS_TRANS_FSYNC_TS);
-        error = xfs_trans_reserve(tp, 0, XFS_FSYNC_TS_LOG_RES(mp), 0, 0, 0);
-        if (error) {
-                xfs_trans_cancel(tp, 0);
-                goto trouble;
-        }
-        xfs_ilock(ip, XFS_ILOCK_EXCL);
-        /*
-         * Grab all the latest timestamps from the Linux inode.
-         */
-        ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
-        ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
-        ip->i_d.di_ctime.t_sec = (__int32_t)inode->i_ctime.tv_sec;
-        ip->i_d.di_ctime.t_nsec = (__int32_t)inode->i_ctime.tv_nsec;
-        ip->i_d.di_mtime.t_sec = (__int32_t)inode->i_mtime.tv_sec;
-        ip->i_d.di_mtime.t_nsec = (__int32_t)inode->i_mtime.tv_nsec;
-
-        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
-        xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP);
-        error = xfs_trans_commit(tp, 0);
-        if (error)
-                goto trouble;
-        return;
-
-trouble:
-        xfs_warn(mp, "failed to update timestamps for inode 0x%llx", ip->i_ino);
-}
-
 STATIC void
 xfs_fs_evict_inode(
         struct inode            *inode)
 {
         xfs_inode_t             *ip = XFS_I(inode);
 
+        ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
+
         trace_xfs_evict_inode(ip);
 
         truncate_inode_pages(&inode->i_data, 0);
@@ -937,22 +884,6 @@ xfs_fs_evict_inode(
         XFS_STATS_INC(vn_remove);
         XFS_STATS_DEC(vn_active);
 
-        /*
-         * The iolock is used by the file system to coordinate reads,
-         * writes, and block truncates.  Up to this point the lock
-         * protected concurrent accesses by users of the inode.  But
-         * from here forward we're doing some final processing of the
-         * inode because we're done with it, and although we reuse the
-         * iolock for protection it is really a distinct lock class
-         * (in the lockdep sense) from before.  To keep lockdep happy
-         * (and basically indicate what we are doing), we explicitly
-         * re-init the iolock here.
-         */
-        ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
-        mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", ip->i_ino);
-        lockdep_set_class_and_name(&ip->i_iolock.mr_lock,
-                        &xfs_iolock_reclaimable, "xfs_iolock_reclaimable");
-
         xfs_inactive(ip);
 }
 
@@ -1436,7 +1367,6 @@ xfs_fs_free_cached_objects(
 static const struct super_operations xfs_super_operations = {
         .alloc_inode            = xfs_fs_alloc_inode,
         .destroy_inode          = xfs_fs_destroy_inode,
-        .dirty_inode            = xfs_fs_dirty_inode,
         .evict_inode            = xfs_fs_evict_inode,
         .drop_inode             = xfs_fs_drop_inode,
         .put_super              = xfs_fs_put_super,
@@ -1491,13 +1421,9 @@ xfs_init_zones(void)
         if (!xfs_da_state_zone)
                 goto out_destroy_btree_cur_zone;
 
-        xfs_dabuf_zone = kmem_zone_init(sizeof(xfs_dabuf_t), "xfs_dabuf");
-        if (!xfs_dabuf_zone)
-                goto out_destroy_da_state_zone;
-
         xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
         if (!xfs_ifork_zone)
-                goto out_destroy_dabuf_zone;
+                goto out_destroy_da_state_zone;
 
         xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
         if (!xfs_trans_zone)
@@ -1514,9 +1440,8 @@ xfs_init_zones(void)
          * size possible under XFS.  This wastes a little bit of memory,
          * but it is much faster.
          */
-        xfs_buf_item_zone = kmem_zone_init((sizeof(xfs_buf_log_item_t) +
-                                (((XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK) /
-                                  NBWORD) * sizeof(int))), "xfs_buf_item");
+        xfs_buf_item_zone = kmem_zone_init(sizeof(struct xfs_buf_log_item),
+                                           "xfs_buf_item");
         if (!xfs_buf_item_zone)
                 goto out_destroy_log_item_desc_zone;
 
@@ -1561,8 +1486,6 @@ xfs_init_zones(void)
         kmem_zone_destroy(xfs_trans_zone);
  out_destroy_ifork_zone:
         kmem_zone_destroy(xfs_ifork_zone);
- out_destroy_dabuf_zone:
-        kmem_zone_destroy(xfs_dabuf_zone);
  out_destroy_da_state_zone:
         kmem_zone_destroy(xfs_da_state_zone);
  out_destroy_btree_cur_zone:
@@ -1590,7 +1513,6 @@ xfs_destroy_zones(void)
         kmem_zone_destroy(xfs_log_item_desc_zone);
         kmem_zone_destroy(xfs_trans_zone);
         kmem_zone_destroy(xfs_ifork_zone);
-        kmem_zone_destroy(xfs_dabuf_zone);
         kmem_zone_destroy(xfs_da_state_zone);
         kmem_zone_destroy(xfs_btree_cur_zone);
         kmem_zone_destroy(xfs_bmap_free_item_zone);