| Message ID | 871qn1wofe.ffs@tglx (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | mm, slab/slub: Ensure kmem_cache_alloc_bulk() is available early | expand |
On 2/7/23 15:16, Thomas Gleixner wrote: > The memory allocators are available during early boot even in the phase > where interrupts are disabled and scheduling is not yet possible. > > The setup is so that GFP_KERNEL allocations work in this phase without > causing might_alloc() splats to be emitted because the system state is > SYSTEM_BOOTING at that point which prevents the warnings to trigger. > > Most allocation/free functions use local_irq_save()/restore() or a lock > variant of that. But kmem_cache_alloc_bulk() and kmem_cache_free_bulk() use > local_[lock]_irq_disable()/enable(), which leads to a lockdep warning when > interrupts are enabled during the early boot phase. > > This went unnoticed so far as there are no early users of these > interfaces. The upcoming conversion of the interrupt descriptor store from > radix_tree to maple_tree triggered this warning as maple_tree uses the bulk > interface. > > Cure this by moving the kmem_cache_alloc/free() bulk variants of SLUB and > SLAB to local[_lock]_irq_save()/restore(). > > There is obviously no reclaim possible and required at this point so there > is no need to expand this coverage further. > > No functional change. > > Signed-off-by: Thomas Gleixner <tglx@linutronix.de> +Cc rest of slab folks Thanks, added to slab/for-6.3/fixes > --- > Initial version: https://lore.kernel.org/r/87o7qdzfay.ffs@tglx > Changes: Update SLAB as well and add changelog > --- > mm/slab.c | 18 ++++++++++-------- > mm/slub.c | 9 +++++---- > 2 files changed, 15 insertions(+), 12 deletions(-) > > --- a/mm/slab.c > +++ b/mm/slab.c > @@ -3479,14 +3479,15 @@ cache_alloc_debugcheck_after_bulk(struct > int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size, > void **p) > { > - size_t i; > struct obj_cgroup *objcg = NULL; > + unsigned long irqflags; > + size_t i; > > s = slab_pre_alloc_hook(s, NULL, &objcg, size, flags); > if (!s) > return 0; > > - local_irq_disable(); > + local_irq_save(irqflags); > for (i = 0; i < size; i++) { > void *objp = kfence_alloc(s, s->object_size, flags) ?: > __do_cache_alloc(s, flags, NUMA_NO_NODE); > @@ -3495,7 +3496,7 @@ int kmem_cache_alloc_bulk(struct kmem_ca > goto error; > p[i] = objp; > } > - local_irq_enable(); > + local_irq_restore(irqflags); > > cache_alloc_debugcheck_after_bulk(s, flags, size, p, _RET_IP_); > > @@ -3508,7 +3509,7 @@ int kmem_cache_alloc_bulk(struct kmem_ca > /* FIXME: Trace call missing. Christoph would like a bulk variant */ > return size; > error: > - local_irq_enable(); > + local_irq_restore(irqflags); > cache_alloc_debugcheck_after_bulk(s, flags, i, p, _RET_IP_); > slab_post_alloc_hook(s, objcg, flags, i, p, false, s->object_size); > kmem_cache_free_bulk(s, i, p); > @@ -3610,8 +3611,9 @@ EXPORT_SYMBOL(kmem_cache_free); > > void kmem_cache_free_bulk(struct kmem_cache *orig_s, size_t size, void **p) > { > + unsigned long flags; > > - local_irq_disable(); > + local_irq_save(flags); > for (int i = 0; i < size; i++) { > void *objp = p[i]; > struct kmem_cache *s; > @@ -3621,9 +3623,9 @@ void kmem_cache_free_bulk(struct kmem_ca > > /* called via kfree_bulk */ > if (!folio_test_slab(folio)) { > - local_irq_enable(); > + local_irq_restore(flags); > free_large_kmalloc(folio, objp); > - local_irq_disable(); > + local_irq_save(flags); > continue; > } > s = folio_slab(folio)->slab_cache; > @@ -3640,7 +3642,7 @@ void kmem_cache_free_bulk(struct kmem_ca > > __cache_free(s, objp, _RET_IP_); > } > - local_irq_enable(); > + local_irq_restore(flags); > > /* FIXME: add tracing */ > } > --- a/mm/slub.c > +++ b/mm/slub.c > @@ -3913,6 +3913,7 @@ static inline int __kmem_cache_alloc_bul > size_t size, void **p, struct obj_cgroup *objcg) > { > struct kmem_cache_cpu *c; > + unsigned long irqflags; > int i; > > /* > @@ -3921,7 +3922,7 @@ static inline int __kmem_cache_alloc_bul > * handlers invoking normal fastpath. > */ > c = slub_get_cpu_ptr(s->cpu_slab); > - local_lock_irq(&s->cpu_slab->lock); > + local_lock_irqsave(&s->cpu_slab->lock, irqflags); > > for (i = 0; i < size; i++) { > void *object = kfence_alloc(s, s->object_size, flags); > @@ -3942,7 +3943,7 @@ static inline int __kmem_cache_alloc_bul > */ > c->tid = next_tid(c->tid); > > - local_unlock_irq(&s->cpu_slab->lock); > + local_unlock_irqrestore(&s->cpu_slab->lock, irqflags); > > /* > * Invoking slow path likely have side-effect > @@ -3956,7 +3957,7 @@ static inline int __kmem_cache_alloc_bul > c = this_cpu_ptr(s->cpu_slab); > maybe_wipe_obj_freeptr(s, p[i]); > > - local_lock_irq(&s->cpu_slab->lock); > + local_lock_irqsave(&s->cpu_slab->lock, irqflags); > > continue; /* goto for-loop */ > } > @@ -3965,7 +3966,7 @@ static inline int __kmem_cache_alloc_bul > maybe_wipe_obj_freeptr(s, p[i]); > } > c->tid = next_tid(c->tid); > - local_unlock_irq(&s->cpu_slab->lock); > + local_unlock_irqrestore(&s->cpu_slab->lock, irqflags); > slub_put_cpu_ptr(s->cpu_slab); > > return i;
On 2/7/23 15:45, Vlastimil Babka wrote: > On 2/7/23 15:16, Thomas Gleixner wrote: >> The memory allocators are available during early boot even in the phase >> where interrupts are disabled and scheduling is not yet possible. >> >> The setup is so that GFP_KERNEL allocations work in this phase without >> causing might_alloc() splats to be emitted because the system state is >> SYSTEM_BOOTING at that point which prevents the warnings to trigger. >> >> Most allocation/free functions use local_irq_save()/restore() or a lock >> variant of that. But kmem_cache_alloc_bulk() and kmem_cache_free_bulk() use >> local_[lock]_irq_disable()/enable(), which leads to a lockdep warning when >> interrupts are enabled during the early boot phase. >> >> This went unnoticed so far as there are no early users of these >> interfaces. The upcoming conversion of the interrupt descriptor store from >> radix_tree to maple_tree triggered this warning as maple_tree uses the bulk >> interface. >> >> Cure this by moving the kmem_cache_alloc/free() bulk variants of SLUB and >> SLAB to local[_lock]_irq_save()/restore(). >> >> There is obviously no reclaim possible and required at this point so there >> is no need to expand this coverage further. >> >> No functional change. >> >> Signed-off-by: Thomas Gleixner <tglx@linutronix.de> > > +Cc rest of slab folks > > Thanks, added to slab/for-6.3/fixes After your patch, I think it also makes sense to do the following: ----8<---- From 340d7c7b99f3e67780f6dec480ed1d27e6f325eb Mon Sep 17 00:00:00 2001 From: Vlastimil Babka <vbabka@suse.cz> Date: Tue, 7 Feb 2023 15:34:53 +0100 Subject: [PATCH] mm, slab/slub: remove notes that bulk alloc/free needs interrupts enabled The slab functions kmem_cache_[alloc|free]_bulk() have been documented as requiring interrupts to be enabled, since their addition in 2015. It's unclear whether that was a fundamental restriction, or an attempt to save some cpu cycles by not having to save and restore the irq flags. However, it appears that most of the code involved was/became safe to be called with interrupts disabled, and the remaining bits were fixed by commit f244b0182b8e ("mm, slab/slub: Ensure kmem_cache_alloc_bulk() is available early"). While the commit was aimed at early boot scenario, we can now also remove the documented restrictions for any interrupt disabled scenarios. Signed-off-by: Vlastimil Babka <vbabka@suse.cz> --- include/linux/slab.h | 2 -- mm/slub.c | 2 -- 2 files changed, 4 deletions(-) diff --git a/include/linux/slab.h b/include/linux/slab.h index 45af70315a94..ea439b4e2b34 100644 --- a/include/linux/slab.h +++ b/include/linux/slab.h @@ -481,8 +481,6 @@ void kmem_cache_free(struct kmem_cache *s, void *objp); * Bulk allocation and freeing operations. These are accelerated in an * allocator specific way to avoid taking locks repeatedly or building * metadata structures unnecessarily. - * - * Note that interrupts must be enabled when calling these functions. */ void kmem_cache_free_bulk(struct kmem_cache *s, size_t size, void **p); int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size, void **p); diff --git a/mm/slub.c b/mm/slub.c index c16d78698e3f..23b3fb86045d 100644 --- a/mm/slub.c +++ b/mm/slub.c @@ -3889,7 +3889,6 @@ int build_detached_freelist(struct kmem_cache *s, size_t size, return same; } -/* Note that interrupts must be enabled when calling this function. */ void kmem_cache_free_bulk(struct kmem_cache *s, size_t size, void **p) { if (!size) @@ -4009,7 +4008,6 @@ static int __kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, } #endif /* CONFIG_SLUB_TINY */ -/* Note that interrupts must be enabled when calling this function. */ int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size, void **p) {
On Tue, Feb 07 2023 at 15:47, Vlastimil Babka wrote: > From 340d7c7b99f3e67780f6dec480ed1d27e6f325eb Mon Sep 17 00:00:00 2001 > From: Vlastimil Babka <vbabka@suse.cz> > Date: Tue, 7 Feb 2023 15:34:53 +0100 > Subject: [PATCH] mm, slab/slub: remove notes that bulk alloc/free needs > interrupts enabled > > The slab functions kmem_cache_[alloc|free]_bulk() have been documented > as requiring interrupts to be enabled, since their addition in 2015. > It's unclear whether that was a fundamental restriction, or an attempt > to save some cpu cycles by not having to save and restore the irq > flags. I don't think so. The restriction is rather meant to avoid huge allocations in atomic context which causes latencies and also might deplete the atomic reserves. So I rather avoid that and enforce !ATOMIC mode despite the local_irq_save/restore() change which is really only to accomodate with early boot. Thanks, tglx
On 2/7/23 19:20, Thomas Gleixner wrote: > On Tue, Feb 07 2023 at 15:47, Vlastimil Babka wrote: >> From 340d7c7b99f3e67780f6dec480ed1d27e6f325eb Mon Sep 17 00:00:00 2001 >> From: Vlastimil Babka <vbabka@suse.cz> >> Date: Tue, 7 Feb 2023 15:34:53 +0100 >> Subject: [PATCH] mm, slab/slub: remove notes that bulk alloc/free needs >> interrupts enabled >> >> The slab functions kmem_cache_[alloc|free]_bulk() have been documented >> as requiring interrupts to be enabled, since their addition in 2015. >> It's unclear whether that was a fundamental restriction, or an attempt >> to save some cpu cycles by not having to save and restore the irq >> flags. > > I don't think so. The restriction is rather meant to avoid huge > allocations in atomic context which causes latencies and also might > deplete the atomic reserves. Fair enough. > So I rather avoid that and enforce !ATOMIC mode despite the > local_irq_save/restore() change which is really only to accomodate with > early boot. We could add some warning then? People might use the bulk alloc unknowingly again e.g. via maple tree. GFP_KERNEL would warn through the existing warning, but e.g. GFP_ATOMIC currently not. Some maple tree users could use its preallocation instead outside of the atomic context, when possible. > Thanks, > > tglx
On Tue, Feb 07, 2023 at 03:16:53PM +0100, Thomas Gleixner wrote: > The memory allocators are available during early boot even in the phase > where interrupts are disabled and scheduling is not yet possible. > > The setup is so that GFP_KERNEL allocations work in this phase without > causing might_alloc() splats to be emitted because the system state is > SYSTEM_BOOTING at that point which prevents the warnings to trigger. > > Most allocation/free functions use local_irq_save()/restore() or a lock > variant of that. But kmem_cache_alloc_bulk() and kmem_cache_free_bulk() use > local_[lock]_irq_disable()/enable(), which leads to a lockdep warning when > interrupts are enabled during the early boot phase. > > This went unnoticed so far as there are no early users of these > interfaces. The upcoming conversion of the interrupt descriptor store from > radix_tree to maple_tree triggered this warning as maple_tree uses the bulk > interface. > > Cure this by moving the kmem_cache_alloc/free() bulk variants of SLUB and > SLAB to local[_lock]_irq_save()/restore(). > > There is obviously no reclaim possible and required at this point so there > is no need to expand this coverage further. > > No functional change. > > Signed-off-by: Thomas Gleixner <tglx@linutronix.de> > --- > Initial version: https://lore.kernel.org/r/87o7qdzfay.ffs@tglx > Changes: Update SLAB as well and add changelog > --- > mm/slab.c | 18 ++++++++++-------- > mm/slub.c | 9 +++++---- > 2 files changed, 15 insertions(+), 12 deletions(-) > > --- a/mm/slab.c > +++ b/mm/slab.c > @@ -3479,14 +3479,15 @@ cache_alloc_debugcheck_after_bulk(struct > int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size, > void **p) > { > - size_t i; > struct obj_cgroup *objcg = NULL; > + unsigned long irqflags; > + size_t i; > > s = slab_pre_alloc_hook(s, NULL, &objcg, size, flags); > if (!s) > return 0; > > - local_irq_disable(); > + local_irq_save(irqflags); > for (i = 0; i < size; i++) { > void *objp = kfence_alloc(s, s->object_size, flags) ?: > __do_cache_alloc(s, flags, NUMA_NO_NODE); > @@ -3495,7 +3496,7 @@ int kmem_cache_alloc_bulk(struct kmem_ca > goto error; > p[i] = objp; > } > - local_irq_enable(); > + local_irq_restore(irqflags); > > cache_alloc_debugcheck_after_bulk(s, flags, size, p, _RET_IP_); > > @@ -3508,7 +3509,7 @@ int kmem_cache_alloc_bulk(struct kmem_ca > /* FIXME: Trace call missing. Christoph would like a bulk variant */ > return size; > error: > - local_irq_enable(); > + local_irq_restore(irqflags); > cache_alloc_debugcheck_after_bulk(s, flags, i, p, _RET_IP_); > slab_post_alloc_hook(s, objcg, flags, i, p, false, s->object_size); > kmem_cache_free_bulk(s, i, p); > @@ -3610,8 +3611,9 @@ EXPORT_SYMBOL(kmem_cache_free); > > void kmem_cache_free_bulk(struct kmem_cache *orig_s, size_t size, void **p) > { > + unsigned long flags; > > - local_irq_disable(); > + local_irq_save(flags); > for (int i = 0; i < size; i++) { > void *objp = p[i]; > struct kmem_cache *s; > @@ -3621,9 +3623,9 @@ void kmem_cache_free_bulk(struct kmem_ca > > /* called via kfree_bulk */ > if (!folio_test_slab(folio)) { > - local_irq_enable(); > + local_irq_restore(flags); > free_large_kmalloc(folio, objp); > - local_irq_disable(); > + local_irq_save(flags); > continue; > } > s = folio_slab(folio)->slab_cache; > @@ -3640,7 +3642,7 @@ void kmem_cache_free_bulk(struct kmem_ca > > __cache_free(s, objp, _RET_IP_); > } > - local_irq_enable(); > + local_irq_restore(flags); > > /* FIXME: add tracing */ > } > --- a/mm/slub.c > +++ b/mm/slub.c > @@ -3913,6 +3913,7 @@ static inline int __kmem_cache_alloc_bul > size_t size, void **p, struct obj_cgroup *objcg) > { > struct kmem_cache_cpu *c; > + unsigned long irqflags; > int i; > > /* > @@ -3921,7 +3922,7 @@ static inline int __kmem_cache_alloc_bul > * handlers invoking normal fastpath. > */ > c = slub_get_cpu_ptr(s->cpu_slab); > - local_lock_irq(&s->cpu_slab->lock); > + local_lock_irqsave(&s->cpu_slab->lock, irqflags); > > for (i = 0; i < size; i++) { > void *object = kfence_alloc(s, s->object_size, flags); > @@ -3942,7 +3943,7 @@ static inline int __kmem_cache_alloc_bul > */ > c->tid = next_tid(c->tid); > > - local_unlock_irq(&s->cpu_slab->lock); > + local_unlock_irqrestore(&s->cpu_slab->lock, irqflags); > > /* > * Invoking slow path likely have side-effect > @@ -3956,7 +3957,7 @@ static inline int __kmem_cache_alloc_bul > c = this_cpu_ptr(s->cpu_slab); > maybe_wipe_obj_freeptr(s, p[i]); > > - local_lock_irq(&s->cpu_slab->lock); > + local_lock_irqsave(&s->cpu_slab->lock, irqflags); > > continue; /* goto for-loop */ > } > @@ -3965,7 +3966,7 @@ static inline int __kmem_cache_alloc_bul > maybe_wipe_obj_freeptr(s, p[i]); > } > c->tid = next_tid(c->tid); > - local_unlock_irq(&s->cpu_slab->lock); > + local_unlock_irqrestore(&s->cpu_slab->lock, irqflags); Looks good to me. Reviewed-by: Hyeonggon Yoo <42.hyeyoo@gmail.com> Thanks! > slub_put_cpu_ptr(s->cpu_slab); > > return i; >
On Wed, Feb 08 2023 at 10:15, Vlastimil Babka wrote: Cc+ Willy > On 2/7/23 19:20, Thomas Gleixner wrote: >> On Tue, Feb 07 2023 at 15:47, Vlastimil Babka wrote: >>> From 340d7c7b99f3e67780f6dec480ed1d27e6f325eb Mon Sep 17 00:00:00 2001 >>> From: Vlastimil Babka <vbabka@suse.cz> >>> Date: Tue, 7 Feb 2023 15:34:53 +0100 >>> Subject: [PATCH] mm, slab/slub: remove notes that bulk alloc/free needs >>> interrupts enabled >>> >>> The slab functions kmem_cache_[alloc|free]_bulk() have been documented >>> as requiring interrupts to be enabled, since their addition in 2015. >>> It's unclear whether that was a fundamental restriction, or an attempt >>> to save some cpu cycles by not having to save and restore the irq >>> flags. >> >> I don't think so. The restriction is rather meant to avoid huge >> allocations in atomic context which causes latencies and also might >> deplete the atomic reserves. > > Fair enough. > >> So I rather avoid that and enforce !ATOMIC mode despite the >> local_irq_save/restore() change which is really only to accomodate with >> early boot. > > We could add some warning then? People might use the bulk alloc unknowingly > again e.g. via maple tree. GFP_KERNEL would warn through the existing > warning, but e.g. GFP_ATOMIC currently not. Correct. > Some maple tree users could use its preallocation instead outside of the > atomic context, when possible. Right. The issue is that there might be maple_tree users which depend on GFP_ATOMIC, but call in from interrupt enabled context, which is legitimate today. Willy might have some insight on that. Thanks, tglx
On Wed, Feb 08, 2023 at 09:46:30PM +0100, Thomas Gleixner wrote: > On Wed, Feb 08 2023 at 10:15, Vlastimil Babka wrote: > > Cc+ Willy > > > On 2/7/23 19:20, Thomas Gleixner wrote: > >> On Tue, Feb 07 2023 at 15:47, Vlastimil Babka wrote: > >>> From 340d7c7b99f3e67780f6dec480ed1d27e6f325eb Mon Sep 17 00:00:00 2001 > >>> From: Vlastimil Babka <vbabka@suse.cz> > >>> Date: Tue, 7 Feb 2023 15:34:53 +0100 > >>> Subject: [PATCH] mm, slab/slub: remove notes that bulk alloc/free needs > >>> interrupts enabled > >>> > >>> The slab functions kmem_cache_[alloc|free]_bulk() have been documented > >>> as requiring interrupts to be enabled, since their addition in 2015. > >>> It's unclear whether that was a fundamental restriction, or an attempt > >>> to save some cpu cycles by not having to save and restore the irq > >>> flags. > >> > >> I don't think so. The restriction is rather meant to avoid huge > >> allocations in atomic context which causes latencies and also might > >> deplete the atomic reserves. > > > > Fair enough. > > > >> So I rather avoid that and enforce !ATOMIC mode despite the > >> local_irq_save/restore() change which is really only to accomodate with > >> early boot. > > > > We could add some warning then? People might use the bulk alloc unknowingly > > again e.g. via maple tree. GFP_KERNEL would warn through the existing > > warning, but e.g. GFP_ATOMIC currently not. > > Correct. > > > Some maple tree users could use its preallocation instead outside of the > > atomic context, when possible. > > Right. > > The issue is that there might be maple_tree users which depend on > GFP_ATOMIC, but call in from interrupt enabled context, which is > legitimate today. > > Willy might have some insight on that. Not today, but eventually. There are XArray users which modify the tree in interrupt context or under some other spinlock that we can't drop for them in order to do an allocation. And I want to replace the radix tree underpinnings of the XArray with the maple tree. In my copious spare time.
On Thu, Feb 09 2023 at 20:28, Matthew Wilcox wrote: > On Wed, Feb 08, 2023 at 09:46:30PM +0100, Thomas Gleixner wrote: >> The issue is that there might be maple_tree users which depend on >> GFP_ATOMIC, but call in from interrupt enabled context, which is >> legitimate today. >> >> Willy might have some insight on that. > > Not today, but eventually. There are XArray users which modify the tree > in interrupt context or under some other spinlock that we can't drop > for them in order to do an allocation. And I want to replace the radix > tree underpinnings of the XArray with the maple tree. In my copious > spare time. If any usage which you described, i.e. interrupt context or with a spinlock held, where interrupts were disabled on acquisition of the lock, ends up calling into kmem_cache_alloc_bulk() today, then that's broken because kmem_cache_alloc_bulk() reenables interrupts unconditionally. So either such code does not exist as of today or it just gets lucky to not run into the code path leading up to kmem_cache_alloc_bulk(). We have to clarify what the valid calling convention of kmem_cache_alloc_bulk() is in the regular kernel context, i.e. outside of early boot. Thanks, tglx
--- a/mm/slab.c +++ b/mm/slab.c @@ -3479,14 +3479,15 @@ cache_alloc_debugcheck_after_bulk(struct int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size, void **p) { - size_t i; struct obj_cgroup *objcg = NULL; + unsigned long irqflags; + size_t i; s = slab_pre_alloc_hook(s, NULL, &objcg, size, flags); if (!s) return 0; - local_irq_disable(); + local_irq_save(irqflags); for (i = 0; i < size; i++) { void *objp = kfence_alloc(s, s->object_size, flags) ?: __do_cache_alloc(s, flags, NUMA_NO_NODE); @@ -3495,7 +3496,7 @@ int kmem_cache_alloc_bulk(struct kmem_ca goto error; p[i] = objp; } - local_irq_enable(); + local_irq_restore(irqflags); cache_alloc_debugcheck_after_bulk(s, flags, size, p, _RET_IP_); @@ -3508,7 +3509,7 @@ int kmem_cache_alloc_bulk(struct kmem_ca /* FIXME: Trace call missing. Christoph would like a bulk variant */ return size; error: - local_irq_enable(); + local_irq_restore(irqflags); cache_alloc_debugcheck_after_bulk(s, flags, i, p, _RET_IP_); slab_post_alloc_hook(s, objcg, flags, i, p, false, s->object_size); kmem_cache_free_bulk(s, i, p); @@ -3610,8 +3611,9 @@ EXPORT_SYMBOL(kmem_cache_free); void kmem_cache_free_bulk(struct kmem_cache *orig_s, size_t size, void **p) { + unsigned long flags; - local_irq_disable(); + local_irq_save(flags); for (int i = 0; i < size; i++) { void *objp = p[i]; struct kmem_cache *s; @@ -3621,9 +3623,9 @@ void kmem_cache_free_bulk(struct kmem_ca /* called via kfree_bulk */ if (!folio_test_slab(folio)) { - local_irq_enable(); + local_irq_restore(flags); free_large_kmalloc(folio, objp); - local_irq_disable(); + local_irq_save(flags); continue; } s = folio_slab(folio)->slab_cache; @@ -3640,7 +3642,7 @@ void kmem_cache_free_bulk(struct kmem_ca __cache_free(s, objp, _RET_IP_); } - local_irq_enable(); + local_irq_restore(flags); /* FIXME: add tracing */ } --- a/mm/slub.c +++ b/mm/slub.c @@ -3913,6 +3913,7 @@ static inline int __kmem_cache_alloc_bul size_t size, void **p, struct obj_cgroup *objcg) { struct kmem_cache_cpu *c; + unsigned long irqflags; int i; /* @@ -3921,7 +3922,7 @@ static inline int __kmem_cache_alloc_bul * handlers invoking normal fastpath. */ c = slub_get_cpu_ptr(s->cpu_slab); - local_lock_irq(&s->cpu_slab->lock); + local_lock_irqsave(&s->cpu_slab->lock, irqflags); for (i = 0; i < size; i++) { void *object = kfence_alloc(s, s->object_size, flags); @@ -3942,7 +3943,7 @@ static inline int __kmem_cache_alloc_bul */ c->tid = next_tid(c->tid); - local_unlock_irq(&s->cpu_slab->lock); + local_unlock_irqrestore(&s->cpu_slab->lock, irqflags); /* * Invoking slow path likely have side-effect @@ -3956,7 +3957,7 @@ static inline int __kmem_cache_alloc_bul c = this_cpu_ptr(s->cpu_slab); maybe_wipe_obj_freeptr(s, p[i]); - local_lock_irq(&s->cpu_slab->lock); + local_lock_irqsave(&s->cpu_slab->lock, irqflags); continue; /* goto for-loop */ } @@ -3965,7 +3966,7 @@ static inline int __kmem_cache_alloc_bul maybe_wipe_obj_freeptr(s, p[i]); } c->tid = next_tid(c->tid); - local_unlock_irq(&s->cpu_slab->lock); + local_unlock_irqrestore(&s->cpu_slab->lock, irqflags); slub_put_cpu_ptr(s->cpu_slab); return i;
The memory allocators are available during early boot even in the phase where interrupts are disabled and scheduling is not yet possible. The setup is so that GFP_KERNEL allocations work in this phase without causing might_alloc() splats to be emitted because the system state is SYSTEM_BOOTING at that point which prevents the warnings to trigger. Most allocation/free functions use local_irq_save()/restore() or a lock variant of that. But kmem_cache_alloc_bulk() and kmem_cache_free_bulk() use local_[lock]_irq_disable()/enable(), which leads to a lockdep warning when interrupts are enabled during the early boot phase. This went unnoticed so far as there are no early users of these interfaces. The upcoming conversion of the interrupt descriptor store from radix_tree to maple_tree triggered this warning as maple_tree uses the bulk interface. Cure this by moving the kmem_cache_alloc/free() bulk variants of SLUB and SLAB to local[_lock]_irq_save()/restore(). There is obviously no reclaim possible and required at this point so there is no need to expand this coverage further. No functional change. Signed-off-by: Thomas Gleixner <tglx@linutronix.de> --- Initial version: https://lore.kernel.org/r/87o7qdzfay.ffs@tglx Changes: Update SLAB as well and add changelog --- mm/slab.c | 18 ++++++++++-------- mm/slub.c | 9 +++++---- 2 files changed, 15 insertions(+), 12 deletions(-)