Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/arch/alpha/kernel/process.c | |
3 | * | |
4 | * Copyright (C) 1995 Linus Torvalds | |
5 | */ | |
6 | ||
7 | /* | |
8 | * This file handles the architecture-dependent parts of process handling. | |
9 | */ | |
10 | ||
1da177e4 LT |
11 | #include <linux/errno.h> |
12 | #include <linux/module.h> | |
13 | #include <linux/sched.h> | |
b17b0153 | 14 | #include <linux/sched/debug.h> |
29930025 | 15 | #include <linux/sched/task.h> |
68db0cf1 | 16 | #include <linux/sched/task_stack.h> |
1da177e4 LT |
17 | #include <linux/kernel.h> |
18 | #include <linux/mm.h> | |
19 | #include <linux/smp.h> | |
1da177e4 LT |
20 | #include <linux/stddef.h> |
21 | #include <linux/unistd.h> | |
22 | #include <linux/ptrace.h> | |
1da177e4 | 23 | #include <linux/user.h> |
1da177e4 LT |
24 | #include <linux/time.h> |
25 | #include <linux/major.h> | |
26 | #include <linux/stat.h> | |
a8f340e3 | 27 | #include <linux/vt.h> |
1da177e4 LT |
28 | #include <linux/mman.h> |
29 | #include <linux/elfcore.h> | |
30 | #include <linux/reboot.h> | |
31 | #include <linux/tty.h> | |
32 | #include <linux/console.h> | |
5a0e3ad6 | 33 | #include <linux/slab.h> |
4c94cada | 34 | #include <linux/rcupdate.h> |
1da177e4 LT |
35 | |
36 | #include <asm/reg.h> | |
7c0f6ba6 | 37 | #include <linux/uaccess.h> |
1da177e4 LT |
38 | #include <asm/io.h> |
39 | #include <asm/pgtable.h> | |
40 | #include <asm/hwrpb.h> | |
41 | #include <asm/fpu.h> | |
42 | ||
43 | #include "proto.h" | |
44 | #include "pci_impl.h" | |
45 | ||
5e38291d EB |
46 | /* |
47 | * Power off function, if any | |
48 | */ | |
49 | void (*pm_power_off)(void) = machine_power_off; | |
89eb1693 | 50 | EXPORT_SYMBOL(pm_power_off); |
5e38291d | 51 | |
7f3bbb82 RH |
52 | #ifdef CONFIG_ALPHA_WTINT |
53 | /* | |
54 | * Sleep the CPU. | |
55 | * EV6, LCA45 and QEMU know how to power down, skipping N timer interrupts. | |
56 | */ | |
57 | void arch_cpu_idle(void) | |
58 | { | |
59 | wtint(0); | |
60 | local_irq_enable(); | |
61 | } | |
62 | ||
63 | void arch_cpu_idle_dead(void) | |
64 | { | |
65 | wtint(INT_MAX); | |
66 | } | |
67 | #endif /* ALPHA_WTINT */ | |
68 | ||
1da177e4 LT |
69 | struct halt_info { |
70 | int mode; | |
71 | char *restart_cmd; | |
72 | }; | |
73 | ||
74 | static void | |
75 | common_shutdown_1(void *generic_ptr) | |
76 | { | |
77 | struct halt_info *how = (struct halt_info *)generic_ptr; | |
78 | struct percpu_struct *cpup; | |
79 | unsigned long *pflags, flags; | |
80 | int cpuid = smp_processor_id(); | |
81 | ||
82 | /* No point in taking interrupts anymore. */ | |
83 | local_irq_disable(); | |
84 | ||
85 | cpup = (struct percpu_struct *) | |
86 | ((unsigned long)hwrpb + hwrpb->processor_offset | |
87 | + hwrpb->processor_size * cpuid); | |
88 | pflags = &cpup->flags; | |
89 | flags = *pflags; | |
90 | ||
91 | /* Clear reason to "default"; clear "bootstrap in progress". */ | |
92 | flags &= ~0x00ff0001UL; | |
93 | ||
94 | #ifdef CONFIG_SMP | |
95 | /* Secondaries halt here. */ | |
96 | if (cpuid != boot_cpuid) { | |
97 | flags |= 0x00040000UL; /* "remain halted" */ | |
98 | *pflags = flags; | |
1371be0f RR |
99 | set_cpu_present(cpuid, false); |
100 | set_cpu_possible(cpuid, false); | |
1da177e4 LT |
101 | halt(); |
102 | } | |
103 | #endif | |
104 | ||
105 | if (how->mode == LINUX_REBOOT_CMD_RESTART) { | |
106 | if (!how->restart_cmd) { | |
107 | flags |= 0x00020000UL; /* "cold bootstrap" */ | |
108 | } else { | |
109 | /* For SRM, we could probably set environment | |
110 | variables to get this to work. We'd have to | |
111 | delay this until after srm_paging_stop unless | |
112 | we ever got srm_fixup working. | |
113 | ||
114 | At the moment, SRM will use the last boot device, | |
115 | but the file and flags will be the defaults, when | |
116 | doing a "warm" bootstrap. */ | |
117 | flags |= 0x00030000UL; /* "warm bootstrap" */ | |
118 | } | |
119 | } else { | |
120 | flags |= 0x00040000UL; /* "remain halted" */ | |
121 | } | |
122 | *pflags = flags; | |
123 | ||
124 | #ifdef CONFIG_SMP | |
125 | /* Wait for the secondaries to halt. */ | |
1371be0f RR |
126 | set_cpu_present(boot_cpuid, false); |
127 | set_cpu_possible(boot_cpuid, false); | |
81740fc6 | 128 | while (cpumask_weight(cpu_present_mask)) |
1da177e4 LT |
129 | barrier(); |
130 | #endif | |
131 | ||
132 | /* If booted from SRM, reset some of the original environment. */ | |
133 | if (alpha_using_srm) { | |
134 | #ifdef CONFIG_DUMMY_CONSOLE | |
4b3c86a7 IK |
135 | /* If we've gotten here after SysRq-b, leave interrupt |
136 | context before taking over the console. */ | |
137 | if (in_interrupt()) | |
138 | irq_exit(); | |
1da177e4 | 139 | /* This has the effect of resetting the VGA video origin. */ |
155957f5 WY |
140 | console_lock(); |
141 | do_take_over_console(&dummy_con, 0, MAX_NR_CONSOLES-1, 1); | |
142 | console_unlock(); | |
1da177e4 LT |
143 | #endif |
144 | pci_restore_srm_config(); | |
145 | set_hae(srm_hae); | |
146 | } | |
147 | ||
148 | if (alpha_mv.kill_arch) | |
149 | alpha_mv.kill_arch(how->mode); | |
150 | ||
151 | if (! alpha_using_srm && how->mode != LINUX_REBOOT_CMD_RESTART) { | |
152 | /* Unfortunately, since MILO doesn't currently understand | |
153 | the hwrpb bits above, we can't reliably halt the | |
154 | processor and keep it halted. So just loop. */ | |
155 | return; | |
156 | } | |
157 | ||
158 | if (alpha_using_srm) | |
159 | srm_paging_stop(); | |
160 | ||
161 | halt(); | |
162 | } | |
163 | ||
164 | static void | |
165 | common_shutdown(int mode, char *restart_cmd) | |
166 | { | |
167 | struct halt_info args; | |
168 | args.mode = mode; | |
169 | args.restart_cmd = restart_cmd; | |
15c8b6c1 | 170 | on_each_cpu(common_shutdown_1, &args, 0); |
1da177e4 LT |
171 | } |
172 | ||
173 | void | |
174 | machine_restart(char *restart_cmd) | |
175 | { | |
176 | common_shutdown(LINUX_REBOOT_CMD_RESTART, restart_cmd); | |
177 | } | |
178 | ||
1da177e4 LT |
179 | |
180 | void | |
181 | machine_halt(void) | |
182 | { | |
183 | common_shutdown(LINUX_REBOOT_CMD_HALT, NULL); | |
184 | } | |
185 | ||
1da177e4 LT |
186 | |
187 | void | |
188 | machine_power_off(void) | |
189 | { | |
190 | common_shutdown(LINUX_REBOOT_CMD_POWER_OFF, NULL); | |
191 | } | |
192 | ||
1da177e4 LT |
193 | |
194 | /* Used by sysrq-p, among others. I don't believe r9-r15 are ever | |
195 | saved in the context it's used. */ | |
196 | ||
197 | void | |
198 | show_regs(struct pt_regs *regs) | |
199 | { | |
a43cb95d | 200 | show_regs_print_info(KERN_DEFAULT); |
1da177e4 LT |
201 | dik_show_regs(regs, NULL); |
202 | } | |
203 | ||
204 | /* | |
205 | * Re-start a thread when doing execve() | |
206 | */ | |
207 | void | |
208 | start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp) | |
209 | { | |
1da177e4 LT |
210 | regs->pc = pc; |
211 | regs->ps = 8; | |
212 | wrusp(sp); | |
213 | } | |
cff52daf | 214 | EXPORT_SYMBOL(start_thread); |
1da177e4 | 215 | |
1da177e4 LT |
216 | void |
217 | flush_thread(void) | |
218 | { | |
219 | /* Arrange for each exec'ed process to start off with a clean slate | |
220 | with respect to the FPU. This is all exceptions disabled. */ | |
221 | current_thread_info()->ieee_state = 0; | |
222 | wrfpcr(FPCR_DYN_NORMAL | ieee_swcr_to_fpcr(0)); | |
223 | ||
224 | /* Clean slate for TLS. */ | |
225 | current_thread_info()->pcb.unique = 0; | |
226 | } | |
227 | ||
228 | void | |
229 | release_thread(struct task_struct *dead_task) | |
230 | { | |
231 | } | |
232 | ||
1da177e4 | 233 | /* |
9f7b2d1f | 234 | * Copy architecture-specific thread state |
1da177e4 | 235 | */ |
1da177e4 | 236 | int |
6f2c55b8 | 237 | copy_thread(unsigned long clone_flags, unsigned long usp, |
9f7b2d1f | 238 | unsigned long kthread_arg, |
afa86fc4 | 239 | struct task_struct *p) |
1da177e4 LT |
240 | { |
241 | extern void ret_from_fork(void); | |
cba1ec7e | 242 | extern void ret_from_kernel_thread(void); |
1da177e4 | 243 | |
27f45130 | 244 | struct thread_info *childti = task_thread_info(p); |
cba1ec7e | 245 | struct pt_regs *childregs = task_pt_regs(p); |
25906730 | 246 | struct pt_regs *regs = current_pt_regs(); |
cba1ec7e | 247 | struct switch_stack *childstack, *stack; |
cba1ec7e AV |
248 | |
249 | childstack = ((struct switch_stack *) childregs) - 1; | |
25906730 AV |
250 | childti->pcb.ksp = (unsigned long) childstack; |
251 | childti->pcb.flags = 1; /* set FEN, clear everything else */ | |
252 | ||
253 | if (unlikely(p->flags & PF_KTHREAD)) { | |
cba1ec7e AV |
254 | /* kernel thread */ |
255 | memset(childstack, 0, | |
256 | sizeof(struct switch_stack) + sizeof(struct pt_regs)); | |
257 | childstack->r26 = (unsigned long) ret_from_kernel_thread; | |
258 | childstack->r9 = usp; /* function */ | |
9f7b2d1f | 259 | childstack->r10 = kthread_arg; |
cba1ec7e AV |
260 | childregs->hae = alpha_mv.hae_cache, |
261 | childti->pcb.usp = 0; | |
cba1ec7e AV |
262 | return 0; |
263 | } | |
25906730 AV |
264 | /* Note: if CLONE_SETTLS is not set, then we must inherit the |
265 | value from the parent, which will have been set by the block | |
266 | copy in dup_task_struct. This is non-intuitive, but is | |
267 | required for proper operation in the case of a threaded | |
268 | application calling fork. */ | |
269 | if (clone_flags & CLONE_SETTLS) | |
270 | childti->pcb.unique = regs->r20; | |
271 | childti->pcb.usp = usp ?: rdusp(); | |
1da177e4 | 272 | *childregs = *regs; |
1da177e4 LT |
273 | childregs->r0 = 0; |
274 | childregs->r19 = 0; | |
275 | childregs->r20 = 1; /* OSF/1 has some strange fork() semantics. */ | |
276 | regs->r20 = 0; | |
277 | stack = ((struct switch_stack *) regs) - 1; | |
1da177e4 LT |
278 | *childstack = *stack; |
279 | childstack->r26 = (unsigned long) ret_from_fork; | |
1da177e4 LT |
280 | return 0; |
281 | } | |
282 | ||
1da177e4 LT |
283 | /* |
284 | * Fill in the user structure for a ELF core dump. | |
285 | */ | |
286 | void | |
287 | dump_elf_thread(elf_greg_t *dest, struct pt_regs *pt, struct thread_info *ti) | |
288 | { | |
289 | /* switch stack follows right below pt_regs: */ | |
290 | struct switch_stack * sw = ((struct switch_stack *) pt) - 1; | |
291 | ||
292 | dest[ 0] = pt->r0; | |
293 | dest[ 1] = pt->r1; | |
294 | dest[ 2] = pt->r2; | |
295 | dest[ 3] = pt->r3; | |
296 | dest[ 4] = pt->r4; | |
297 | dest[ 5] = pt->r5; | |
298 | dest[ 6] = pt->r6; | |
299 | dest[ 7] = pt->r7; | |
300 | dest[ 8] = pt->r8; | |
301 | dest[ 9] = sw->r9; | |
302 | dest[10] = sw->r10; | |
303 | dest[11] = sw->r11; | |
304 | dest[12] = sw->r12; | |
305 | dest[13] = sw->r13; | |
306 | dest[14] = sw->r14; | |
307 | dest[15] = sw->r15; | |
308 | dest[16] = pt->r16; | |
309 | dest[17] = pt->r17; | |
310 | dest[18] = pt->r18; | |
311 | dest[19] = pt->r19; | |
312 | dest[20] = pt->r20; | |
313 | dest[21] = pt->r21; | |
314 | dest[22] = pt->r22; | |
315 | dest[23] = pt->r23; | |
316 | dest[24] = pt->r24; | |
317 | dest[25] = pt->r25; | |
318 | dest[26] = pt->r26; | |
319 | dest[27] = pt->r27; | |
320 | dest[28] = pt->r28; | |
321 | dest[29] = pt->gp; | |
32163f4b | 322 | dest[30] = ti == current_thread_info() ? rdusp() : ti->pcb.usp; |
1da177e4 LT |
323 | dest[31] = pt->pc; |
324 | ||
325 | /* Once upon a time this was the PS value. Which is stupid | |
326 | since that is always 8 for usermode. Usurped for the more | |
327 | useful value of the thread's UNIQUE field. */ | |
328 | dest[32] = ti->pcb.unique; | |
329 | } | |
cff52daf | 330 | EXPORT_SYMBOL(dump_elf_thread); |
1da177e4 LT |
331 | |
332 | int | |
333 | dump_elf_task(elf_greg_t *dest, struct task_struct *task) | |
334 | { | |
e52f4ca2 | 335 | dump_elf_thread(dest, task_pt_regs(task), task_thread_info(task)); |
1da177e4 LT |
336 | return 1; |
337 | } | |
cff52daf | 338 | EXPORT_SYMBOL(dump_elf_task); |
1da177e4 LT |
339 | |
340 | int | |
341 | dump_elf_task_fp(elf_fpreg_t *dest, struct task_struct *task) | |
342 | { | |
e52f4ca2 | 343 | struct switch_stack *sw = (struct switch_stack *)task_pt_regs(task) - 1; |
1da177e4 | 344 | memcpy(dest, sw->fp, 32 * 8); |
1da177e4 LT |
345 | return 1; |
346 | } | |
cff52daf | 347 | EXPORT_SYMBOL(dump_elf_task_fp); |
1da177e4 | 348 | |
1da177e4 LT |
349 | /* |
350 | * Return saved PC of a blocked thread. This assumes the frame | |
351 | * pointer is the 6th saved long on the kernel stack and that the | |
352 | * saved return address is the first long in the frame. This all | |
353 | * holds provided the thread blocked through a call to schedule() ($15 | |
354 | * is the frame pointer in schedule() and $15 is saved at offset 48 by | |
355 | * entry.S:do_switch_stack). | |
356 | * | |
357 | * Under heavy swap load I've seen this lose in an ugly way. So do | |
358 | * some extra sanity checking on the ranges we expect these pointers | |
359 | * to be in so that we can fail gracefully. This is just for ps after | |
360 | * all. -- r~ | |
361 | */ | |
362 | ||
363 | unsigned long | |
36c8b586 | 364 | thread_saved_pc(struct task_struct *t) |
1da177e4 | 365 | { |
27f45130 | 366 | unsigned long base = (unsigned long)task_stack_page(t); |
37bfbaf9 | 367 | unsigned long fp, sp = task_thread_info(t)->pcb.ksp; |
1da177e4 LT |
368 | |
369 | if (sp > base && sp+6*8 < base + 16*1024) { | |
370 | fp = ((unsigned long*)sp)[6]; | |
371 | if (fp > sp && fp < base + 16*1024) | |
372 | return *(unsigned long *)fp; | |
373 | } | |
374 | ||
375 | return 0; | |
376 | } | |
377 | ||
378 | unsigned long | |
379 | get_wchan(struct task_struct *p) | |
380 | { | |
381 | unsigned long schedule_frame; | |
382 | unsigned long pc; | |
383 | if (!p || p == current || p->state == TASK_RUNNING) | |
384 | return 0; | |
385 | /* | |
386 | * This one depends on the frame size of schedule(). Do a | |
387 | * "disass schedule" in gdb to find the frame size. Also, the | |
388 | * code assumes that sleep_on() follows immediately after | |
389 | * interruptible_sleep_on() and that add_timer() follows | |
390 | * immediately after interruptible_sleep(). Ugly, isn't it? | |
391 | * Maybe adding a wchan field to task_struct would be better, | |
392 | * after all... | |
393 | */ | |
394 | ||
395 | pc = thread_saved_pc(p); | |
396 | if (in_sched_functions(pc)) { | |
37bfbaf9 | 397 | schedule_frame = ((unsigned long *)task_thread_info(p)->pcb.ksp)[6]; |
1da177e4 LT |
398 | return ((unsigned long *)schedule_frame)[12]; |
399 | } | |
400 | return pc; | |
401 | } |