[XFS] Improve buffered read throughput by removing unnecessary timer calls

[mv-sheeva.git] / fs / xfs / linux-2.6 / xfs_iops.c

diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 77708a8c9f87b78afc74125879071a2617493e88..68c83ec31143fdaba0b9575de4df6b6da0237af3 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -69,6 +69,137 @@
 #include <linux/xattr.h>
 #include <linux/namei.h>
 
+/*
+ * Change the requested timestamp in the given inode.
+ * We don't lock across timestamp updates, and we don't log them but
+ * we do record the fact that there is dirty information in core.
+ *
+ * NOTE -- callers MUST combine XFS_ICHGTIME_MOD or XFS_ICHGTIME_CHG
+ *             with XFS_ICHGTIME_ACC to be sure that access time
+ *             update will take.  Calling first with XFS_ICHGTIME_ACC
+ *             and then XFS_ICHGTIME_MOD may fail to modify the access
+ *             timestamp if the filesystem is mounted noacctm.
+ */
+void
+xfs_ichgtime(
+       xfs_inode_t     *ip,
+       int             flags)
+{
+       struct inode    *inode = LINVFS_GET_IP(XFS_ITOV(ip));
+       timespec_t      tv;
+
+       /*
+        * We're not supposed to change timestamps in readonly-mounted
+        * filesystems.  Throw it away if anyone asks us.
+        */
+       if (unlikely(IS_RDONLY(inode)))
+               return;
+
+       /*
+        * Don't update access timestamps on reads if mounted "noatime".
+        * Throw it away if anyone asks us.
+        */
+       if (unlikely(
+           (ip->i_mount->m_flags & XFS_MOUNT_NOATIME || IS_NOATIME(inode)) &&
+           (flags & (XFS_ICHGTIME_ACC|XFS_ICHGTIME_MOD|XFS_ICHGTIME_CHG)) ==
+                       XFS_ICHGTIME_ACC))
+               return;
+
+       nanotime(&tv);
+       if (flags & XFS_ICHGTIME_MOD) {
+               inode->i_mtime = tv;
+               ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
+               ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
+       }
+       if (flags & XFS_ICHGTIME_ACC) {
+               inode->i_atime = tv;
+               ip->i_d.di_atime.t_sec = (__int32_t)tv.tv_sec;
+               ip->i_d.di_atime.t_nsec = (__int32_t)tv.tv_nsec;
+       }
+       if (flags & XFS_ICHGTIME_CHG) {
+               inode->i_ctime = tv;
+               ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
+               ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
+       }
+
+       /*
+        * We update the i_update_core field _after_ changing
+        * the timestamps in order to coordinate properly with
+        * xfs_iflush() so that we don't lose timestamp updates.
+        * This keeps us from having to hold the inode lock
+        * while doing this.  We use the SYNCHRONIZE macro to
+        * ensure that the compiler does not reorder the update
+        * of i_update_core above the timestamp updates above.
+        */
+       SYNCHRONIZE();
+       ip->i_update_core = 1;
+       if (!(inode->i_state & I_LOCK))
+               mark_inode_dirty_sync(inode);
+}
+
+/*
+ * Variant on the above which avoids querying the system clock
+ * in situations where we know the Linux inode timestamps have
+ * just been updated (and so we can update our inode cheaply).
+ * We also skip the readonly and noatime checks here, they are
+ * also catered for already.
+ */
+void
+xfs_ichgtime_fast(
+       xfs_inode_t     *ip,
+       struct inode    *inode,
+       int             flags)
+{
+       timespec_t      *tvp;
+
+       /*
+        * We're not supposed to change timestamps in readonly-mounted
+        * filesystems.  Throw it away if anyone asks us.
+        */
+       if (unlikely(IS_RDONLY(inode)))
+               return;
+
+       /*
+        * Don't update access timestamps on reads if mounted "noatime".
+        * Throw it away if anyone asks us.
+        */
+       if (unlikely(
+           (ip->i_mount->m_flags & XFS_MOUNT_NOATIME || IS_NOATIME(inode)) &&
+           ((flags & (XFS_ICHGTIME_ACC|XFS_ICHGTIME_MOD|XFS_ICHGTIME_CHG)) ==
+                       XFS_ICHGTIME_ACC)))
+               return;
+
+       if (flags & XFS_ICHGTIME_MOD) {
+               tvp = &inode->i_mtime;
+               ip->i_d.di_mtime.t_sec = (__int32_t)tvp->tv_sec;
+               ip->i_d.di_mtime.t_nsec = (__int32_t)tvp->tv_nsec;
+       }
+       if (flags & XFS_ICHGTIME_ACC) {
+               tvp = &inode->i_atime;
+               ip->i_d.di_atime.t_sec = (__int32_t)tvp->tv_sec;
+               ip->i_d.di_atime.t_nsec = (__int32_t)tvp->tv_nsec;
+       }
+       if (flags & XFS_ICHGTIME_CHG) {
+               tvp = &inode->i_ctime;
+               ip->i_d.di_ctime.t_sec = (__int32_t)tvp->tv_sec;
+               ip->i_d.di_ctime.t_nsec = (__int32_t)tvp->tv_nsec;
+       }
+
+       /*
+        * We update the i_update_core field _after_ changing
+        * the timestamps in order to coordinate properly with
+        * xfs_iflush() so that we don't lose timestamp updates.
+        * This keeps us from having to hold the inode lock
+        * while doing this.  We use the SYNCHRONIZE macro to
+        * ensure that the compiler does not reorder the update
+        * of i_update_core above the timestamp updates above.
+        */
+       SYNCHRONIZE();
+       ip->i_update_core = 1;
+       if (!(inode->i_state & I_LOCK))
+               mark_inode_dirty_sync(inode);
+}
+
 
 /*
  * Pull the link count and size up from the xfs inode to the linux inode