Merge branch 'for-next' of git://git.samba.org/sfrench/cifs-2.6

[karo-tx-linux.git] / mm / list_lru.c

diff --git a/mm/list_lru.c b/mm/list_lru.c
index 1efe4ecc02b1f6d14738a3dc7e6ea2e9255f540b..72467914b85640bb88730cb4a5c54113e531b35a 100644 (file)
--- a/mm/list_lru.c
+++ b/mm/list_lru.c
@@ -8,6 +8,7 @@
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/list_lru.h>
+#include <linux/slab.h>
 
 bool list_lru_add(struct list_lru *lru, struct list_head *item)
 {
@@ -47,25 +48,22 @@ bool list_lru_del(struct list_lru *lru, struct list_head *item)
 }
 EXPORT_SYMBOL_GPL(list_lru_del);
 
-unsigned long list_lru_count(struct list_lru *lru)
+unsigned long
+list_lru_count_node(struct list_lru *lru, int nid)
 {
        unsigned long count = 0;
-       int nid;
-
-       for_each_node_mask(nid, lru->active_nodes) {
-               struct list_lru_node *nlru = &lru->node[nid];
+       struct list_lru_node *nlru = &lru->node[nid];
 
-               spin_lock(&nlru->lock);
-               WARN_ON_ONCE(nlru->nr_items < 0);
-               count += nlru->nr_items;
-               spin_unlock(&nlru->lock);
-       }
+       spin_lock(&nlru->lock);
+       WARN_ON_ONCE(nlru->nr_items < 0);
+       count += nlru->nr_items;
+       spin_unlock(&nlru->lock);
 
        return count;
 }
-EXPORT_SYMBOL_GPL(list_lru_count);
+EXPORT_SYMBOL_GPL(list_lru_count_node);
 
-static unsigned long
+unsigned long
 list_lru_walk_node(struct list_lru *lru, int nid, list_lru_walk_cb isolate,
                   void *cb_arg, unsigned long *nr_to_walk)
 {
@@ -73,19 +71,19 @@ list_lru_walk_node(struct list_lru *lru, int nid, list_lru_walk_cb isolate,
        struct list_lru_node    *nlru = &lru->node[nid];
        struct list_head *item, *n;
        unsigned long isolated = 0;
-       /*
-        * If we don't keep state of at which pass we are, we can loop at
-        * LRU_RETRY, since we have no guarantees that the caller will be able
-        * to do something other than retry on the next pass. We handle this by
-        * allowing at most one retry per object. This should not be altered
-        * by any condition other than LRU_RETRY.
-        */
-       bool first_pass = true;
 
        spin_lock(&nlru->lock);
 restart:
        list_for_each_safe(item, n, &nlru->list) {
                enum lru_status ret;
+
+               /*
+                * decrement nr_to_walk first so that we don't livelock if we
+                * get stuck on large numbesr of LRU_RETRY items
+                */
+               if (--(*nr_to_walk) == 0)
+                       break;
+
                ret = isolate(item, &nlru->lock, cb_arg);
                switch (ret) {
                case LRU_REMOVED:
@@ -100,19 +98,14 @@ restart:
                case LRU_SKIP:
                        break;
                case LRU_RETRY:
-                       if (!first_pass) {
-                               first_pass = true;
-                               break;
-                       }
-                       first_pass = false;
+                       /*
+                        * The lru lock has been dropped, our list traversal is
+                        * now invalid and so we have to restart from scratch.
+                        */
                        goto restart;
                default:
                        BUG();
                }
-
-               if ((*nr_to_walk)-- == 0)
-                       break;
-
        }
 
        spin_unlock(&nlru->lock);
@@ -120,70 +113,17 @@ restart:
 }
 EXPORT_SYMBOL_GPL(list_lru_walk_node);
 
-unsigned long list_lru_walk(struct list_lru *lru, list_lru_walk_cb isolate,
-                           void *cb_arg, unsigned long nr_to_walk)
-{
-       unsigned long isolated = 0;
-       int nid;
-
-       for_each_node_mask(nid, lru->active_nodes) {
-               isolated += list_lru_walk_node(lru, nid, isolate,
-                                              cb_arg, &nr_to_walk);
-               if (nr_to_walk <= 0)
-                       break;
-       }
-       return isolated;
-}
-EXPORT_SYMBOL_GPL(list_lru_walk);
-
-static unsigned long list_lru_dispose_all_node(struct list_lru *lru, int nid,
-                                              list_lru_dispose_cb dispose)
-{
-       struct list_lru_node    *nlru = &lru->node[nid];
-       LIST_HEAD(dispose_list);
-       unsigned long disposed = 0;
-
-       spin_lock(&nlru->lock);
-       while (!list_empty(&nlru->list)) {
-               list_splice_init(&nlru->list, &dispose_list);
-               disposed += nlru->nr_items;
-               nlru->nr_items = 0;
-               node_clear(nid, lru->active_nodes);
-               spin_unlock(&nlru->lock);
-
-               dispose(&dispose_list);
-
-               spin_lock(&nlru->lock);
-       }
-       spin_unlock(&nlru->lock);
-       return disposed;
-}
-
-unsigned long list_lru_dispose_all(struct list_lru *lru,
-                                  list_lru_dispose_cb dispose)
-{
-       unsigned long disposed;
-       unsigned long total = 0;
-       int nid;
-
-       do {
-               disposed = 0;
-               for_each_node_mask(nid, lru->active_nodes) {
-                       disposed += list_lru_dispose_all_node(lru, nid,
-                                                             dispose);
-               }
-               total += disposed;
-       } while (disposed != 0);
-
-       return total;
-}
-
 int list_lru_init(struct list_lru *lru)
 {
        int i;
+       size_t size = sizeof(*lru->node) * nr_node_ids;
+
+       lru->node = kzalloc(size, GFP_KERNEL);
+       if (!lru->node)
+               return -ENOMEM;
 
        nodes_clear(lru->active_nodes);
-       for (i = 0; i < MAX_NUMNODES; i++) {
+       for (i = 0; i < nr_node_ids; i++) {
                spin_lock_init(&lru->node[i].lock);
                INIT_LIST_HEAD(&lru->node[i].list);
                lru->node[i].nr_items = 0;
@@ -191,3 +131,9 @@ int list_lru_init(struct list_lru *lru)
        return 0;
 }
 EXPORT_SYMBOL_GPL(list_lru_init);
+
+void list_lru_destroy(struct list_lru *lru)
+{
+       kfree(lru->node);
+}
+EXPORT_SYMBOL_GPL(list_lru_destroy);