mm, slub: separate detaching of partial list in unfreeze_partials() from unfreezing

Unfreezing partial list can be split to two phases - detaching the list from
struct kmem_cache_cpu, and processing the list. The whole operation does not
need to be protected by disabled irqs. Restructure the code to separate the
detaching (with disabled irqs) and unfreezing (with irq disabling to be reduced
in the next patch).

Also, unfreeze_partials() can be called from another cpu on behalf of a cpu
that is being offlined, where disabling irqs on the local cpu has no sense, so
restructure the code as follows:

- __unfreeze_partials() is the bulk of unfreeze_partials() that processes the
  detached percpu partial list
- unfreeze_partials() detaches list from current cpu with irqs disabled and
  calls __unfreeze_partials()
- unfreeze_partials_cpu() is to be called for the offlined cpu so it needs no
  irq disabling, and is called from __flush_cpu_slab()
- flush_cpu_slab() is for the local cpu thus it needs to call
  unfreeze_partials(). So it can't simply call
  __flush_cpu_slab(smp_processor_id()) anymore and we have to open-code the
  proper calls.

Signed-off-by: Vlastimil Babka <vbabka@suse.cz>

diff --git a/mm/slub.c b/mm/slub.c
index b31e00eb9561e2d67a9dd1983a4ca7c17ae77ed2..9b46d9b9c879994be508ab6530b76450390dfc93 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -2347,25 +2347,15 @@ redo:
        }
 }
 
-/*
- * Unfreeze all the cpu partial slabs.
- *
- * This function must be called with preemption or migration
- * disabled with c local to the cpu.
- */
-static void unfreeze_partials(struct kmem_cache *s,
-               struct kmem_cache_cpu *c)
-{
 #ifdef CONFIG_SLUB_CPU_PARTIAL
+static void __unfreeze_partials(struct kmem_cache *s, struct page *partial_page)
+{
        struct kmem_cache_node *n = NULL, *n2 = NULL;
-       struct page *page, *partial_page, *discard_page = NULL;
+       struct page *page, *discard_page = NULL;
        unsigned long flags;
 
        local_irq_save(flags);
 
-       partial_page = slub_percpu_partial(c);
-       c->partial = NULL;
-
        while (partial_page) {
                struct page new;
                struct page old;
@@ -2420,10 +2410,45 @@ static void unfreeze_partials(struct kmem_cache *s,
                discard_slab(s, page);
                stat(s, FREE_SLAB);
        }
+}
 
-#endif /* CONFIG_SLUB_CPU_PARTIAL */
+/*
+ * Unfreeze all the cpu partial slabs.
+ */
+static void unfreeze_partials(struct kmem_cache *s)
+{
+       struct page *partial_page;
+       unsigned long flags;
+
+       local_irq_save(flags);
+       partial_page = this_cpu_read(s->cpu_slab->partial);
+       this_cpu_write(s->cpu_slab->partial, NULL);
+       local_irq_restore(flags);
+
+       if (partial_page)
+               __unfreeze_partials(s, partial_page);
 }
 
+static void unfreeze_partials_cpu(struct kmem_cache *s,
+                                 struct kmem_cache_cpu *c)
+{
+       struct page *partial_page;
+
+       partial_page = slub_percpu_partial(c);
+       c->partial = NULL;
+
+       if (partial_page)
+               __unfreeze_partials(s, partial_page);
+}
+
+#else  /* CONFIG_SLUB_CPU_PARTIAL */
+
+static inline void unfreeze_partials(struct kmem_cache *s) { }
+static inline void unfreeze_partials_cpu(struct kmem_cache *s,
+                                 struct kmem_cache_cpu *c) { }
+
+#endif /* CONFIG_SLUB_CPU_PARTIAL */
+
 /*
  * Put a page that was just frozen (in __slab_free|get_partial_node) into a
  * partial page slot if available.
@@ -2452,7 +2477,7 @@ static void put_cpu_partial(struct kmem_cache *s, struct page *page, int drain)
                                 * partial array is full. Move the existing
                                 * set to the per node partial list.
                                 */
-                               unfreeze_partials(s, this_cpu_ptr(s->cpu_slab));
+                               unfreeze_partials(s);
                                oldpage = NULL;
                                pobjects = 0;
                                pages = 0;
@@ -2487,11 +2512,6 @@ static inline void flush_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
        stat(s, CPUSLAB_FLUSH);
 }
 
-/*
- * Flush cpu slab.
- *
- * Called from IPI handler with interrupts disabled.
- */
 static inline void __flush_cpu_slab(struct kmem_cache *s, int cpu)
 {
        struct kmem_cache_cpu *c = per_cpu_ptr(s->cpu_slab, cpu);
@@ -2499,14 +2519,23 @@ static inline void __flush_cpu_slab(struct kmem_cache *s, int cpu)
        if (c->page)
                flush_slab(s, c);
 
-       unfreeze_partials(s, c);
+       unfreeze_partials_cpu(s, c);
 }
 
+/*
+ * Flush cpu slab.
+ *
+ * Called from IPI handler with interrupts disabled.
+ */
 static void flush_cpu_slab(void *d)
 {
        struct kmem_cache *s = d;
+       struct kmem_cache_cpu *c = this_cpu_ptr(s->cpu_slab);
 
-       __flush_cpu_slab(s, smp_processor_id());
+       if (c->page)
+               flush_slab(s, c);
+
+       unfreeze_partials(s);
 }
 
 static bool has_cpu_slab(int cpu, void *info)