[linux-2.6-block.git] / mm / slab.h

#ifndef MM_SLAB_H
#define MM_SLAB_H
/*
 * Internal slab definitions
 */

/*
 * State of the slab allocator.
 *
 * This is used to describe the states of the allocator during bootup.
 * Allocators use this to gradually bootstrap themselves. Most allocators
 * have the problem that the structures used for managing slab caches are
 * allocated from slab caches themselves.
 */
enum slab_state {
	DOWN,			/* No slab functionality yet */
	PARTIAL,		/* SLUB: kmem_cache_node available */
	PARTIAL_ARRAYCACHE,	/* SLAB: kmalloc size for arraycache available */
	PARTIAL_L3,		/* SLAB: kmalloc size for l3 struct available */
	UP,			/* Slab caches usable but not all extras yet */
	FULL			/* Everything is working */
};

extern enum slab_state slab_state;

/* The slab cache mutex protects the management structures during changes */
extern struct mutex slab_mutex;

/* The list of all slab caches on the system */
extern struct list_head slab_caches;

/* The slab cache that manages slab cache information */
extern struct kmem_cache *kmem_cache;

unsigned long calculate_alignment(unsigned long flags,
		unsigned long align, unsigned long size);

/* Functions provided by the slab allocators */
extern int __kmem_cache_create(struct kmem_cache *, unsigned long flags);

extern struct kmem_cache *create_kmalloc_cache(const char *name, size_t size,
			unsigned long flags);
extern void create_boot_cache(struct kmem_cache *, const char *name,
			size_t size, unsigned long flags);

#ifdef CONFIG_SLUB
struct kmem_cache *__kmem_cache_alias(const char *name, size_t size,
	size_t align, unsigned long flags, void (*ctor)(void *));
#else
static inline struct kmem_cache *__kmem_cache_alias(const char *name, size_t size,
	size_t align, unsigned long flags, void (*ctor)(void *))
{ return NULL; }
#endif


/* Legal flag mask for kmem_cache_create(), for various configurations */
#define SLAB_CORE_FLAGS (SLAB_HWCACHE_ALIGN | SLAB_CACHE_DMA | SLAB_PANIC | \
			 SLAB_DESTROY_BY_RCU | SLAB_DEBUG_OBJECTS )

#if defined(CONFIG_DEBUG_SLAB)
#define SLAB_DEBUG_FLAGS (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER)
#elif defined(CONFIG_SLUB_DEBUG)
#define SLAB_DEBUG_FLAGS (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER | \
			  SLAB_TRACE | SLAB_DEBUG_FREE)
#else
#define SLAB_DEBUG_FLAGS (0)
#endif

#if defined(CONFIG_SLAB)
#define SLAB_CACHE_FLAGS (SLAB_MEM_SPREAD | SLAB_NOLEAKTRACE | \
			  SLAB_RECLAIM_ACCOUNT | SLAB_TEMPORARY | SLAB_NOTRACK)
#elif defined(CONFIG_SLUB)
#define SLAB_CACHE_FLAGS (SLAB_NOLEAKTRACE | SLAB_RECLAIM_ACCOUNT | \
			  SLAB_TEMPORARY | SLAB_NOTRACK)
#else
#define SLAB_CACHE_FLAGS (0)
#endif

#define CACHE_CREATE_MASK (SLAB_CORE_FLAGS | SLAB_DEBUG_FLAGS | SLAB_CACHE_FLAGS)

int __kmem_cache_shutdown(struct kmem_cache *);

struct seq_file;
struct file;

struct slabinfo {
	unsigned long active_objs;
	unsigned long num_objs;
	unsigned long active_slabs;
	unsigned long num_slabs;
	unsigned long shared_avail;
	unsigned int limit;
	unsigned int batchcount;
	unsigned int shared;
	unsigned int objects_per_slab;
	unsigned int cache_order;
};

void get_slabinfo(struct kmem_cache *s, struct slabinfo *sinfo);
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);

#ifdef CONFIG_MEMCG_KMEM
static inline bool is_root_cache(struct kmem_cache *s)
{
	return !s->memcg_params || s->memcg_params->is_root_cache;
}
#else
static inline bool is_root_cache(struct kmem_cache *s)
{
	return true;
}

#endif
#endif
Commit	Line	Data
97d06609 CL	1	#ifndef MM_SLAB_H
	2	#define MM_SLAB_H
	3	/*
	4	* Internal slab definitions
	5	*/
	6
	7	/*
	8	* State of the slab allocator.
	9	*
	10	* This is used to describe the states of the allocator during bootup.
	11	* Allocators use this to gradually bootstrap themselves. Most allocators
	12	* have the problem that the structures used for managing slab caches are
	13	* allocated from slab caches themselves.
	14	*/
	15	enum slab_state {
	16	DOWN, /* No slab functionality yet */
	17	PARTIAL, /* SLUB: kmem_cache_node available */
	18	PARTIAL_ARRAYCACHE, /* SLAB: kmalloc size for arraycache available */
	19	PARTIAL_L3, /* SLAB: kmalloc size for l3 struct available */
	20	UP, /* Slab caches usable but not all extras yet */
	21	FULL /* Everything is working */
	22	};
	23
	24	extern enum slab_state slab_state;
	25
