Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef __LINUX_SMP_H |
| 2 | #define __LINUX_SMP_H |
| 3 | |
| 4 | /* |
| 5 | * Generic SMP support |
| 6 | * Alan Cox. <alan@redhat.com> |
| 7 | */ |
| 8 | |
Heiko Carstens | 79974a0 | 2007-05-16 22:11:09 -0700 | [diff] [blame] | 9 | #include <linux/errno.h> |
David S. Miller | 54514a7 | 2008-09-23 22:15:57 -0700 | [diff] [blame] | 10 | #include <linux/types.h> |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 11 | #include <linux/list.h> |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 12 | #include <linux/cpumask.h> |
Heiko Carstens | 04948c7 | 2011-03-23 08:24:58 +0100 | [diff] [blame] | 13 | #include <linux/init.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | |
| 15 | extern void cpu_idle(void); |
| 16 | |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 17 | typedef void (*smp_call_func_t)(void *info); |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 18 | struct call_single_data { |
| 19 | struct list_head list; |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 20 | smp_call_func_t func; |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 21 | void *info; |
David S. Miller | 54514a7 | 2008-09-23 22:15:57 -0700 | [diff] [blame] | 22 | u16 flags; |
| 23 | u16 priv; |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 24 | }; |
| 25 | |
Mike Travis | e057d7a | 2008-12-15 20:26:48 -0800 | [diff] [blame] | 26 | /* total number of cpus in this system (may exceed NR_CPUS) */ |
| 27 | extern unsigned int total_cpus; |
| 28 | |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 29 | int smp_call_function_single(int cpuid, smp_call_func_t func, void *info, |
| 30 | int wait); |
Andrew Morton | 53ce3d9 | 2009-01-09 12:27:08 -0800 | [diff] [blame] | 31 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | #ifdef CONFIG_SMP |
| 33 | |
| 34 | #include <linux/preempt.h> |
| 35 | #include <linux/kernel.h> |
| 36 | #include <linux/compiler.h> |
| 37 | #include <linux/thread_info.h> |
| 38 | #include <asm/smp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | |
| 40 | /* |
| 41 | * main cross-CPU interfaces, handles INIT, TLB flush, STOP, etc. |
| 42 | * (defined in asm header): |
Ingo Molnar | d1dedb5 | 2009-03-13 11:14:06 +0100 | [diff] [blame] | 43 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | |
| 45 | /* |
| 46 | * stops all CPUs but the current one: |
| 47 | */ |
| 48 | extern void smp_send_stop(void); |
| 49 | |
| 50 | /* |
| 51 | * sends a 'reschedule' event to another CPU: |
| 52 | */ |
| 53 | extern void smp_send_reschedule(int cpu); |
| 54 | |
| 55 | |
| 56 | /* |
| 57 | * Prepare machine for booting other CPUs. |
| 58 | */ |
| 59 | extern void smp_prepare_cpus(unsigned int max_cpus); |
| 60 | |
| 61 | /* |
| 62 | * Bring a CPU up |
| 63 | */ |
| 64 | extern int __cpu_up(unsigned int cpunum); |
| 65 | |
| 66 | /* |
| 67 | * Final polishing of CPUs |
| 68 | */ |
| 69 | extern void smp_cpus_done(unsigned int max_cpus); |
| 70 | |
| 71 | /* |
| 72 | * Call a function on all other processors |
| 73 | */ |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 74 | int smp_call_function(smp_call_func_t func, void *info, int wait); |
Rusty Russell | 54b11e6 | 2008-12-30 09:05:16 +1030 | [diff] [blame] | 75 | void smp_call_function_many(const struct cpumask *mask, |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 76 | smp_call_func_t func, void *info, bool wait); |
Rusty Russell | 2d3854a | 2008-11-05 13:39:10 +1100 | [diff] [blame] | 77 | |
Peter Zijlstra | 6e27563 | 2009-02-25 13:59:48 +0100 | [diff] [blame] | 78 | void __smp_call_function_single(int cpuid, struct call_single_data *data, |
| 79 | int wait); |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 80 | |
Rusty Russell | 2ea6dec | 2009-11-17 14:27:27 -0800 | [diff] [blame] | 81 | int smp_call_function_any(const struct cpumask *mask, |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 82 | smp_call_func_t func, void *info, int wait); |
Rusty Russell | 2ea6dec | 2009-11-17 14:27:27 -0800 | [diff] [blame] | 83 | |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 84 | /* |
| 85 | * Generic and arch helpers |
| 86 | */ |
| 87 | #ifdef CONFIG_USE_GENERIC_SMP_HELPERS |
Takao Indoh | d8ad7d1 | 2011-03-29 12:35:04 -0400 | [diff] [blame] | 88 | void __init call_function_init(void); |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 89 | void generic_smp_call_function_single_interrupt(void); |
| 90 | void generic_smp_call_function_interrupt(void); |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 91 | void ipi_call_lock(void); |
| 92 | void ipi_call_unlock(void); |
| 93 | void ipi_call_lock_irq(void); |
| 94 | void ipi_call_unlock_irq(void); |
Takao Indoh | d8ad7d1 | 2011-03-29 12:35:04 -0400 | [diff] [blame] | 95 | #else |
| 96 | static inline void call_function_init(void) { } |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 97 | #endif |
Andrew Morton | a3bc0db | 2006-09-25 23:32:33 -0700 | [diff] [blame] | 98 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | /* |
| 100 | * Call a function on all processors |
| 101 | */ |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 102 | int on_each_cpu(smp_call_func_t func, void *info, int wait); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | /* |
Gilad Ben-Yossef | 3fc498f | 2012-03-28 14:42:43 -0700 | [diff] [blame] | 105 | * Call a function on processors specified by mask, which might include |
| 106 | * the local one. |
| 107 | */ |
| 108 | void on_each_cpu_mask(const struct cpumask *mask, smp_call_func_t func, |
| 109 | void *info, bool wait); |
| 110 | |
| 111 | /* |
Gilad Ben-Yossef | b3a7e98 | 2012-03-28 14:42:43 -0700 | [diff] [blame] | 112 | * Call a function on each processor for which the supplied function |
| 113 | * cond_func returns a positive value. This may include the local |
| 114 | * processor. |
| 115 | */ |
| 116 | void on_each_cpu_cond(bool (*cond_func)(int cpu, void *info), |
| 117 | smp_call_func_t func, void *info, bool wait, |
| 118 | gfp_t gfp_flags); |
| 119 | |
| 120 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | * Mark the boot cpu "online" so that it can call console drivers in |
| 122 | * printk() and can access its per-cpu storage. |
| 123 | */ |
| 124 | void smp_prepare_boot_cpu(void); |
| 125 | |
Andi Kleen | ca74a6f | 2008-01-30 13:33:17 +0100 | [diff] [blame] | 126 | extern unsigned int setup_max_cpus; |
Amerigo Wang | 34db18a0 | 2011-03-22 16:34:06 -0700 | [diff] [blame] | 127 | extern void __init setup_nr_cpu_ids(void); |
| 128 | extern void __init smp_init(void); |
Andi Kleen | ca74a6f | 2008-01-30 13:33:17 +0100 | [diff] [blame] | 129 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | #else /* !SMP */ |
| 131 | |
Ingo Molnar | d1dedb5 | 2009-03-13 11:14:06 +0100 | [diff] [blame] | 132 | static inline void smp_send_stop(void) { } |
| 133 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | /* |
| 135 | * These macros fold the SMP functionality into a single CPU system |
| 136 | */ |
Ingo Molnar | 39c715b | 2005-06-21 17:14:34 -0700 | [diff] [blame] | 137 | #define raw_smp_processor_id() 0 |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 138 | static inline int up_smp_call_function(smp_call_func_t func, void *info) |
Con Kolivas | 3c30b06 | 2006-03-26 01:37:19 -0800 | [diff] [blame] | 139 | { |
| 140 | return 0; |
| 141 | } |
Jens Axboe | 8691e5a | 2008-06-06 11:18:06 +0200 | [diff] [blame] | 142 | #define smp_call_function(func, info, wait) \ |
Ingo Molnar | a5fbb6d | 2007-11-09 22:39:38 +0100 | [diff] [blame] | 143 | (up_smp_call_function(func, info)) |
Jens Axboe | 15c8b6c | 2008-05-09 09:39:44 +0200 | [diff] [blame] | 144 | #define on_each_cpu(func,info,wait) \ |
Andrew Morton | 78eef01 | 2006-03-22 00:08:16 -0800 | [diff] [blame] | 145 | ({ \ |
| 146 | local_irq_disable(); \ |
| 147 | func(info); \ |
| 148 | local_irq_enable(); \ |
| 149 | 0; \ |
| 150 | }) |
Gilad Ben-Yossef | 3fc498f | 2012-03-28 14:42:43 -0700 | [diff] [blame] | 151 | /* |
| 152 | * Note we still need to test the mask even for UP |
| 153 | * because we actually can get an empty mask from |
| 154 | * code that on SMP might call us without the local |
| 155 | * CPU in the mask. |
| 156 | */ |
| 157 | #define on_each_cpu_mask(mask, func, info, wait) \ |
| 158 | do { \ |
| 159 | if (cpumask_test_cpu(0, (mask))) { \ |
| 160 | local_irq_disable(); \ |
| 161 | (func)(info); \ |
| 162 | local_irq_enable(); \ |
| 163 | } \ |
| 164 | } while (0) |
Gilad Ben-Yossef | b3a7e98 | 2012-03-28 14:42:43 -0700 | [diff] [blame] | 165 | /* |
| 166 | * Preemption is disabled here to make sure the cond_func is called under the |
| 167 | * same condtions in UP and SMP. |
| 168 | */ |
| 169 | #define on_each_cpu_cond(cond_func, func, info, wait, gfp_flags)\ |
| 170 | do { \ |
| 171 | void *__info = (info); \ |
| 172 | preempt_disable(); \ |
| 173 | if ((cond_func)(0, __info)) { \ |
| 174 | local_irq_disable(); \ |
| 175 | (func)(__info); \ |
| 176 | local_irq_enable(); \ |
| 177 | } \ |
| 178 | preempt_enable(); \ |
| 179 | } while (0) |
Gilad Ben-Yossef | 3fc498f | 2012-03-28 14:42:43 -0700 | [diff] [blame] | 180 | |
Richard Henderson | 79a8810 | 2005-07-28 01:07:41 -0700 | [diff] [blame] | 181 | static inline void smp_send_reschedule(int cpu) { } |
Linus Torvalds | 2ac6608 | 2005-07-28 10:34:47 -0700 | [diff] [blame] | 182 | #define num_booting_cpus() 1 |
| 183 | #define smp_prepare_boot_cpu() do {} while (0) |
Rusty Russell | d2ff911 | 2008-12-15 19:04:35 +1030 | [diff] [blame] | 184 | #define smp_call_function_many(mask, func, info, wait) \ |
| 185 | (up_smp_call_function(func, info)) |
Takao Indoh | d8ad7d1 | 2011-03-29 12:35:04 -0400 | [diff] [blame] | 186 | static inline void call_function_init(void) { } |
Rusty Russell | 2ea6dec | 2009-11-17 14:27:27 -0800 | [diff] [blame] | 187 | |
| 188 | static inline int |
David Howells | 3a5f65d | 2010-10-27 17:28:36 +0100 | [diff] [blame] | 189 | smp_call_function_any(const struct cpumask *mask, smp_call_func_t func, |
Rusty Russell | 2ea6dec | 2009-11-17 14:27:27 -0800 | [diff] [blame] | 190 | void *info, int wait) |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 191 | { |
Rusty Russell | 2ea6dec | 2009-11-17 14:27:27 -0800 | [diff] [blame] | 192 | return smp_call_function_single(0, func, info, wait); |
Jens Axboe | 3d44223 | 2008-06-26 11:21:34 +0200 | [diff] [blame] | 193 | } |
Rusty Russell | 2ea6dec | 2009-11-17 14:27:27 -0800 | [diff] [blame] | 194 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | #endif /* !SMP */ |
| 196 | |
| 197 | /* |
Ingo Molnar | 39c715b | 2005-06-21 17:14:34 -0700 | [diff] [blame] | 198 | * smp_processor_id(): get the current CPU ID. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | * |
Rakib Mullick | cfd8d6c | 2010-03-05 13:42:45 -0800 | [diff] [blame] | 200 | * if DEBUG_PREEMPT is enabled then we check whether it is |
Ingo Molnar | 39c715b | 2005-06-21 17:14:34 -0700 | [diff] [blame] | 201 | * used in a preemption-safe way. (smp_processor_id() is safe |
| 202 | * if it's used in a preemption-off critical section, or in |
| 203 | * a thread that is bound to the current CPU.) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | * |
Ingo Molnar | 39c715b | 2005-06-21 17:14:34 -0700 | [diff] [blame] | 205 | * NOTE: raw_smp_processor_id() is for internal use only |
| 206 | * (smp_processor_id() is the preferred variant), but in rare |
| 207 | * instances it might also be used to turn off false positives |
| 208 | * (i.e. smp_processor_id() use that the debugging code reports but |
| 209 | * which use for some reason is legal). Don't use this to hack around |
| 210 | * the warning message, as your code might not work under PREEMPT. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | */ |
Ingo Molnar | 39c715b | 2005-06-21 17:14:34 -0700 | [diff] [blame] | 212 | #ifdef CONFIG_DEBUG_PREEMPT |
| 213 | extern unsigned int debug_smp_processor_id(void); |
| 214 | # define smp_processor_id() debug_smp_processor_id() |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | #else |
Ingo Molnar | 39c715b | 2005-06-21 17:14:34 -0700 | [diff] [blame] | 216 | # define smp_processor_id() raw_smp_processor_id() |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | #endif |
| 218 | |
| 219 | #define get_cpu() ({ preempt_disable(); smp_processor_id(); }) |
| 220 | #define put_cpu() preempt_enable() |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | |
Ingo Molnar | a146649 | 2009-01-31 14:09:06 +0100 | [diff] [blame] | 222 | /* |
| 223 | * Callback to arch code if there's nosmp or maxcpus=0 on the |
| 224 | * boot command line: |
| 225 | */ |
| 226 | extern void arch_disable_smp_support(void); |
| 227 | |
Andrew Morton | 033ab7f | 2006-06-30 01:55:50 -0700 | [diff] [blame] | 228 | void smp_setup_processor_id(void); |
| 229 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | #endif /* __LINUX_SMP_H */ |