Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-10 06:01:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

slab: add struct kmem_cache_args

Browse Source 
Currently we have multiple kmem_cache_create*() variants that take up to
seven separate parameters with one of the functions having to grow an
eigth parameter in the future to handle both usercopy and a custom
freelist pointer.

Add a struct kmem_cache_args structure and move less common parameters
into it. Core parameters such as name, object size, and flags continue
to be passed separately.

Add a new function __kmem_cache_create_args() that takes a struct
kmem_cache_args pointer and port do_kmem_cache_create_usercopy() over to
it.

In follow-up patches we will port the other kmem_cache_create*()
variants over to it as well.

Reviewed-by: Kees Cook <kees@kernel.org>
Reviewed-by: Jens Axboe <axboe@kernel.dk>
Reviewed-by: Mike Rapoport (Microsoft) <rppt@kernel.org>
Reviewed-by: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: Christian Brauner <brauner@kernel.org>
Reviewed-by: Roman Gushchin <roman.gushchin@linux.dev>
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
This commit is contained in:
Christian Brauner 2024-09-05 09:56:45 +02:00 committed by Vlastimil Babka
parent 53d3d21086
commit 879fb3c274
2 changed files with 72 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/linux/slab.h
View File

@ -240,6 +240,28 @@ struct mem_cgroup;
*/
bool slab_is_available(void);
/**
* struct kmem_cache_args - Less common arguments for kmem_cache_create()
* @align: The required alignment for the objects.
* @useroffset: Usercopy region offset
* @usersize: Usercopy region size
* @freeptr_offset: Custom offset for the free pointer in RCU caches
* @use_freeptr_offset: Whether a @freeptr_offset is used
* @ctor: A constructor for the objects.
*/
struct kmem_cache_args {
unsigned int align;
unsigned int useroffset;
unsigned int usersize;
unsigned int freeptr_offset;
bool use_freeptr_offset;
void (*ctor)(void *);
};
struct kmem_cache *__kmem_cache_create_args(const char *name,
unsigned int object_size,
struct kmem_cache_args *args,
slab_flags_t flags);
struct kmem_cache *kmem_cache_create(const char *name, unsigned int size,
unsigned int align, slab_flags_t flags,
void (*ctor)(void *));

65
mm/slab_common.c
View File

@ -248,14 +248,24 @@ out:
return ERR_PTR(err);
}
static struct kmem_cache *
do_kmem_cache_create_usercopy(const char *name,
unsigned int size, unsigned int freeptr_offset,
unsigned int align, slab_flags_t flags,
unsigned int useroffset, unsigned int usersize,
void (*ctor)(void *))
/**
* __kmem_cache_create_args - Create a kmem cache
* @name: A string which is used in /proc/slabinfo to identify this cache.
* @object_size: The size of objects to be created in this cache.
* @args: Arguments for the cache creation (see struct kmem_cache_args).
* @flags: See %SLAB_* flags for an explanation of individual @flags.
*
* Cannot be called within a interrupt, but can be interrupted.
*
* Return: a pointer to the cache on success, NULL on failure.
*/
struct kmem_cache *__kmem_cache_create_args(const char *name,
unsigned int object_size,
struct kmem_cache_args *args,
slab_flags_t flags)
{
struct kmem_cache *s = NULL;
unsigned int freeptr_offset = UINT_MAX;
const char *cache_name;
int err;
@ -275,7 +285,7 @@ do_kmem_cache_create_usercopy(const char *name,
mutex_lock(&slab_mutex);
err = kmem_cache_sanity_check(name, size);
err = kmem_cache_sanity_check(name, object_size);
if (err) {
goto out_unlock;
}
@ -296,12 +306,14 @@ do_kmem_cache_create_usercopy(const char *name,
/* Fail closed on bad usersize of useroffset values. */
if (!IS_ENABLED(CONFIG_HARDENED_USERCOPY) ||
WARN_ON(!usersize && useroffset) ||
WARN_ON(size < usersize || size - usersize < useroffset))
usersize = useroffset = 0;
WARN_ON(!args->usersize && args->useroffset) ||
WARN_ON(object_size < args->usersize ||
object_size - args->usersize < args->useroffset))
args->usersize = args->useroffset = 0;
if (!usersize)
s = __kmem_cache_alias(name, size, align, flags, ctor);
if (!args->usersize)
s = __kmem_cache_alias(name, object_size, args->align, flags,
args->ctor);
if (s)
goto out_unlock;
@ -311,9 +323,11 @@ do_kmem_cache_create_usercopy(const char *name,
goto out_unlock;
}
s = create_cache(cache_name, size, freeptr_offset,
calculate_alignment(flags, align, size),
flags, useroffset, usersize, ctor);
if (args->use_freeptr_offset)
freeptr_offset = args->freeptr_offset;
s = create_cache(cache_name, object_size, freeptr_offset,
calculate_alignment(flags, args->align, object_size),
flags, args->useroffset, args->usersize, args->ctor);
if (IS_ERR(s)) {
err = PTR_ERR(s);
kfree_const(cache_name);
@ -335,6 +349,27 @@ out_unlock:
}
return s;
}
EXPORT_SYMBOL(__kmem_cache_create_args);
static struct kmem_cache *
do_kmem_cache_create_usercopy(const char *name,
unsigned int size, unsigned int freeptr_offset,
unsigned int align, slab_flags_t flags,
unsigned int useroffset, unsigned int usersize,
void (*ctor)(void *))
{
struct kmem_cache_args kmem_args = {
.align = align,
.use_freeptr_offset = freeptr_offset != UINT_MAX,
.freeptr_offset = freeptr_offset,
.useroffset = useroffset,
.usersize = usersize,
.ctor = ctor,
};
return __kmem_cache_create_args(name, size, &kmem_args, flags);
}
/**
* kmem_cache_create_usercopy - Create a cache with a region suitable