[net-next-2.6.git] / include / linux / smp.h

#ifndef __LINUX_SMP_H
#define __LINUX_SMP_H

/*
 *	Generic SMP support
 *		Alan Cox. <alan@redhat.com>
 */

#include <linux/errno.h>

extern void cpu_idle(void);

#ifdef CONFIG_SMP

#include <linux/preempt.h>
#include <linux/kernel.h>
#include <linux/compiler.h>
#include <linux/thread_info.h>
#include <asm/smp.h>

/*
 * main cross-CPU interfaces, handles INIT, TLB flush, STOP, etc.
 * (defined in asm header):
 */ 

/*
 * stops all CPUs but the current one:
 */
extern void smp_send_stop(void);

/*
 * sends a 'reschedule' event to another CPU:
 */
extern void smp_send_reschedule(int cpu);


/*
 * Prepare machine for booting other CPUs.
 */
extern void smp_prepare_cpus(unsigned int max_cpus);

/*
 * Bring a CPU up
 */
extern int __cpu_up(unsigned int cpunum);

/*
 * Final polishing of CPUs
 */
extern void smp_cpus_done(unsigned int max_cpus);

/*
 * Call a function on all other processors
 */
int smp_call_function(void(*func)(void *info), void *info, int retry, int wait);

int smp_call_function_single(int cpuid, void (*func) (void *info), void *info,
				int retry, int wait);

/*
 * Call a function on all processors
 */
int on_each_cpu(void (*func) (void *info), void *info, int retry, int wait);

#define MSG_ALL_BUT_SELF	0x8000	/* Assume <32768 CPU's */
#define MSG_ALL			0x8001

#define MSG_INVALIDATE_TLB	0x0001	/* Remote processor TLB invalidate */
#define MSG_STOP_CPU		0x0002	/* Sent to shut down slave CPU's
					 * when rebooting
					 */
#define MSG_RESCHEDULE		0x0003	/* Reschedule request from master CPU*/
#define MSG_CALL_FUNCTION       0x0004  /* Call function on all other CPUs */

/*
 * Mark the boot cpu "online" so that it can call console drivers in
 * printk() and can access its per-cpu storage.
 */
void smp_prepare_boot_cpu(void);

#else /* !SMP */

/*
 *	These macros fold the SMP functionality into a single CPU system
 */
#define raw_smp_processor_id()			0
static inline int up_smp_call_function(void)
{
	return 0;
}
#define smp_call_function(func,info,retry,wait)	(up_smp_call_function())
#define on_each_cpu(func,info,retry,wait)	\
	({					\
		local_irq_disable();		\
		func(info);			\
		local_irq_enable();		\
		0;				\
	})
static inline void smp_send_reschedule(int cpu) { }
#define num_booting_cpus()			1
#define smp_prepare_boot_cpu()			do {} while (0)
static inline int smp_call_function_single(int cpuid, void (*func) (void *info),
					   void *info, int retry, int wait)
{
	return -EBUSY;
}

#endif /* !SMP */

/*
 * smp_processor_id(): get the current CPU ID.
 *
 * if DEBUG_PREEMPT is enabled the we check whether it is
 * used in a preemption-safe way. (smp_processor_id() is safe
 * if it's used in a preemption-off critical section, or in
 * a thread that is bound to the current CPU.)
 *
 * NOTE: raw_smp_processor_id() is for internal use only
 * (smp_processor_id() is the preferred variant), but in rare
 * instances it might also be used to turn off false positives
 * (i.e. smp_processor_id() use that the debugging code reports but
 * which use for some reason is legal). Don't use this to hack around
 * the warning message, as your code might not work under PREEMPT.
 */
#ifdef CONFIG_DEBUG_PREEMPT
  extern unsigned int debug_smp_processor_id(void);
# define smp_processor_id() debug_smp_processor_id()
#else
# define smp_processor_id() raw_smp_processor_id()
#endif

#define get_cpu()		({ preempt_disable(); smp_processor_id(); })
#define put_cpu()		preempt_enable()
#define put_cpu_no_resched()	preempt_enable_no_resched()

void smp_setup_processor_id(void);

#endif /* __LINUX_SMP_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef __LINUX_SMP_H
	2	#define __LINUX_SMP_H
	3
	4	/*
	5	* Generic SMP support
	6	* Alan Cox. <alan@redhat.com>
	7	*/
	8
79974a0e	9	#include <linux/errno.h>
1da177e4 LT	10
	11	extern void cpu_idle(void);
	12
	13	#ifdef CONFIG_SMP
	14
	15	#include <linux/preempt.h>
	16	#include <linux/kernel.h>
	17	#include <linux/compiler.h>
	18	#include <linux/thread_info.h>
	19	#include <asm/smp.h>
