[deliverable/linux.git] / include / linux / percpu.h

#ifndef __LINUX_PERCPU_H
#define __LINUX_PERCPU_H

#include <linux/preempt.h>
#include <linux/slab.h> /* For kmalloc() */
#include <linux/smp.h>
#include <linux/cpumask.h>

#include <asm/percpu.h>

#ifdef CONFIG_SMP
#define DEFINE_PER_CPU(type, name)					\
	__attribute__((__section__(".data.percpu")))			\
	PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name

#ifdef MODULE
#define SHARED_ALIGNED_SECTION ".data.percpu"
#else
#define SHARED_ALIGNED_SECTION ".data.percpu.shared_aligned"
#endif

#define DEFINE_PER_CPU_SHARED_ALIGNED(type, name)			\
	__attribute__((__section__(SHARED_ALIGNED_SECTION)))		\
	PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name		\
	____cacheline_aligned_in_smp
#else
#define DEFINE_PER_CPU(type, name)					\
	PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name

#define DEFINE_PER_CPU_SHARED_ALIGNED(type, name)		      \
	DEFINE_PER_CPU(type, name)
#endif

#define EXPORT_PER_CPU_SYMBOL(var) EXPORT_SYMBOL(per_cpu__##var)
#define EXPORT_PER_CPU_SYMBOL_GPL(var) EXPORT_SYMBOL_GPL(per_cpu__##var)

/* Enough to cover all DEFINE_PER_CPUs in kernel, including modules. */
#ifndef PERCPU_ENOUGH_ROOM
#ifdef CONFIG_MODULES
#define PERCPU_MODULE_RESERVE	8192
#else
#define PERCPU_MODULE_RESERVE	0
#endif

#define PERCPU_ENOUGH_ROOM						\
	(__per_cpu_end - __per_cpu_start + PERCPU_MODULE_RESERVE)
#endif	/* PERCPU_ENOUGH_ROOM */

/*
 * Must be an lvalue. Since @var must be a simple identifier,
 * we force a syntax error here if it isn't.
 */
#define get_cpu_var(var) (*({				\
	extern int simple_identifier_##var(void);	\
	preempt_disable();				\
	&__get_cpu_var(var); }))
#define put_cpu_var(var) preempt_enable()

#ifdef CONFIG_SMP

struct percpu_data {
	void *ptrs[1];
};

#define __percpu_disguise(pdata) (struct percpu_data *)~(unsigned long)(pdata)
/* 
 * Use this to get to a cpu's version of the per-cpu object dynamically
 * allocated. Non-atomic access to the current CPU's version should
 * probably be combined with get_cpu()/put_cpu().
 */ 
#define percpu_ptr(ptr, cpu)                              \
({                                                        \
        struct percpu_data *__p = __percpu_disguise(ptr); \
        (__typeof__(ptr))__p->ptrs[(cpu)];	          \
})

extern void *percpu_populate(void *__pdata, size_t size, gfp_t gfp, int cpu);
extern void percpu_depopulate(void *__pdata, int cpu);
extern int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
				  cpumask_t *mask);
extern void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask);
extern void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask);
extern void percpu_free(void *__pdata);

#else /* CONFIG_SMP */

#define percpu_ptr(ptr, cpu) ({ (void)(cpu); (ptr); })

static inline void percpu_depopulate(void *__pdata, int cpu)
{
}

static inline void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask)
{
}

static inline void *percpu_populate(void *__pdata, size_t size, gfp_t gfp,
				    int cpu)
{
	return percpu_ptr(__pdata, cpu);
}

static inline int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
					 cpumask_t *mask)
{
	return 0;
}

static __always_inline void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask)
{
	return kzalloc(size, gfp);
}

static inline void percpu_free(void *__pdata)
{
	kfree(__pdata);
}

#endif /* CONFIG_SMP */

#define percpu_populate_mask(__pdata, size, gfp, mask) \
	__percpu_populate_mask((__pdata), (size), (gfp), &(mask))
#define percpu_depopulate_mask(__pdata, mask) \
	__percpu_depopulate_mask((__pdata), &(mask))
#define percpu_alloc_mask(size, gfp, mask) \
	__percpu_alloc_mask((size), (gfp), &(mask))

#define percpu_alloc(size, gfp) percpu_alloc_mask((size), (gfp), cpu_online_map)

/* (legacy) interface for use without CPU hotplug handling */

#define __alloc_percpu(size)	percpu_alloc_mask((size), GFP_KERNEL, \
						  cpu_possible_map)
#define alloc_percpu(type)	(type *)__alloc_percpu(sizeof(type))
#define free_percpu(ptr)	percpu_free((ptr))
#define per_cpu_ptr(ptr, cpu)	percpu_ptr((ptr), (cpu))

