forked from luck/tmp_suning_uos_patched
4c13dd3b48
This patch allow to inject faults only for specific slabs. In order to preserve default behavior cache filter is off by default (all caches are faulty). One may define specific set of slabs like this: # mark skbuff_head_cache as faulty echo 1 > /sys/kernel/slab/skbuff_head_cache/failslab # Turn on cache filter (off by default) echo 1 > /sys/kernel/debug/failslab/cache-filter # Turn on fault injection echo 1 > /sys/kernel/debug/failslab/times echo 1 > /sys/kernel/debug/failslab/probability Acked-by: David Rientjes <rientjes@google.com> Acked-by: Akinobu Mita <akinobu.mita@gmail.com> Acked-by: Christoph Lameter <cl@linux-foundation.org> Signed-off-by: Dmitry Monakhov <dmonakhov@openvz.org> Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>
337 lines
11 KiB
C
337 lines
11 KiB
C
/*
|
|
* Written by Mark Hemment, 1996 (markhe@nextd.demon.co.uk).
|
|
*
|
|
* (C) SGI 2006, Christoph Lameter
|
|
* Cleaned up and restructured to ease the addition of alternative
|
|
* implementations of SLAB allocators.
|
|
*/
|
|
|
|
#ifndef _LINUX_SLAB_H
|
|
#define _LINUX_SLAB_H
|
|
|
|
#include <linux/gfp.h>
|
|
#include <linux/types.h>
|
|
|
|
/*
|
|
* Flags to pass to kmem_cache_create().
|
|
* The ones marked DEBUG are only valid if CONFIG_SLAB_DEBUG is set.
|
|
*/
|
|
#define SLAB_DEBUG_FREE 0x00000100UL /* DEBUG: Perform (expensive) checks on free */
|
|
#define SLAB_RED_ZONE 0x00000400UL /* DEBUG: Red zone objs in a cache */
|
|
#define SLAB_POISON 0x00000800UL /* DEBUG: Poison objects */
|
|
#define SLAB_HWCACHE_ALIGN 0x00002000UL /* Align objs on cache lines */
|
|
#define SLAB_CACHE_DMA 0x00004000UL /* Use GFP_DMA memory */
|
|
#define SLAB_STORE_USER 0x00010000UL /* DEBUG: Store the last owner for bug hunting */
|
|
#define SLAB_PANIC 0x00040000UL /* Panic if kmem_cache_create() fails */
|
|
/*
|
|
* SLAB_DESTROY_BY_RCU - **WARNING** READ THIS!
|
|
*
|
|
* This delays freeing the SLAB page by a grace period, it does _NOT_
|
|
* delay object freeing. This means that if you do kmem_cache_free()
|
|
* that memory location is free to be reused at any time. Thus it may
|
|
* be possible to see another object there in the same RCU grace period.
|
|
*
|
|
* This feature only ensures the memory location backing the object
|
|
* stays valid, the trick to using this is relying on an independent
|
|
* object validation pass. Something like:
|
|
*
|
|
* rcu_read_lock()
|
|
* again:
|
|
* obj = lockless_lookup(key);
|
|
* if (obj) {
|
|
* if (!try_get_ref(obj)) // might fail for free objects
|
|
* goto again;
|
|
*
|
|
* if (obj->key != key) { // not the object we expected
|
|
* put_ref(obj);
|
|
* goto again;
|
|
* }
|
|
* }
|
|
* rcu_read_unlock();
|
|
*
|
|
* See also the comment on struct slab_rcu in mm/slab.c.
|
|
*/
|
|
#define SLAB_DESTROY_BY_RCU 0x00080000UL /* Defer freeing slabs to RCU */
|
|
#define SLAB_MEM_SPREAD 0x00100000UL /* Spread some memory over cpuset */
|
|
#define SLAB_TRACE 0x00200000UL /* Trace allocations and frees */
|
|
|
|
/* Flag to prevent checks on free */
|
|
#ifdef CONFIG_DEBUG_OBJECTS
|
|
# define SLAB_DEBUG_OBJECTS 0x00400000UL
|
|
#else
|
|
# define SLAB_DEBUG_OBJECTS 0x00000000UL
|
|
#endif
|
|
|
|
#define SLAB_NOLEAKTRACE 0x00800000UL /* Avoid kmemleak tracing */
|
|
|
|
/* Don't track use of uninitialized memory */
|
|
#ifdef CONFIG_KMEMCHECK
|
|
# define SLAB_NOTRACK 0x01000000UL
|
|
#else
|
|
# define SLAB_NOTRACK 0x00000000UL
|
|
#endif
|
|
#ifdef CONFIG_FAILSLAB
|
|
# define SLAB_FAILSLAB 0x02000000UL /* Fault injection mark */
|
|
#else
|
|
# define SLAB_FAILSLAB 0x00000000UL
|
|
#endif
|
|
|
|
/* The following flags affect the page allocator grouping pages by mobility */
|
|
#define SLAB_RECLAIM_ACCOUNT 0x00020000UL /* Objects are reclaimable */
|
|
#define SLAB_TEMPORARY SLAB_RECLAIM_ACCOUNT /* Objects are short-lived */
|
|
/*
|
|
* ZERO_SIZE_PTR will be returned for zero sized kmalloc requests.
|
|
*
|
|
* Dereferencing ZERO_SIZE_PTR will lead to a distinct access fault.
|
|
*
|
|
* ZERO_SIZE_PTR can be passed to kfree though in the same way that NULL can.
|
|
* Both make kfree a no-op.
|
|
*/
|
|
#define ZERO_SIZE_PTR ((void *)16)
|
|
|
|
#define ZERO_OR_NULL_PTR(x) ((unsigned long)(x) <= \
|
|
(unsigned long)ZERO_SIZE_PTR)
|
|
|
|
/*
|
|
* struct kmem_cache related prototypes
|
|
*/
|
|
void __init kmem_cache_init(void);
|
|
int slab_is_available(void);
|
|
|
|
struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
|
|
unsigned long,
|
|
void (*)(void *));
|
|
void kmem_cache_destroy(struct kmem_cache *);
|
|
int kmem_cache_shrink(struct kmem_cache *);
|
|
void kmem_cache_free(struct kmem_cache *, void *);
|
|
unsigned int kmem_cache_size(struct kmem_cache *);
|
|
const char *kmem_cache_name(struct kmem_cache *);
|
|
int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
|
|
|
|
/*
|
|
* Please use this macro to create slab caches. Simply specify the
|
|
* name of the structure and maybe some flags that are listed above.
|
|
*
|
|
* The alignment of the struct determines object alignment. If you
|
|
* f.e. add ____cacheline_aligned_in_smp to the struct declaration
|
|
* then the objects will be properly aligned in SMP configurations.
|
|
*/
|
|
#define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
|
|
sizeof(struct __struct), __alignof__(struct __struct),\
|
|
(__flags), NULL)
|
|
|
|
/*
|
|
* The largest kmalloc size supported by the slab allocators is
|
|
* 32 megabyte (2^25) or the maximum allocatable page order if that is
|
|
* less than 32 MB.
|
|
*
|
|
* WARNING: Its not easy to increase this value since the allocators have
|
|
* to do various tricks to work around compiler limitations in order to
|
|
* ensure proper constant folding.
|
|
*/
|
|
#define KMALLOC_SHIFT_HIGH ((MAX_ORDER + PAGE_SHIFT - 1) <= 25 ? \
|
|
(MAX_ORDER + PAGE_SHIFT - 1) : 25)
|
|
|
|
#define KMALLOC_MAX_SIZE (1UL << KMALLOC_SHIFT_HIGH)
|
|
#define KMALLOC_MAX_ORDER (KMALLOC_SHIFT_HIGH - PAGE_SHIFT)
|
|
|
|
/*
|
|
* Common kmalloc functions provided by all allocators
|
|
*/
|
|
void * __must_check __krealloc(const void *, size_t, gfp_t);
|
|
void * __must_check krealloc(const void *, size_t, gfp_t);
|
|
void kfree(const void *);
|
|
void kzfree(const void *);
|
|
size_t ksize(const void *);
|
|
|
|
/*
|
|
* Allocator specific definitions. These are mainly used to establish optimized
|
|
* ways to convert kmalloc() calls to kmem_cache_alloc() invocations by
|
|
* selecting the appropriate general cache at compile time.
|
|
*
|
|
* Allocators must define at least:
|
|
*
|
|
* kmem_cache_alloc()
|
|
* __kmalloc()
|
|
* kmalloc()
|
|
*
|
|
* Those wishing to support NUMA must also define:
|
|
*
|
|
* kmem_cache_alloc_node()
|
|
* kmalloc_node()
|
|
*
|
|
* See each allocator definition file for additional comments and
|
|
* implementation notes.
|
|
*/
|
|
#ifdef CONFIG_SLUB
|
|
#include <linux/slub_def.h>
|
|
#elif defined(CONFIG_SLOB)
|
|
#include <linux/slob_def.h>
|
|
#else
|
|
#include <linux/slab_def.h>
|
|
#endif
|
|
|
|
/**
|
|
* kcalloc - allocate memory for an array. The memory is set to zero.
|
|
* @n: number of elements.
|
|
* @size: element size.
|
|
* @flags: the type of memory to allocate.
|
|
*
|
|
* The @flags argument may be one of:
|
|
*
|
|
* %GFP_USER - Allocate memory on behalf of user. May sleep.
|
|
*
|
|
* %GFP_KERNEL - Allocate normal kernel ram. May sleep.
|
|
*
|
|
* %GFP_ATOMIC - Allocation will not sleep. May use emergency pools.
|
|
* For example, use this inside interrupt handlers.
|
|
*
|
|
* %GFP_HIGHUSER - Allocate pages from high memory.
|
|
*
|
|
* %GFP_NOIO - Do not do any I/O at all while trying to get memory.
|
|
*
|
|
* %GFP_NOFS - Do not make any fs calls while trying to get memory.
|
|
*
|
|
* %GFP_NOWAIT - Allocation will not sleep.
|
|
*
|
|
* %GFP_THISNODE - Allocate node-local memory only.
|
|
*
|
|
* %GFP_DMA - Allocation suitable for DMA.
|
|
* Should only be used for kmalloc() caches. Otherwise, use a
|
|
* slab created with SLAB_DMA.
|
|
*
|
|
* Also it is possible to set different flags by OR'ing
|
|
* in one or more of the following additional @flags:
|
|
*
|
|
* %__GFP_COLD - Request cache-cold pages instead of
|
|
* trying to return cache-warm pages.
|
|
*
|
|
* %__GFP_HIGH - This allocation has high priority and may use emergency pools.
|
|
*
|
|
* %__GFP_NOFAIL - Indicate that this allocation is in no way allowed to fail
|
|
* (think twice before using).
|
|
*
|
|
* %__GFP_NORETRY - If memory is not immediately available,
|
|
* then give up at once.
|
|
*
|
|
* %__GFP_NOWARN - If allocation fails, don't issue any warnings.
|
|
*
|
|
* %__GFP_REPEAT - If allocation fails initially, try once more before failing.
|
|
*
|
|
* There are other flags available as well, but these are not intended
|
|
* for general use, and so are not documented here. For a full list of
|
|
* potential flags, always refer to linux/gfp.h.
|
|
*/
|
|
static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
|
|
{
|
|
if (size != 0 && n > ULONG_MAX / size)
|
|
return NULL;
|
|
return __kmalloc(n * size, flags | __GFP_ZERO);
|
|
}
|
|
|
|
#if !defined(CONFIG_NUMA) && !defined(CONFIG_SLOB)
|
|
/**
|
|
* kmalloc_node - allocate memory from a specific node
|
|
* @size: how many bytes of memory are required.
|
|
* @flags: the type of memory to allocate (see kcalloc).
|
|
* @node: node to allocate from.
|
|
*
|
|
* kmalloc() for non-local nodes, used to allocate from a specific node
|
|
* if available. Equivalent to kmalloc() in the non-NUMA single-node
|
|
* case.
|
|
*/
|
|
static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
|
|
{
|
|
return kmalloc(size, flags);
|
|
}
|
|
|
|
static inline void *__kmalloc_node(size_t size, gfp_t flags, int node)
|
|
{
|
|
return __kmalloc(size, flags);
|
|
}
|
|
|
|
void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
|
|
|
|
static inline void *kmem_cache_alloc_node(struct kmem_cache *cachep,
|
|
gfp_t flags, int node)
|
|
{
|
|
return kmem_cache_alloc(cachep, flags);
|
|
}
|
|
#endif /* !CONFIG_NUMA && !CONFIG_SLOB */
|
|
|
|
/*
|
|
* kmalloc_track_caller is a special version of kmalloc that records the
|
|
* calling function of the routine calling it for slab leak tracking instead
|
|
* of just the calling function (confusing, eh?).
|
|
* It's useful when the call to kmalloc comes from a widely-used standard
|
|
* allocator where we care about the real place the memory allocation
|
|
* request comes from.
|
|
*/
|
|
#if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB)
|
|
extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
|
|
#define kmalloc_track_caller(size, flags) \
|
|
__kmalloc_track_caller(size, flags, _RET_IP_)
|
|
#else
|
|
#define kmalloc_track_caller(size, flags) \
|
|
__kmalloc(size, flags)
|
|
#endif /* DEBUG_SLAB */
|
|
|
|
#ifdef CONFIG_NUMA
|
|
/*
|
|
* kmalloc_node_track_caller is a special version of kmalloc_node that
|
|
* records the calling function of the routine calling it for slab leak
|
|
* tracking instead of just the calling function (confusing, eh?).
|
|
* It's useful when the call to kmalloc_node comes from a widely-used
|
|
* standard allocator where we care about the real place the memory
|
|
* allocation request comes from.
|
|
*/
|
|
#if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB)
|
|
extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, unsigned long);
|
|
#define kmalloc_node_track_caller(size, flags, node) \
|
|
__kmalloc_node_track_caller(size, flags, node, \
|
|
_RET_IP_)
|
|
#else
|
|
#define kmalloc_node_track_caller(size, flags, node) \
|
|
__kmalloc_node(size, flags, node)
|
|
#endif
|
|
|
|
#else /* CONFIG_NUMA */
|
|
|
|
#define kmalloc_node_track_caller(size, flags, node) \
|
|
kmalloc_track_caller(size, flags)
|
|
|
|
#endif /* CONFIG_NUMA */
|
|
|
|
/*
|
|
* Shortcuts
|
|
*/
|
|
static inline void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
|
|
{
|
|
return kmem_cache_alloc(k, flags | __GFP_ZERO);
|
|
}
|
|
|
|
/**
|
|
* kzalloc - allocate memory. The memory is set to zero.
|
|
* @size: how many bytes of memory are required.
|
|
* @flags: the type of memory to allocate (see kmalloc).
|
|
*/
|
|
static inline void *kzalloc(size_t size, gfp_t flags)
|
|
{
|
|
return kmalloc(size, flags | __GFP_ZERO);
|
|
}
|
|
|
|
/**
|
|
* kzalloc_node - allocate zeroed memory from a particular memory node.
|
|
* @size: how many bytes of memory are required.
|
|
* @flags: the type of memory to allocate (see kmalloc).
|
|
* @node: memory node from which to allocate
|
|
*/
|
|
static inline void *kzalloc_node(size_t size, gfp_t flags, int node)
|
|
{
|
|
return kmalloc_node(size, flags | __GFP_ZERO, node);
|
|
}
|
|
|
|
void __init kmem_cache_init_late(void);
|
|
|
|
#endif /* _LINUX_SLAB_H */
|