Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef __LINUX_PERCPU_H |
| 2 | #define __LINUX_PERCPU_H |
Martin Peschke | 7ff6f08 | 2006-09-25 23:31:21 -0700 | [diff] [blame] | 3 | |
Robert P. J. Day | 0a3021f | 2007-07-15 23:39:57 -0700 | [diff] [blame] | 4 | #include <linux/preempt.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | #include <linux/slab.h> /* For kmalloc() */ |
| 6 | #include <linux/smp.h> |
Martin Peschke | 7ff6f08 | 2006-09-25 23:31:21 -0700 | [diff] [blame] | 7 | #include <linux/cpumask.h> |
Tejun Heo | 6a24290 | 2009-03-06 14:33:58 +0900 | [diff] [blame] | 8 | #include <linux/pfn.h> |
Martin Peschke | 7ff6f08 | 2006-09-25 23:31:21 -0700 | [diff] [blame] | 9 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | #include <asm/percpu.h> |
| 11 | |
Tejun Heo | 6a24290 | 2009-03-06 14:33:58 +0900 | [diff] [blame] | 12 | /* enough to cover all DEFINE_PER_CPUs in modules */ |
Jeremy Fitzhardinge | b00742d3 | 2007-05-02 19:27:11 +0200 | [diff] [blame] | 13 | #ifdef CONFIG_MODULES |
Tejun Heo | 6a24290 | 2009-03-06 14:33:58 +0900 | [diff] [blame] | 14 | #define PERCPU_MODULE_RESERVE (8 << 10) |
Jeremy Fitzhardinge | b00742d3 | 2007-05-02 19:27:11 +0200 | [diff] [blame] | 15 | #else |
Tejun Heo | 6a24290 | 2009-03-06 14:33:58 +0900 | [diff] [blame] | 16 | #define PERCPU_MODULE_RESERVE 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #endif |
| 18 | |
Tejun Heo | 6a24290 | 2009-03-06 14:33:58 +0900 | [diff] [blame] | 19 | #ifndef PERCPU_ENOUGH_ROOM |
Jeremy Fitzhardinge | b00742d3 | 2007-05-02 19:27:11 +0200 | [diff] [blame] | 20 | #define PERCPU_ENOUGH_ROOM \ |
Tejun Heo | 6a24290 | 2009-03-06 14:33:58 +0900 | [diff] [blame] | 21 | (ALIGN(__per_cpu_end - __per_cpu_start, SMP_CACHE_BYTES) + \ |
| 22 | PERCPU_MODULE_RESERVE) |
| 23 | #endif |
Jeremy Fitzhardinge | b00742d3 | 2007-05-02 19:27:11 +0200 | [diff] [blame] | 24 | |
Jan Blunck | 632bbfe | 2006-09-25 23:30:53 -0700 | [diff] [blame] | 25 | /* |
| 26 | * Must be an lvalue. Since @var must be a simple identifier, |
| 27 | * we force a syntax error here if it isn't. |
| 28 | */ |
| 29 | #define get_cpu_var(var) (*({ \ |
Jan Blunck | a666ecf | 2006-10-06 00:43:58 -0700 | [diff] [blame] | 30 | extern int simple_identifier_##var(void); \ |
Jan Blunck | 632bbfe | 2006-09-25 23:30:53 -0700 | [diff] [blame] | 31 | preempt_disable(); \ |
| 32 | &__get_cpu_var(var); })) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | #define put_cpu_var(var) preempt_enable() |
| 34 | |
| 35 | #ifdef CONFIG_SMP |
| 36 | |
Tejun Heo | e74e396 | 2009-03-30 19:07:44 +0900 | [diff] [blame] | 37 | #ifndef CONFIG_HAVE_LEGACY_PER_CPU_AREA |
Tejun Heo | fbf59bc | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 38 | |
Tejun Heo | 8d408b4 | 2009-02-24 11:57:21 +0900 | [diff] [blame] | 39 | /* minimum unit size, also is the maximum supported allocation size */ |
Tejun Heo | 6a24290 | 2009-03-06 14:33:58 +0900 | [diff] [blame] | 40 | #define PCPU_MIN_UNIT_SIZE PFN_ALIGN(64 << 10) |
Tejun Heo | 8d408b4 | 2009-02-24 11:57:21 +0900 | [diff] [blame] | 41 | |
| 42 | /* |
| 43 | * PERCPU_DYNAMIC_RESERVE indicates the amount of free area to piggy |
Tejun Heo | 6b19b0c | 2009-03-06 14:33:59 +0900 | [diff] [blame] | 44 | * back on the first chunk for dynamic percpu allocation if arch is |
| 45 | * manually allocating and mapping it for faster access (as a part of |
| 46 | * large page mapping for example). |
Tejun Heo | 8d408b4 | 2009-02-24 11:57:21 +0900 | [diff] [blame] | 47 | * |
Tejun Heo | 6b19b0c | 2009-03-06 14:33:59 +0900 | [diff] [blame] | 48 | * The following values give between one and two pages of free space |
| 49 | * after typical minimal boot (2-way SMP, single disk and NIC) with |
| 50 | * both defconfig and a distro config on x86_64 and 32. More |
| 51 | * intelligent way to determine this would be nice. |
Tejun Heo | 8d408b4 | 2009-02-24 11:57:21 +0900 | [diff] [blame] | 52 | */ |
Tejun Heo | 6b19b0c | 2009-03-06 14:33:59 +0900 | [diff] [blame] | 53 | #if BITS_PER_LONG > 32 |
| 54 | #define PERCPU_DYNAMIC_RESERVE (20 << 10) |
| 55 | #else |
| 56 | #define PERCPU_DYNAMIC_RESERVE (12 << 10) |
| 57 | #endif |
Tejun Heo | 8d408b4 | 2009-02-24 11:57:21 +0900 | [diff] [blame] | 58 | |
Tejun Heo | fbf59bc | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 59 | extern void *pcpu_base_addr; |
Tejun Heo | 2f39e63 | 2009-07-04 08:11:00 +0900 | [diff] [blame] | 60 | extern const int *pcpu_unit_map; |
Tejun Heo | fbf59bc | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 61 | |
Tejun Heo | d4b95f8 | 2009-07-04 08:10:59 +0900 | [diff] [blame] | 62 | typedef void * (*pcpu_fc_alloc_fn_t)(unsigned int cpu, size_t size); |
| 63 | typedef void (*pcpu_fc_free_fn_t)(void *ptr, size_t size); |
| 64 | typedef void (*pcpu_fc_populate_pte_fn_t)(unsigned long addr); |
Tejun Heo | a530b79 | 2009-07-04 08:11:00 +0900 | [diff] [blame] | 65 | typedef int (pcpu_fc_cpu_distance_fn_t)(unsigned int from, unsigned int to); |
Tejun Heo | 8c4bfc6 | 2009-07-04 08:10:59 +0900 | [diff] [blame] | 66 | typedef void (*pcpu_fc_map_fn_t)(void *ptr, size_t size, void *addr); |
Tejun Heo | fbf59bc | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 67 | |
Tejun Heo | ce3141a | 2009-07-04 08:11:00 +0900 | [diff] [blame] | 68 | extern size_t __init pcpu_setup_first_chunk( |
Tejun Heo | edcb463 | 2009-03-06 14:33:59 +0900 | [diff] [blame] | 69 | size_t static_size, size_t reserved_size, |
Tejun Heo | 38a6be5 | 2009-07-04 08:10:59 +0900 | [diff] [blame] | 70 | ssize_t dyn_size, size_t unit_size, |
Tejun Heo | 2f39e63 | 2009-07-04 08:11:00 +0900 | [diff] [blame] | 71 | void *base_addr, const int *unit_map); |
Tejun Heo | 8d408b4 | 2009-02-24 11:57:21 +0900 | [diff] [blame] | 72 | |
Tejun Heo | 08fc458 | 2009-08-14 15:00:49 +0900 | [diff] [blame^] | 73 | #ifdef CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK |
Tejun Heo | 66c3a75 | 2009-03-10 16:27:48 +0900 | [diff] [blame] | 74 | extern ssize_t __init pcpu_embed_first_chunk( |
| 75 | size_t static_size, size_t reserved_size, |
Tejun Heo | 788e5ab | 2009-07-04 08:10:58 +0900 | [diff] [blame] | 76 | ssize_t dyn_size); |
Tejun Heo | 08fc458 | 2009-08-14 15:00:49 +0900 | [diff] [blame^] | 77 | #endif |
Tejun Heo | 66c3a75 | 2009-03-10 16:27:48 +0900 | [diff] [blame] | 78 | |
Tejun Heo | 08fc458 | 2009-08-14 15:00:49 +0900 | [diff] [blame^] | 79 | #ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK |
Tejun Heo | 00ae406 | 2009-08-14 15:00:49 +0900 | [diff] [blame] | 80 | extern ssize_t __init pcpu_page_first_chunk( |
Tejun Heo | d4b95f8 | 2009-07-04 08:10:59 +0900 | [diff] [blame] | 81 | size_t static_size, size_t reserved_size, |
| 82 | pcpu_fc_alloc_fn_t alloc_fn, |
| 83 | pcpu_fc_free_fn_t free_fn, |
| 84 | pcpu_fc_populate_pte_fn_t populate_pte_fn); |
Tejun Heo | 08fc458 | 2009-08-14 15:00:49 +0900 | [diff] [blame^] | 85 | #endif |
Tejun Heo | d4b95f8 | 2009-07-04 08:10:59 +0900 | [diff] [blame] | 86 | |
Tejun Heo | 08fc458 | 2009-08-14 15:00:49 +0900 | [diff] [blame^] | 87 | #ifdef CONFIG_NEED_PER_CPU_LPAGE_FIRST_CHUNK |
Tejun Heo | a530b79 | 2009-07-04 08:11:00 +0900 | [diff] [blame] | 88 | extern int __init pcpu_lpage_build_unit_map( |
| 89 | size_t static_size, size_t reserved_size, |
| 90 | ssize_t *dyn_sizep, size_t *unit_sizep, |
| 91 | size_t lpage_size, int *unit_map, |
| 92 | pcpu_fc_cpu_distance_fn_t cpu_distance_fn); |
| 93 | |
Tejun Heo | 8c4bfc6 | 2009-07-04 08:10:59 +0900 | [diff] [blame] | 94 | extern ssize_t __init pcpu_lpage_first_chunk( |
| 95 | size_t static_size, size_t reserved_size, |
Tejun Heo | a530b79 | 2009-07-04 08:11:00 +0900 | [diff] [blame] | 96 | size_t dyn_size, size_t unit_size, |
| 97 | size_t lpage_size, const int *unit_map, |
| 98 | int nr_units, |
Tejun Heo | 8c4bfc6 | 2009-07-04 08:10:59 +0900 | [diff] [blame] | 99 | pcpu_fc_alloc_fn_t alloc_fn, |
| 100 | pcpu_fc_free_fn_t free_fn, |
| 101 | pcpu_fc_map_fn_t map_fn); |
| 102 | |
| 103 | extern void *pcpu_lpage_remapped(void *kaddr); |
| 104 | #else |
Tejun Heo | 8c4bfc6 | 2009-07-04 08:10:59 +0900 | [diff] [blame] | 105 | static inline void *pcpu_lpage_remapped(void *kaddr) |
| 106 | { |
| 107 | return NULL; |
| 108 | } |
| 109 | #endif |
| 110 | |
Tejun Heo | fbf59bc | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 111 | /* |
| 112 | * Use this to get to a cpu's version of the per-cpu object |
| 113 | * dynamically allocated. Non-atomic access to the current CPU's |
| 114 | * version should probably be combined with get_cpu()/put_cpu(). |
| 115 | */ |
| 116 | #define per_cpu_ptr(ptr, cpu) SHIFT_PERCPU_PTR((ptr), per_cpu_offset((cpu))) |
| 117 | |
Tejun Heo | edcb463 | 2009-03-06 14:33:59 +0900 | [diff] [blame] | 118 | extern void *__alloc_reserved_percpu(size_t size, size_t align); |
| 119 | |
Tejun Heo | e74e396 | 2009-03-30 19:07:44 +0900 | [diff] [blame] | 120 | #else /* CONFIG_HAVE_LEGACY_PER_CPU_AREA */ |
Tejun Heo | fbf59bc | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 121 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | struct percpu_data { |
Eric Dumazet | b324215 | 2008-02-06 01:37:01 -0800 | [diff] [blame] | 123 | void *ptrs[1]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | }; |
| 125 | |
Catalin Marinas | 2e1483c | 2009-06-11 13:24:13 +0100 | [diff] [blame] | 126 | /* pointer disguising messes up the kmemleak objects tracking */ |
| 127 | #ifndef CONFIG_DEBUG_KMEMLEAK |
Martin Peschke | 7ff6f08 | 2006-09-25 23:31:21 -0700 | [diff] [blame] | 128 | #define __percpu_disguise(pdata) (struct percpu_data *)~(unsigned long)(pdata) |
Catalin Marinas | 2e1483c | 2009-06-11 13:24:13 +0100 | [diff] [blame] | 129 | #else |
| 130 | #define __percpu_disguise(pdata) (struct percpu_data *)(pdata) |
| 131 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | |
Rusty Russell | b36128c | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 133 | #define per_cpu_ptr(ptr, cpu) \ |
| 134 | ({ \ |
| 135 | struct percpu_data *__p = __percpu_disguise(ptr); \ |
| 136 | (__typeof__(ptr))__p->ptrs[(cpu)]; \ |
| 137 | }) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | |
Tejun Heo | e74e396 | 2009-03-30 19:07:44 +0900 | [diff] [blame] | 139 | #endif /* CONFIG_HAVE_LEGACY_PER_CPU_AREA */ |
Tejun Heo | fbf59bc | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 140 | |
Tejun Heo | f2a8205 | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 141 | extern void *__alloc_percpu(size_t size, size_t align); |
| 142 | extern void free_percpu(void *__pdata); |
| 143 | |
Tejun Heo | e74e396 | 2009-03-30 19:07:44 +0900 | [diff] [blame] | 144 | #ifndef CONFIG_HAVE_SETUP_PER_CPU_AREA |
| 145 | extern void __init setup_per_cpu_areas(void); |
| 146 | #endif |
| 147 | |
Tejun Heo | f2a8205 | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 148 | #else /* CONFIG_SMP */ |
| 149 | |
| 150 | #define per_cpu_ptr(ptr, cpu) ({ (void)(cpu); (ptr); }) |
| 151 | |
| 152 | static inline void *__alloc_percpu(size_t size, size_t align) |
| 153 | { |
| 154 | /* |
| 155 | * Can't easily make larger alignment work with kmalloc. WARN |
| 156 | * on it. Larger alignment should only be used for module |
| 157 | * percpu sections on SMP for which this path isn't used. |
| 158 | */ |
Tejun Heo | e317603 | 2009-02-26 10:54:17 +0900 | [diff] [blame] | 159 | WARN_ON_ONCE(align > SMP_CACHE_BYTES); |
Ingo Molnar | d2b0261 | 2009-02-25 14:36:45 +0100 | [diff] [blame] | 160 | return kzalloc(size, GFP_KERNEL); |
Tejun Heo | f2a8205 | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 161 | } |
| 162 | |
| 163 | static inline void free_percpu(void *p) |
| 164 | { |
| 165 | kfree(p); |
| 166 | } |
| 167 | |
Tejun Heo | e74e396 | 2009-03-30 19:07:44 +0900 | [diff] [blame] | 168 | static inline void __init setup_per_cpu_areas(void) { } |
| 169 | |
Tejun Heo | a76761b | 2009-07-15 23:35:14 +0900 | [diff] [blame] | 170 | static inline void *pcpu_lpage_remapped(void *kaddr) |
| 171 | { |
| 172 | return NULL; |
| 173 | } |
| 174 | |
Tejun Heo | f2a8205 | 2009-02-20 16:29:08 +0900 | [diff] [blame] | 175 | #endif /* CONFIG_SMP */ |
| 176 | |
| 177 | #define alloc_percpu(type) (type *)__alloc_percpu(sizeof(type), \ |
| 178 | __alignof__(type)) |
| 179 | |
Tejun Heo | 066123a | 2009-04-10 12:02:40 -0700 | [diff] [blame] | 180 | /* |
| 181 | * Optional methods for optimized non-lvalue per-cpu variable access. |
| 182 | * |
| 183 | * @var can be a percpu variable or a field of it and its size should |
| 184 | * equal char, int or long. percpu_read() evaluates to a lvalue and |
| 185 | * all others to void. |
| 186 | * |
| 187 | * These operations are guaranteed to be atomic w.r.t. preemption. |
| 188 | * The generic versions use plain get/put_cpu_var(). Archs are |
| 189 | * encouraged to implement single-instruction alternatives which don't |
| 190 | * require preemption protection. |
| 191 | */ |
| 192 | #ifndef percpu_read |
| 193 | # define percpu_read(var) \ |
| 194 | ({ \ |
| 195 | typeof(per_cpu_var(var)) __tmp_var__; \ |
| 196 | __tmp_var__ = get_cpu_var(var); \ |
| 197 | put_cpu_var(var); \ |
| 198 | __tmp_var__; \ |
| 199 | }) |
| 200 | #endif |
| 201 | |
| 202 | #define __percpu_generic_to_op(var, val, op) \ |
| 203 | do { \ |
| 204 | get_cpu_var(var) op val; \ |
| 205 | put_cpu_var(var); \ |
| 206 | } while (0) |
| 207 | |
| 208 | #ifndef percpu_write |
| 209 | # define percpu_write(var, val) __percpu_generic_to_op(var, (val), =) |
| 210 | #endif |
| 211 | |
| 212 | #ifndef percpu_add |
| 213 | # define percpu_add(var, val) __percpu_generic_to_op(var, (val), +=) |
| 214 | #endif |
| 215 | |
| 216 | #ifndef percpu_sub |
| 217 | # define percpu_sub(var, val) __percpu_generic_to_op(var, (val), -=) |
| 218 | #endif |
| 219 | |
| 220 | #ifndef percpu_and |
| 221 | # define percpu_and(var, val) __percpu_generic_to_op(var, (val), &=) |
| 222 | #endif |
| 223 | |
| 224 | #ifndef percpu_or |
| 225 | # define percpu_or(var, val) __percpu_generic_to_op(var, (val), |=) |
| 226 | #endif |
| 227 | |
| 228 | #ifndef percpu_xor |
| 229 | # define percpu_xor(var, val) __percpu_generic_to_op(var, (val), ^=) |
| 230 | #endif |
| 231 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | #endif /* __LINUX_PERCPU_H */ |