Merge branch 'xfs-4.7-inode-reclaim' into for-next

4 files changed, 250 insertions, 199 deletions

diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c
index d3d1477bfb9e..bbcc8c7a44b3 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.c
+++ b/fs/xfs/libxfs/xfs_inode_fork.c
@@ -1519,6 +1519,24 @@ xfs_iext_indirect_to_direct(
 }
 
 /*
+ * Remove all records from the indirection array.
+ */
+STATIC void
+xfs_iext_irec_remove_all(
+        struct xfs_ifork *ifp)
+{
+        int             nlists;
+        int             i;
+
+        ASSERT(ifp->if_flags & XFS_IFEXTIREC);
+        nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
+        for (i = 0; i < nlists; i++)
+                kmem_free(ifp->if_u1.if_ext_irec[i].er_extbuf);
+        kmem_free(ifp->if_u1.if_ext_irec);
+        ifp->if_flags &= ~XFS_IFEXTIREC;
+}
+
+/*
  * Free incore file extents.
  */
 void
@@ -1526,14 +1544,7 @@ xfs_iext_destroy(
         xfs_ifork_t     *ifp)           /* inode fork pointer */
 {
         if (ifp->if_flags & XFS_IFEXTIREC) {
-                int     erp_idx;
-                int     nlists;
-
-                nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
-                for (erp_idx = nlists - 1; erp_idx >= 0 ; erp_idx--) {
-                        xfs_iext_irec_remove(ifp, erp_idx);
-                }
-                ifp->if_flags &= ~XFS_IFEXTIREC;
+                xfs_iext_irec_remove_all(ifp);
         } else if (ifp->if_real_bytes) {
                 kmem_free(ifp->if_u1.if_extents);
         } else if (ifp->if_bytes) {
diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index bf2d60749278..99ee6eee5e0b 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -37,9 +37,6 @@
 #include <linux/kthread.h>
 #include <linux/freezer.h>
 
-STATIC void __xfs_inode_clear_reclaim_tag(struct xfs_mount *mp,
-                                struct xfs_perag *pag, struct xfs_inode *ip);
-
 /*
  * Allocate and initialise an xfs_inode.
  */
@@ -94,13 +91,6 @@ xfs_inode_free_callback(
         struct inode            *inode = container_of(head, struct inode, i_rcu);
         struct xfs_inode        *ip = XFS_I(inode);
 
-        kmem_zone_free(xfs_inode_zone, ip);
-}
-
-void
-xfs_inode_free(
-        struct xfs_inode        *ip)
-{
         switch (VFS_I(ip)->i_mode & S_IFMT) {
         case S_IFREG:
         case S_IFDIR:
@@ -118,6 +108,25 @@ xfs_inode_free(
                 ip->i_itemp = NULL;
         }
 
+        kmem_zone_free(xfs_inode_zone, ip);
+}
+
+static void
+__xfs_inode_free(
+        struct xfs_inode        *ip)
+{
+        /* asserts to verify all state is correct here */
+        ASSERT(atomic_read(&ip->i_pincount) == 0);
+        ASSERT(!xfs_isiflocked(ip));
+        XFS_STATS_DEC(ip->i_mount, vn_active);
+
+        call_rcu(&VFS_I(ip)->i_rcu, xfs_inode_free_callback);
+}
+
+void
+xfs_inode_free(
+        struct xfs_inode        *ip)
+{
         /*
          * Because we use RCU freeing we need to ensure the inode always
          * appears to be reclaimed with an invalid inode number when in the
@@ -129,12 +138,123 @@ xfs_inode_free(
         ip->i_ino = 0;
         spin_unlock(&ip->i_flags_lock);
 
-        /* asserts to verify all state is correct here */
-        ASSERT(atomic_read(&ip->i_pincount) == 0);
-        ASSERT(!xfs_isiflocked(ip));
-        XFS_STATS_DEC(ip->i_mount, vn_active);
+        __xfs_inode_free(ip);
+}
 
-        call_rcu(&VFS_I(ip)->i_rcu, xfs_inode_free_callback);
+/*
+ * Queue a new inode reclaim pass if there are reclaimable inodes and there
+ * isn't a reclaim pass already in progress. By default it runs every 5s based
+ * on the xfs periodic sync default of 30s. Perhaps this should have it's own
+ * tunable, but that can be done if this method proves to be ineffective or too
+ * aggressive.
+ */
+static void
+xfs_reclaim_work_queue(
+        struct xfs_mount        *mp)
+{
+
+        rcu_read_lock();
+        if (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_RECLAIM_TAG)) {
+                queue_delayed_work(mp->m_reclaim_workqueue, &mp->m_reclaim_work,
+                        msecs_to_jiffies(xfs_syncd_centisecs / 6 * 10));
+        }
+        rcu_read_unlock();
+}
+
+/*
+ * This is a fast pass over the inode cache to try to get reclaim moving on as
+ * many inodes as possible in a short period of time. It kicks itself every few
+ * seconds, as well as being kicked by the inode cache shrinker when memory
+ * goes low. It scans as quickly as possible avoiding locked inodes or those
+ * already being flushed, and once done schedules a future pass.
+ */
+void
+xfs_reclaim_worker(
+        struct work_struct *work)
+{
+        struct xfs_mount *mp = container_of(to_delayed_work(work),
+                                        struct xfs_mount, m_reclaim_work);
+
+        xfs_reclaim_inodes(mp, SYNC_TRYLOCK);
+        xfs_reclaim_work_queue(mp);
+}
+
+static void
+xfs_perag_set_reclaim_tag(
+        struct xfs_perag        *pag)
+{
+        struct xfs_mount        *mp = pag->pag_mount;
+
+        ASSERT(spin_is_locked(&pag->pag_ici_lock));
+        if (pag->pag_ici_reclaimable++)
+                return;
+
+        /* propagate the reclaim tag up into the perag radix tree */
+        spin_lock(&mp->m_perag_lock);
+        radix_tree_tag_set(&mp->m_perag_tree, pag->pag_agno,
+                           XFS_ICI_RECLAIM_TAG);
+        spin_unlock(&mp->m_perag_lock);
+
+        /* schedule periodic background inode reclaim */
+        xfs_reclaim_work_queue(mp);
+
+        trace_xfs_perag_set_reclaim(mp, pag->pag_agno, -1, _RET_IP_);
+}
+
+static void
+xfs_perag_clear_reclaim_tag(
+        struct xfs_perag        *pag)
+{
+        struct xfs_mount        *mp = pag->pag_mount;
+
+        ASSERT(spin_is_locked(&pag->pag_ici_lock));
+        if (--pag->pag_ici_reclaimable)
+                return;
+
+        /* clear the reclaim tag from the perag radix tree */
+        spin_lock(&mp->m_perag_lock);
+        radix_tree_tag_clear(&mp->m_perag_tree, pag->pag_agno,
+                             XFS_ICI_RECLAIM_TAG);
+        spin_unlock(&mp->m_perag_lock);
+        trace_xfs_perag_clear_reclaim(mp, pag->pag_agno, -1, _RET_IP_);
+}
+
+
+/*
+ * We set the inode flag atomically with the radix tree tag.
+ * Once we get tag lookups on the radix tree, this inode flag
+ * can go away.
+ */
+void
+xfs_inode_set_reclaim_tag(
+        struct xfs_inode        *ip)
+{
+        struct xfs_mount        *mp = ip->i_mount;
+        struct xfs_perag        *pag;
+
+        pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));