18004c5d CL	26	/* The slab cache mutex protects the management structures during changes */
18004c5d CL	27	extern struct mutex slab_mutex;
9b030cb8 CL	28
9b030cb8 CL	29	/* The list of all slab caches on the system */
18004c5d CL	30	extern struct list_head slab_caches;
18004c5d CL	31
9b030cb8 CL	32	/* The slab cache that manages slab cache information */
	33	extern struct kmem_cache *kmem_cache;
	34
45906855 CL	35	unsigned long calculate_alignment(unsigned long flags,
	36	unsigned long align, unsigned long size);
	37
9b030cb8	38	/* Functions provided by the slab allocators */
8a13a4cc	39	extern int __kmem_cache_create(struct kmem_cache *, unsigned long flags);
97d06609	40
45530c44 CL	41	extern struct kmem_cache create_kmalloc_cache(const char name, size_t size,
	42	unsigned long flags);
	43	extern void create_boot_cache(struct kmem_cache , const char name,
	44	size_t size, unsigned long flags);
	45
cbb79694 CL	46	#ifdef CONFIG_SLUB
	47	struct kmem_cache __kmem_cache_alias(const char name, size_t size,
	48	size_t align, unsigned long flags, void (ctor)(void ));
	49	#else
	50	static inline struct kmem_cache __kmem_cache_alias(const char name, size_t size,
	51	size_t align, unsigned long flags, void (ctor)(void ))
	52	{ return NULL; }
	53	#endif
	54
	55
d8843922 GC	56	/* Legal flag mask for kmem_cache_create(), for various configurations */
	57	#define SLAB_CORE_FLAGS (SLAB_HWCACHE_ALIGN \| SLAB_CACHE_DMA \| SLAB_PANIC \| \
	58	SLAB_DESTROY_BY_RCU \| SLAB_DEBUG_OBJECTS )
	59
	60	#if defined(CONFIG_DEBUG_SLAB)
	61	#define SLAB_DEBUG_FLAGS (SLAB_RED_ZONE \| SLAB_POISON \| SLAB_STORE_USER)
	62	#elif defined(CONFIG_SLUB_DEBUG)
	63	#define SLAB_DEBUG_FLAGS (SLAB_RED_ZONE \| SLAB_POISON \| SLAB_STORE_USER \| \
	64	SLAB_TRACE \| SLAB_DEBUG_FREE)
	65	#else
	66	#define SLAB_DEBUG_FLAGS (0)
	67	#endif
	68
	69	#if defined(CONFIG_SLAB)
	70	#define SLAB_CACHE_FLAGS (SLAB_MEM_SPREAD \| SLAB_NOLEAKTRACE \| \
	71	SLAB_RECLAIM_ACCOUNT \| SLAB_TEMPORARY \| SLAB_NOTRACK)
	72	#elif defined(CONFIG_SLUB)
	73	#define SLAB_CACHE_FLAGS (SLAB_NOLEAKTRACE \| SLAB_RECLAIM_ACCOUNT \| \
	74	SLAB_TEMPORARY \| SLAB_NOTRACK)
	75	#else
	76	#define SLAB_CACHE_FLAGS (0)
	77	#endif
	78
	79	#define CACHE_CREATE_MASK (SLAB_CORE_FLAGS \| SLAB_DEBUG_FLAGS \| SLAB_CACHE_FLAGS)
	80
945cf2b6	81	int __kmem_cache_shutdown(struct kmem_cache *);
945cf2b6	82
b7454ad3 GC	83	struct seq_file;
b7454ad3 GC	84	struct file;
b7454ad3	85
0d7561c6 GC	86	struct slabinfo {
	87	unsigned long active_objs;
	88	unsigned long num_objs;
	89	unsigned long active_slabs;
	90	unsigned long num_slabs;
	91	unsigned long shared_avail;
	92	unsigned int limit;
	93	unsigned int batchcount;
	94	unsigned int shared;
	95	unsigned int objects_per_slab;
	96	unsigned int cache_order;
	97	};
	98
	99	void get_slabinfo(struct kmem_cache s, struct slabinfo sinfo);
	100	void slabinfo_show_stats(struct seq_file m, struct kmem_cache s);
b7454ad3 GC	101	ssize_t slabinfo_write(struct file file, const char __user buffer,
b7454ad3 GC	102	size_t count, loff_t *ppos);
ba6c496e GC	103
	104	#ifdef CONFIG_MEMCG_KMEM
	105	static inline bool is_root_cache(struct kmem_cache *s)
	106	{
	107	return !s->memcg_params \|\| s->memcg_params->is_root_cache;
	108	}
	109	#else
	110	static inline bool is_root_cache(struct kmem_cache *s)
	111	{
	112	return true;
	113	}
	114
	115	#endif
97d06609	116	#endif