1#ifndef _LINUX_STOP_MACHINE
2#define _LINUX_STOP_MACHINE
3
4#include <linux/cpu.h>
5#include <linux/cpumask.h>
6#include <linux/smp.h>
7#include <linux/list.h>
8
9/*
10 * stop_cpu[s]() is simplistic per-cpu maximum priority cpu
11 * monopolization mechanism.  The caller can specify a non-sleeping
12 * function to be executed on a single or multiple cpus preempting all
13 * other processes and monopolizing those cpus until it finishes.
14 *
15 * Resources for this mechanism are preallocated when a cpu is brought
16 * up and requests are guaranteed to be served as long as the target
17 * cpus are online.
18 */
19typedef int (*cpu_stop_fn_t)(void *arg);
20
21#ifdef CONFIG_SMP
22
23struct cpu_stop_work {
24	struct list_head	list;		/* cpu_stopper->works */
25	cpu_stop_fn_t		fn;
26	void			*arg;
27	struct cpu_stop_done	*done;
28};
29
30int stop_one_cpu(unsigned int cpu, cpu_stop_fn_t fn, void *arg);
31int stop_two_cpus(unsigned int cpu1, unsigned int cpu2, cpu_stop_fn_t fn, void *arg);
32void stop_one_cpu_nowait(unsigned int cpu, cpu_stop_fn_t fn, void *arg,
33			 struct cpu_stop_work *work_buf);
34int stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg);
35int try_stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg);
36void stop_machine_park(int cpu);
37void stop_machine_unpark(int cpu);
38
39#else	/* CONFIG_SMP */
40
41#include <linux/workqueue.h>
42
43struct cpu_stop_work {
44	struct work_struct	work;
45	cpu_stop_fn_t		fn;
46	void			*arg;
47};
48
49static inline int stop_one_cpu(unsigned int cpu, cpu_stop_fn_t fn, void *arg)
50{
51	int ret = -ENOENT;
52	preempt_disable();
53	if (cpu == smp_processor_id())
54		ret = fn(arg);
55	preempt_enable();
56	return ret;
57}
58
59static void stop_one_cpu_nowait_workfn(struct work_struct *work)
60{
61	struct cpu_stop_work *stwork =
62		container_of(work, struct cpu_stop_work, work);
63	preempt_disable();
64	stwork->fn(stwork->arg);
65	preempt_enable();
66}
67
68static inline void stop_one_cpu_nowait(unsigned int cpu,
69				       cpu_stop_fn_t fn, void *arg,
70				       struct cpu_stop_work *work_buf)
71{
72	if (cpu == smp_processor_id()) {
73		INIT_WORK(&work_buf->work, stop_one_cpu_nowait_workfn);
74		work_buf->fn = fn;
75		work_buf->arg = arg;
76		schedule_work(&work_buf->work);
77	}
78}
79
80static inline int stop_cpus(const struct cpumask *cpumask,
81			    cpu_stop_fn_t fn, void *arg)
82{
83	if (cpumask_test_cpu(raw_smp_processor_id(), cpumask))
84		return stop_one_cpu(raw_smp_processor_id(), fn, arg);
85	return -ENOENT;
86}
87
88static inline int try_stop_cpus(const struct cpumask *cpumask,
89				cpu_stop_fn_t fn, void *arg)
90{
91	return stop_cpus(cpumask, fn, arg);
92}
93
94#endif	/* CONFIG_SMP */
95
96/*
97 * stop_machine "Bogolock": stop the entire machine, disable
98 * interrupts.  This is a very heavy lock, which is equivalent to
99 * grabbing every spinlock (and more).  So the "read" side to such a
100 * lock is anything which disables preemption.
101 */
102#if defined(CONFIG_SMP) || defined(CONFIG_HOTPLUG_CPU)
103
104/**
105 * stop_machine: freeze the machine on all CPUs and run this function
106 * @fn: the function to run
107 * @data: the data ptr for the @fn()
108 * @cpus: the cpus to run the @fn() on (NULL = any online cpu)
109 *
110 * Description: This causes a thread to be scheduled on every cpu,
111 * each of which disables interrupts.  The result is that no one is
112 * holding a spinlock or inside any other preempt-disabled region when
113 * @fn() runs.
114 *
115 * This can be thought of as a very heavy write lock, equivalent to
116 * grabbing every spinlock in the kernel. */
117int stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus);
118
119int stop_machine_from_inactive_cpu(cpu_stop_fn_t fn, void *data,
120				   const struct cpumask *cpus);
121#else	/* CONFIG_SMP || CONFIG_HOTPLUG_CPU */
122
123static inline int stop_machine(cpu_stop_fn_t fn, void *data,
124				 const struct cpumask *cpus)
125{
126	unsigned long flags;
127	int ret;
128	local_irq_save(flags);
129	ret = fn(data);
130	local_irq_restore(flags);
131	return ret;
132}
133
134static inline int stop_machine_from_inactive_cpu(cpu_stop_fn_t fn, void *data,
135						 const struct cpumask *cpus)
136{
137	return stop_machine(fn, data, cpus);
138}
139
140#endif	/* CONFIG_SMP || CONFIG_HOTPLUG_CPU */
141#endif	/* _LINUX_STOP_MACHINE */
142