aboutsummaryrefslogtreecommitdiffstats
path: root/arch/um/kernel/smp.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/um/kernel/smp.c')
-rw-r--r--arch/um/kernel/smp.c269
1 files changed, 269 insertions, 0 deletions
diff --git a/arch/um/kernel/smp.c b/arch/um/kernel/smp.c
new file mode 100644
index 000000000000..72113b0a96e7
--- /dev/null
+++ b/arch/um/kernel/smp.c
@@ -0,0 +1,269 @@
1/*
2 * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
3 * Licensed under the GPL
4 */
5
6#include "linux/config.h"
7#include "linux/percpu.h"
8#include "asm/pgalloc.h"
9#include "asm/tlb.h"
10
11/* For some reason, mmu_gathers are referenced when CONFIG_SMP is off. */
12DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
13
14#ifdef CONFIG_SMP
15
16#include "linux/sched.h"
17#include "linux/module.h"
18#include "linux/threads.h"
19#include "linux/interrupt.h"
20#include "linux/err.h"
21#include "linux/hardirq.h"
22#include "asm/smp.h"
23#include "asm/processor.h"
24#include "asm/spinlock.h"
25#include "user_util.h"
26#include "kern_util.h"
27#include "kern.h"
28#include "irq_user.h"
29#include "os.h"
30
31/* CPU online map, set by smp_boot_cpus */
32cpumask_t cpu_online_map = CPU_MASK_NONE;
33cpumask_t cpu_possible_map = CPU_MASK_NONE;
34
35EXPORT_SYMBOL(cpu_online_map);
36EXPORT_SYMBOL(cpu_possible_map);
37
38/* Per CPU bogomips and other parameters
39 * The only piece used here is the ipi pipe, which is set before SMP is
40 * started and never changed.
41 */
42struct cpuinfo_um cpu_data[NR_CPUS];
43
44/* A statistic, can be a little off */
45int num_reschedules_sent = 0;
46
47/* Not changed after boot */
48struct task_struct *idle_threads[NR_CPUS];
49
50void smp_send_reschedule(int cpu)
51{
52 os_write_file(cpu_data[cpu].ipi_pipe[1], "R", 1);
53 num_reschedules_sent++;
54}
55
56void smp_send_stop(void)
57{
58 int i;
59
60 printk(KERN_INFO "Stopping all CPUs...");
61 for(i = 0; i < num_online_cpus(); i++){
62 if(i == current_thread->cpu)
63 continue;
64 os_write_file(cpu_data[i].ipi_pipe[1], "S", 1);
65 }
66 printk("done\n");
67}
68
69static cpumask_t smp_commenced_mask = CPU_MASK_NONE;
70static cpumask_t cpu_callin_map = CPU_MASK_NONE;
71
72static int idle_proc(void *cpup)
73{
74 int cpu = (int) cpup, err;
75
76 err = os_pipe(cpu_data[cpu].ipi_pipe, 1, 1);
77 if(err < 0)
78 panic("CPU#%d failed to create IPI pipe, err = %d", cpu, -err);
79
80 activate_ipi(cpu_data[cpu].ipi_pipe[0],
81 current->thread.mode.tt.extern_pid);
82
83 wmb();
84 if (cpu_test_and_set(cpu, cpu_callin_map)) {
85 printk("huh, CPU#%d already present??\n", cpu);
86 BUG();
87 }
88
89 while (!cpu_isset(cpu, smp_commenced_mask))
90 cpu_relax();
91
92 cpu_set(cpu, cpu_online_map);
93 default_idle();
94 return(0);
95}
96
97static struct task_struct *idle_thread(int cpu)
98{
99 struct task_struct *new_task;
100 unsigned char c;
101
102 current->thread.request.u.thread.proc = idle_proc;
103 current->thread.request.u.thread.arg = (void *) cpu;
104 new_task = fork_idle(cpu);
105 if(IS_ERR(new_task))
106 panic("copy_process failed in idle_thread, error = %ld",
107 PTR_ERR(new_task));
108
109 cpu_tasks[cpu] = ((struct cpu_task)
110 { .pid = new_task->thread.mode.tt.extern_pid,
111 .task = new_task } );
112 idle_threads[cpu] = new_task;
113 CHOOSE_MODE(os_write_file(new_task->thread.mode.tt.switch_pipe[1], &c,
114 sizeof(c)),
115 ({ panic("skas mode doesn't support SMP"); }));
116 return(new_task);
117}
118
119void smp_prepare_cpus(unsigned int maxcpus)
120{
121 struct task_struct *idle;
122 unsigned long waittime;
123 int err, cpu, me = smp_processor_id();
124 int i;
125
126 for (i = 0; i < ncpus; ++i)
127 cpu_set(i, cpu_possible_map);
128
129 cpu_clear(me, cpu_online_map);
130 cpu_set(me, cpu_online_map);
131 cpu_set(me, cpu_callin_map);
132
133 err = os_pipe(cpu_data[me].ipi_pipe, 1, 1);
134 if(err < 0)
135 panic("CPU#0 failed to create IPI pipe, errno = %d", -err);
136
137 activate_ipi(cpu_data[me].ipi_pipe[0],
138 current->thread.mode.tt.extern_pid);
139
140 for(cpu = 1; cpu < ncpus; cpu++){
141 printk("Booting processor %d...\n", cpu);
142
143 idle = idle_thread(cpu);
144
145 init_idle(idle, cpu);
146 unhash_process(idle);
147
148 waittime = 200000000;
149 while (waittime-- && !cpu_isset(cpu, cpu_callin_map))
150 cpu_relax();
151
152 if (cpu_isset(cpu, cpu_callin_map))
153 printk("done\n");
154 else printk("failed\n");
155 }
156}
157
158void smp_prepare_boot_cpu(void)
159{
160 cpu_set(smp_processor_id(), cpu_online_map);
161}
162
163int __cpu_up(unsigned int cpu)
164{
165 cpu_set(cpu, smp_commenced_mask);
166 while (!cpu_isset(cpu, cpu_online_map))
167 mb();
168 return(0);
169}
170
171int setup_profiling_timer(unsigned int multiplier)
172{
173 printk(KERN_INFO "setup_profiling_timer\n");
174 return(0);
175}
176
177void smp_call_function_slave(int cpu);
178
179void IPI_handler(int cpu)
180{
181 unsigned char c;
182 int fd;
183
184 fd = cpu_data[cpu].ipi_pipe[0];
185 while (os_read_file(fd, &c, 1) == 1) {
186 switch (c) {
187 case 'C':
188 smp_call_function_slave(cpu);
189 break;
190
191 case 'R':
192 set_tsk_need_resched(current);
193 break;
194
195 case 'S':
196 printk("CPU#%d stopping\n", cpu);
197 while(1)
198 pause();
199 break;
200
201 default:
202 printk("CPU#%d received unknown IPI [%c]!\n", cpu, c);
203 break;
204 }
205 }
206}
207
208int hard_smp_processor_id(void)
209{
210 return(pid_to_processor_id(os_getpid()));
211}
212
213static DEFINE_SPINLOCK(call_lock);
214static atomic_t scf_started;
215static atomic_t scf_finished;
216static void (*func)(void *info);
217static void *info;
218
219void smp_call_function_slave(int cpu)
220{
221 atomic_inc(&scf_started);
222 (*func)(info);
223 atomic_inc(&scf_finished);
224}
225
226int smp_call_function(void (*_func)(void *info), void *_info, int nonatomic,
227 int wait)
228{
229 int cpus = num_online_cpus() - 1;
230 int i;
231
232 if (!cpus)
233 return 0;
234
235 /* Can deadlock when called with interrupts disabled */
236 WARN_ON(irqs_disabled());
237
238 spin_lock_bh(&call_lock);
239 atomic_set(&scf_started, 0);
240 atomic_set(&scf_finished, 0);
241 func = _func;
242 info = _info;
243
244 for_each_online_cpu(i)
245 os_write_file(cpu_data[i].ipi_pipe[1], "C", 1);
246
247 while (atomic_read(&scf_started) != cpus)
248 barrier();
249
250 if (wait)
251 while (atomic_read(&scf_finished) != cpus)
252 barrier();
253
254 spin_unlock_bh(&call_lock);
255 return 0;
256}
257
258#endif
259
260/*
261 * Overrides for Emacs so that we follow Linus's tabbing style.
262 * Emacs will notice this stuff at the end of the file and automatically
263 * adjust the settings for this buffer only. This must remain at the end
264 * of the file.
265 * ---------------------------------------------------------------------------
266 * Local variables:
267 * c-file-style: "linux"
268 * End:
269 */