slab: handle pfmemalloc slabs properly with sheaves

When a pfmemalloc allocation actually dips into reserves, the slab is
marked accordingly and non-pfmemalloc allocations should not be allowed
to allocate from it. The sheaves percpu caching currently doesn't follow
this rule, so implement it before we expand sheaves usage to all caches.

Make sure objects from pfmemalloc slabs don't end up in percpu sheaves.
When freeing, skip sheaves when freeing an object from pfmemalloc slab.
When refilling sheaves, use __GFP_NOMEMALLOC to override any pfmemalloc
context - the allocation will fallback to regular slab allocations when
sheaves are depleted and can't be refilled because of the override.

For kfree_rcu(), detect pfmemalloc slabs after processing the rcu_sheaf
after the grace period in __rcu_free_sheaf_prepare() and simply flush
it if any object is from pfmemalloc slabs.

For prefilled sheaves, try to refill them first with __GFP_NOMEMALLOC
and if it fails, retry without __GFP_NOMEMALLOC but then mark the sheaf
pfmemalloc, which makes it flushed back to slabs when returned.

Link: https://patch.msgid.link/20251105-sheaves-cleanups-v1-3-b8218e1ac7ef@suse.cz
Reviewed-by: Harry Yoo <harry.yoo@oracle.com>
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>

diff --git a/mm/slub.c b/mm/slub.c
index 0237a329d4e5639bc6bdcbe3b63ed09f0acd9b9a..bb744e8044f0bd3eb523bf3d55c0d509d04a65f8 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -469,7 +469,10 @@ struct slab_sheaf {
                struct rcu_head rcu_head;
                struct list_head barn_list;
                /* only used for prefilled sheafs */
-               unsigned int capacity;
+               struct {
+                       unsigned int capacity;
+                       bool pfmemalloc;
+               };
        };
        struct kmem_cache *cache;
        unsigned int size;
@@ -2651,7 +2654,7 @@ static struct slab_sheaf *alloc_full_sheaf(struct kmem_cache *s, gfp_t gfp)
        if (!sheaf)
                return NULL;
 
-       if (refill_sheaf(s, sheaf, gfp)) {
+       if (refill_sheaf(s, sheaf, gfp | __GFP_NOMEMALLOC)) {
                free_empty_sheaf(s, sheaf);
                return NULL;
        }
@@ -2729,12 +2732,13 @@ static void sheaf_flush_unused(struct kmem_cache *s, struct slab_sheaf *sheaf)
        sheaf->size = 0;
 }
 