#endif /* __LINUX_PERCPU_H */
Commit	Line	Data
	1	#ifndef __LINUX_PERCPU_H
	2	#define __LINUX_PERCPU_H
	3
	4	#include <linux/preempt.h>
	5	#include <linux/slab.h> /* For kmalloc() */
	6	#include <linux/smp.h>
	7	#include <linux/cpumask.h>
	8
	9	#include <asm/percpu.h>
	10
	11	#ifdef CONFIG_SMP
	12	#define DEFINE_PER_CPU(type, name) \
	13	__attribute__((__section__(".data.percpu"))) \
	14	PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name
	15
	16	#ifdef MODULE
	17	#define SHARED_ALIGNED_SECTION ".data.percpu"
	18	#else
	19	#define SHARED_ALIGNED_SECTION ".data.percpu.shared_aligned"
	20	#endif
	21
	22	#define DEFINE_PER_CPU_SHARED_ALIGNED(type, name) \
	23	__attribute__((__section__(SHARED_ALIGNED_SECTION))) \
	24	PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name \
	25	____cacheline_aligned_in_smp
	26	#else
	27	#define DEFINE_PER_CPU(type, name) \
	28	PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name
	29
	30	#define DEFINE_PER_CPU_SHARED_ALIGNED(type, name) \
	31	DEFINE_PER_CPU(type, name)
	32	#endif
	33
	34	#define EXPORT_PER_CPU_SYMBOL(var) EXPORT_SYMBOL(per_cpu__##var)
	35	#define EXPORT_PER_CPU_SYMBOL_GPL(var) EXPORT_SYMBOL_GPL(per_cpu__##var)
	36
	37	/* Enough to cover all DEFINE_PER_CPUs in kernel, including modules. */
	38	#ifndef PERCPU_ENOUGH_ROOM
	39	#ifdef CONFIG_MODULES
	40	#define PERCPU_MODULE_RESERVE 8192
	41	#else
	42	#define PERCPU_MODULE_RESERVE 0
	43	#endif
	44
	45	#define PERCPU_ENOUGH_ROOM \
	46	(__per_cpu_end - __per_cpu_start + PERCPU_MODULE_RESERVE)
	47	#endif /* PERCPU_ENOUGH_ROOM */
	48
	49	/*
	50	* Must be an lvalue. Since @var must be a simple identifier,
	51	* we force a syntax error here if it isn't.
	52	*/
	53	#define get_cpu_var(var) (*({ \
	54	extern int simple_identifier_##var(void); \
	55	preempt_disable(); \
	56	&__get_cpu_var(var); }))
	57	#define put_cpu_var(var) preempt_enable()
	58
	59	#ifdef CONFIG_SMP
	60
	61	struct percpu_data {
	62	void *ptrs[1];
	63	};
	64
	65	#define __percpu_disguise(pdata) (struct percpu_data *)~(unsigned long)(pdata)
	66	/*
	67	* Use this to get to a cpu's version of the per-cpu object dynamically
	68	* allocated. Non-atomic access to the current CPU's version should
	69	* probably be combined with get_cpu()/put_cpu().
	70	*/
	71	#define percpu_ptr(ptr, cpu) \
	72	({ \
	73	struct percpu_data *__p = __percpu_disguise(ptr); \
	74	(__typeof__(ptr))__p->ptrs[(cpu)]; \
	75	})
	76
	77	extern void percpu_populate(void __pdata, size_t size, gfp_t gfp, int cpu);
	78	extern void percpu_depopulate(void *__pdata, int cpu);
	79	extern int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
	80	cpumask_t *mask);
	81	extern void __percpu_depopulate_mask(void __pdata, cpumask_t mask);
	82	extern void __percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t mask);
	83	extern void percpu_free(void *__pdata);
	84
	85	#else /* CONFIG_SMP */
	86
	87	#define percpu_ptr(ptr, cpu) ({ (void)(cpu); (ptr); })
	88
	89	static inline void percpu_depopulate(void *__pdata, int cpu)
	90	{
	91	}
	92
	93	static inline void __percpu_depopulate_mask(void __pdata, cpumask_t mask)
	94	{
	95	}
	96
	97	static inline void percpu_populate(void __pdata, size_t size, gfp_t gfp,
	98	int cpu)
	99	{
	100	return percpu_ptr(__pdata, cpu);
	101	}
	102
	103	static inline int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
	104	cpumask_t *mask)
	105	{
	106	return 0;
	107	}
	108
	109	static __always_inline void __percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t mask)
	110	{
	111	return kzalloc(size, gfp);
	112	}
	113
	114	static inline void percpu_free(void *__pdata)
	115	{
	116	kfree(__pdata);
	117	}
	118
	119	#endif /* CONFIG_SMP */
	120
	121	#define percpu_populate_mask(__pdata, size, gfp, mask) \
	122	__percpu_populate_mask((__pdata), (size), (gfp), &(mask))
	123	#define percpu_depopulate_mask(__pdata, mask) \
	124	__percpu_depopulate_mask((__pdata), &(mask))
	125	#define percpu_alloc_mask(size, gfp, mask) \
	126	__percpu_alloc_mask((size), (gfp), &(mask))
	127
	128	#define percpu_alloc(size, gfp) percpu_alloc_mask((size), (gfp), cpu_online_map)
	129
	130	/* (legacy) interface for use without CPU hotplug handling */
	131
	132	#define __alloc_percpu(size) percpu_alloc_mask((size), GFP_KERNEL, \
	133	cpu_possible_map)
	134	#define alloc_percpu(type) (type *)__alloc_percpu(sizeof(type))
	135	#define free_percpu(ptr) percpu_free((ptr))
	136	#define per_cpu_ptr(ptr, cpu) percpu_ptr((ptr), (cpu))
	137
	138	#endif /* __LINUX_PERCPU_H */