1da177e4 LT	20
	21	/*
	22	* main cross-CPU interfaces, handles INIT, TLB flush, STOP, etc.
	23	* (defined in asm header):
	24	*/
	25
	26	/*
	27	* stops all CPUs but the current one:
	28	*/
	29	extern void smp_send_stop(void);
	30
	31	/*
	32	* sends a 'reschedule' event to another CPU:
	33	*/
	34	extern void smp_send_reschedule(int cpu);
	35
	36
	37	/*
	38	* Prepare machine for booting other CPUs.
	39	*/
	40	extern void smp_prepare_cpus(unsigned int max_cpus);
	41
	42	/*
	43	* Bring a CPU up
	44	*/
	45	extern int __cpu_up(unsigned int cpunum);
	46
	47	/*
	48	* Final polishing of CPUs
	49	*/
	50	extern void smp_cpus_done(unsigned int max_cpus);
	51
	52	/*
	53	* Call a function on all other processors
	54	*/
78eef01b	55	int smp_call_function(void(func)(void info), void *info, int retry, int wait);
1da177e4	56
a3bc0dbc AM	57	int smp_call_function_single(int cpuid, void (func) (void info), void *info,
	58	int retry, int wait);
	59
1da177e4 LT	60	/*
	61	* Call a function on all processors
	62	*/
78eef01b	63	int on_each_cpu(void (func) (void info), void *info, int retry, int wait);
1da177e4 LT	64
	65	#define MSG_ALL_BUT_SELF 0x8000 /* Assume <32768 CPU's */
	66	#define MSG_ALL 0x8001
	67
	68	#define MSG_INVALIDATE_TLB 0x0001 /* Remote processor TLB invalidate */
	69	#define MSG_STOP_CPU 0x0002 /* Sent to shut down slave CPU's
	70	* when rebooting
	71	*/
	72	#define MSG_RESCHEDULE 0x0003 /* Reschedule request from master CPU*/
	73	#define MSG_CALL_FUNCTION 0x0004 /* Call function on all other CPUs */
	74
	75	/*
	76	* Mark the boot cpu "online" so that it can call console drivers in
	77	* printk() and can access its per-cpu storage.
	78	*/
	79	void smp_prepare_boot_cpu(void);
	80
	81	#else /* !SMP */
	82
	83	/*
	84	* These macros fold the SMP functionality into a single CPU system
	85	*/
39c715b7	86	#define raw_smp_processor_id() 0
3c30b06d CK	87	static inline int up_smp_call_function(void)
	88	{
	89	return 0;
	90	}
	91	#define smp_call_function(func,info,retry,wait) (up_smp_call_function())
78eef01b AM	92	#define on_each_cpu(func,info,retry,wait) \
	93	({ \
	94	local_irq_disable(); \
	95	func(info); \
	96	local_irq_enable(); \
	97	0; \
	98	})
79a88102	99	static inline void smp_send_reschedule(int cpu) { }
2ac6608c LT	100	#define num_booting_cpus() 1
2ac6608c LT	101	#define smp_prepare_boot_cpu() do {} while (0)
83df8db9	102	static inline int smp_call_function_single(int cpuid, void (func) (void info),
79974a0e	103	void *info, int retry, int wait)
83df8db9	104	{
79974a0e	105	return -EBUSY;
83df8db9	106	}
1da177e4 LT	107
	108	#endif /* !SMP */
	109
	110	/*
39c715b7	111	* smp_processor_id(): get the current CPU ID.
1da177e4	112	*
39c715b7 IM	113	* if DEBUG_PREEMPT is enabled the we check whether it is
	114	* used in a preemption-safe way. (smp_processor_id() is safe
	115	* if it's used in a preemption-off critical section, or in
	116	* a thread that is bound to the current CPU.)
1da177e4	117	*
39c715b7 IM	118	* NOTE: raw_smp_processor_id() is for internal use only
	119	* (smp_processor_id() is the preferred variant), but in rare
	120	* instances it might also be used to turn off false positives
	121	* (i.e. smp_processor_id() use that the debugging code reports but
	122	* which use for some reason is legal). Don't use this to hack around
	123	* the warning message, as your code might not work under PREEMPT.
1da177e4	124	*/
39c715b7 IM	125	#ifdef CONFIG_DEBUG_PREEMPT
	126	extern unsigned int debug_smp_processor_id(void);
	127	# define smp_processor_id() debug_smp_processor_id()
1da177e4	128	#else
39c715b7	129	# define smp_processor_id() raw_smp_processor_id()
1da177e4 LT	130	#endif
	131
	132	#define get_cpu() ({ preempt_disable(); smp_processor_id(); })
	133	#define put_cpu() preempt_enable()
	134	#define put_cpu_no_resched() preempt_enable_no_resched()
	135
033ab7f8 AM	136	void smp_setup_processor_id(void);
033ab7f8 AM	137
1da177e4	138	#endif /* __LINUX_SMP_H */