-static void __rcu_free_sheaf_prepare(struct kmem_cache *s,
+static bool __rcu_free_sheaf_prepare(struct kmem_cache *s,
                                     struct slab_sheaf *sheaf)
 {
        bool init = slab_want_init_on_free(s);
        void **p = &sheaf->objects[0];
        unsigned int i = 0;
+       bool pfmemalloc = false;
 
        while (i < sheaf->size) {
                struct slab *slab = virt_to_slab(p[i]);
@@ -2747,8 +2751,13 @@ static void __rcu_free_sheaf_prepare(struct kmem_cache *s,
                        continue;
                }
 
+               if (slab_test_pfmemalloc(slab))
+                       pfmemalloc = true;
+
                i++;
        }
+
+       return pfmemalloc;
 }
 
 static void rcu_free_sheaf_nobarn(struct rcu_head *head)
@@ -5041,7 +5050,7 @@ __pcs_replace_empty_main(struct kmem_cache *s, struct slub_percpu_sheaves *pcs,
                return NULL;
 
        if (empty) {
-               if (!refill_sheaf(s, empty, gfp)) {
+               if (!refill_sheaf(s, empty, gfp | __GFP_NOMEMALLOC)) {
                        full = empty;
                } else {
                        /*
@@ -5341,6 +5350,26 @@ void *kmem_cache_alloc_node_noprof(struct kmem_cache *s, gfp_t gfpflags, int nod
 }
 EXPORT_SYMBOL(kmem_cache_alloc_node_noprof);
 
+static int __prefill_sheaf_pfmemalloc(struct kmem_cache *s,
+                                     struct slab_sheaf *sheaf, gfp_t gfp)
+{
+       int ret = 0;
+
+       ret = refill_sheaf(s, sheaf, gfp | __GFP_NOMEMALLOC);
+
+       if (likely(!ret || !gfp_pfmemalloc_allowed(gfp)))
+               return ret;
+
+       /*
+        * if we are allowed to, refill sheaf with pfmemalloc but then remember
+        * it for when it's returned
+        */
+       ret = refill_sheaf(s, sheaf, gfp);
+       sheaf->pfmemalloc = true;
+
+       return ret;
+}
+
 /*
  * returns a sheaf that has at least the requested size
  * when prefilling is needed, do so with given gfp flags
@@ -5375,6 +5404,10 @@ kmem_cache_prefill_sheaf(struct kmem_cache *s, gfp_t gfp, unsigned int size)
                sheaf->cache = s;
                sheaf->capacity = size;
 
+               /*
+                * we do not need to care about pfmemalloc here because oversize
+                * sheaves area always flushed and freed when returned
+                */
                if (!__kmem_cache_alloc_bulk(s, gfp, size,
                                             &sheaf->objects[0])) {
                        kfree(sheaf);
@@ -5411,17 +5444,18 @@ kmem_cache_prefill_sheaf(struct kmem_cache *s, gfp_t gfp, unsigned int size)
        if (!sheaf)
                sheaf = alloc_empty_sheaf(s, gfp);
 
-       if (sheaf && sheaf->size < size) {
-               if (refill_sheaf(s, sheaf, gfp)) {
+       if (sheaf) {
+               sheaf->capacity = s->sheaf_capacity;
+               sheaf->pfmemalloc = false;
+
+               if (sheaf->size < size &&
+                   __prefill_sheaf_pfmemalloc(s, sheaf, gfp)) {
                        sheaf_flush_unused(s, sheaf);
                        free_empty_sheaf(s, sheaf);
                        sheaf = NULL;
                }
        }
 
-       if (sheaf)
-               sheaf->capacity = s->sheaf_capacity;
-
        return sheaf;
 }
 
@@ -5441,7 +5475,8 @@ void kmem_cache_return_sheaf(struct kmem_cache *s, gfp_t gfp,
        struct slub_percpu_sheaves *pcs;
        struct node_barn *barn;
 
-       if (unlikely(sheaf->capacity != s->sheaf_capacity)) {
+       if (unlikely((sheaf->capacity != s->sheaf_capacity)
+                    || sheaf->pfmemalloc)) {
                sheaf_flush_unused(s, sheaf);
                kfree(sheaf);
                return;
@@ -5507,7 +5542,7 @@ int kmem_cache_refill_sheaf(struct kmem_cache *s, gfp_t gfp,
 
        if (likely(sheaf->capacity >= size)) {
                if (likely(sheaf->capacity == s->sheaf_capacity))
-                       return refill_sheaf(s, sheaf, gfp);
+                       return __prefill_sheaf_pfmemalloc(s, sheaf, gfp);
 
                if (!__kmem_cache_alloc_bulk(s, gfp, sheaf->capacity - sheaf->size,
                                             &sheaf->objects[sheaf->size])) {
@@ -6215,8 +6250,12 @@ static void rcu_free_sheaf(struct rcu_head *head)
         * handles it fine. The only downside is that sheaf will serve fewer
         * allocations when reused. It only happens due to debugging, which is a
         * performance hit anyway.
+        *
+        * If it returns true, there was at least one object from pfmemalloc
+        * slab so simply flush everything.
         */
-       __rcu_free_sheaf_prepare(s, sheaf);
+       if (__rcu_free_sheaf_prepare(s, sheaf))
+               goto flush;
 
        n = get_node(s, sheaf->node);
        if (!n)
@@ -6371,7 +6410,8 @@ next_remote_batch:
                        continue;
                }
 
-               if (unlikely(IS_ENABLED(CONFIG_NUMA) && slab_nid(slab) != node)) {
+               if (unlikely((IS_ENABLED(CONFIG_NUMA) && slab_nid(slab) != node)
+                            || slab_test_pfmemalloc(slab))) {
                        remote_objects[remote_nr] = p[i];
                        p[i] = p[--size];
                        if (++remote_nr >= PCS_BATCH_MAX)
@@ -6669,7 +6709,8 @@ void slab_free(struct kmem_cache *s, struct slab *slab, void *object,
                return;
 
        if (s->cpu_sheaves && likely(!IS_ENABLED(CONFIG_NUMA) ||
-                                    slab_nid(slab) == numa_mem_id())) {
+                                    slab_nid(slab) == numa_mem_id())
+                          && likely(!slab_test_pfmemalloc(slab))) {
                if (likely(free_to_pcs(s, object)))
                        return;
        }