slab bulk alloc/free cleanups
Subsystems (2)
cover slab bulk alloc/free cleanups
This makes SLUB and SLAB use their own kmem_cache_free_bulk() (instead of __kmem_cache_free_bulk()) when kmem_cache_alloc_bulk() failed. And then it moves generic __kmem_cache_{alloc,free}_bulk to SLOB.
This is suggested by Matthew WilCox.
Hyeonggon Yoo (2):
mm/sl[au]b: use own bulk free function when bulk alloc failed mm/slab_common: move generic bulk alloc/free functions to SLOB
mm/slab.c | 2 +- mm/slab.h | 9 --------- mm/slab_common.c | 27 --------------------------- mm/slob.c | 25 +++++++++++++++++++++---- mm/slub.c | 4 ++-- 5 files changed, 24 insertions(+), 43 deletions(-)
Signature · 1 line
2.32.0
PATCH 1/2 mm/sl[au]b: use own bulk free function when bulk alloc failed
There is no benefit to call generic bulk free function when kmem_cache_alloc_bulk() failed. Use own kmem_cache_free_bulk() instead of generic function.
Note that if kmem_cache_alloc_bulk() fails to allocate first object in SLUB, size is zero. So allow passing size == 0 to kmem_cache_free_bulk() like SLAB's.
--- mm/slab.c | 2 +- mm/slub.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
mm/slab.c +1 -1
@@ -3553,7 +3553,7 @@ int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size,local_irq_enable ();cache_alloc_debugcheck_after_bulk (s, flags, i, p, _RET_IP_);slab_post_alloc_hook (s, objcg, flags, i, p, false); -__kmem_cache_free_bulk (s, i, p); +kmem_cache_free_bulk (s, i, p);return 0 ; }EXPORT_SYMBOL (kmem_cache_alloc_bulk);
mm/slub.c +2 -2
@@ -3669,7 +3669,7 @@ int build_detached_freelist(struct kmem_cache *s, size_t size,/* 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 (WARN_ON (!size)) +if (!size)return ;memcg_slab_free_hook (s, p, size);
@@ -3760,7 +3760,7 @@ int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size, error:slub_put_cpu_ptr (s->cpu_slab);slab_post_alloc_hook (s, objcg, flags, i, p, false); -__kmem_cache_free_bulk (s, i, p); +kmem_cache_free_bulk (s, i, p);return 0 ; }EXPORT_SYMBOL (kmem_cache_alloc_bulk);
Signature · 1 line
2.32.0
PATCH 2/2 mm/slab_common: move generic bulk alloc/free functions to SLOB
In reply to Hyeonggon YooNow that only SLOB use __kmem_cache_{alloc,free}_bulk(), move them to SLOB. No functional change intended.
--- mm/slab.h | 9 --------- mm/slab_common.c | 27 --------------------------- mm/slob.c | 25 +++++++++++++++++++++---- 3 files changed, 21 insertions(+), 40 deletions(-)
mm/slab.h +0 -9
@@ -380,15 +380,6 @@ void slabinfo_show_stats(struct seq_file *m, struct kmem_cache *s);ssize_t slabinfo_write (struct file *file,const char __user *buffer,size_t count,loff_t *ppos); -/* -* Generic implementation of bulk operations -* These are useful for situations in which the allocator cannot -* perform optimizations. In that case segments of the object listed -* may be allocated or freed using these operations. -*/ -void __kmem_cache_free_bulk (struct kmem_cache *,size_t ,void **); -int __kmem_cache_alloc_bulk (struct kmem_cache *,gfp_t ,size_t ,void **); -static inline enum node_stat_item cache_vmstat_idx (struct kmem_cache *s) { return (s->flags & SLAB_RECLAIM_ACCOUNT) ?
mm/slab_common.c +0 -27
@@ -105,33 +105,6 @@ static inline int kmem_cache_sanity_check(const char *name, unsigned int size) }#endif -void __kmem_cache_free_bulk (struct kmem_cache *s,size_t nr,void **p) -{ -size_t i; - -for (i =0 ; i < nr; i++) { -if (s) -kmem_cache_free (s, p[i]); -else -kfree (p[i]); - } -} - -int __kmem_cache_alloc_bulk (struct kmem_cache *s,gfp_t flags,size_t nr, -void **p) -{ -size_t i; - -for (i =0 ; i < nr; i++) { -void *x = p[i] =kmem_cache_alloc (s, flags); -if (!x) { -__kmem_cache_free_bulk (s, i, p); -return 0 ; - } - } -return i; -} -/* * Figure out what the alignment of the objects will be given a set of * flags, a user specified alignment and the size of the objects.
mm/slob.c +21 -4
@@ -692,16 +692,33 @@ void kmem_cache_free(struct kmem_cache *c, void *b) }EXPORT_SYMBOL (kmem_cache_free); -void kmem_cache_free_bulk (struct kmem_cache *s,size_t size,void **p) +void kmem_cache_free_bulk (struct kmem_cache *s,size_t nr,void **p) { -__kmem_cache_free_bulk (s, size, p); +size_t i; + +for (i =0 ; i < nr; i++) { +if (s) +kmem_cache_free (s, p[i]); +else +kfree (p[i]); + } }EXPORT_SYMBOL (kmem_cache_free_bulk); -int kmem_cache_alloc_bulk (struct kmem_cache *s,gfp_t flags,size_t size, +int kmem_cache_alloc_bulk (struct kmem_cache *s,gfp_t flags,size_t nr,void **p) { -return __kmem_cache_alloc_bulk (s, flags, size, p); +size_t i; + +for (i =0 ; i < nr; i++) { +void *x = p[i] =kmem_cache_alloc (s, flags); + +if (!x) { +kmem_cache_free_bulk (s, i, p); +return 0 ; + } + } +return i; }EXPORT_SYMBOL (kmem_cache_alloc_bulk);
Signature · 1 line
2.32.0
Vlastimil Babka (SUSE)
maintainerQuoted 9 lines · Hyeonggon Yoo
This makes SLUB and SLAB use their own
kmem_cache_free_bulk()(instead of__kmem_cache_free_bulk()) whenkmem_cache_alloc_bulk()failed. And then it moves generic __kmem_cache_{alloc,free}_bulk to SLOB.This is suggested by Matthew WilCox.
Hyeonggon Yoo (2):
mm/sl[au]b: use own bulk free function when bulk alloc failedmm/slab_common: move generic bulk alloc/free functions to SLOB
Thanks, pushed to slab/for-5.20/bulk_cleanup
Quoted 7 lines
mm/slab.c | 2 +- mm/slab.h | 9 --------- mm/slab_common.c | 27 --------------------------- mm/slob.c | 25 +++++++++++++++++++++---- mm/slub.c | 4 ++-- 5 files changed, 24 insertions(+), 43 deletions(-)