diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /arch/alpha/kernel/process.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'arch/alpha/kernel/process.c')
-rw-r--r-- | arch/alpha/kernel/process.c | 528 |
1 files changed, 528 insertions, 0 deletions
diff --git a/arch/alpha/kernel/process.c b/arch/alpha/kernel/process.c new file mode 100644 index 000000000000..4933f3ce5833 --- /dev/null +++ b/arch/alpha/kernel/process.c | |||
@@ -0,0 +1,528 @@ | |||
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 | |||
11 | #include <linux/config.h> | ||
12 | #include <linux/errno.h> | ||
13 | #include <linux/module.h> | ||
14 | #include <linux/sched.h> | ||
15 | #include <linux/kernel.h> | ||
16 | #include <linux/mm.h> | ||
17 | #include <linux/smp.h> | ||
18 | #include <linux/smp_lock.h> | ||
19 | #include <linux/stddef.h> | ||
20 | #include <linux/unistd.h> | ||
21 | #include <linux/ptrace.h> | ||
22 | #include <linux/slab.h> | ||
23 | #include <linux/user.h> | ||
24 | #include <linux/a.out.h> | ||
25 | #include <linux/utsname.h> | ||
26 | #include <linux/time.h> | ||
27 | #include <linux/major.h> | ||
28 | #include <linux/stat.h> | ||
29 | #include <linux/mman.h> | ||
30 | #include <linux/elfcore.h> | ||
31 | #include <linux/reboot.h> | ||
32 | #include <linux/tty.h> | ||
33 | #include <linux/console.h> | ||
34 | |||
35 | #include <asm/reg.h> | ||
36 | #include <asm/uaccess.h> | ||
37 | #include <asm/system.h> | ||
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 | |||
46 | void default_idle(void) | ||
47 | { | ||
48 | barrier(); | ||
49 | } | ||
50 | |||
51 | void | ||
52 | cpu_idle(void) | ||
53 | { | ||
54 | while (1) { | ||
55 | void (*idle)(void) = default_idle; | ||
56 | /* FIXME -- EV6 and LCA45 know how to power down | ||
57 | the CPU. */ | ||
58 | |||
59 | while (!need_resched()) | ||
60 | idle(); | ||
61 | schedule(); | ||
62 | } | ||
63 | } | ||
64 | |||
65 | |||
66 | struct halt_info { | ||
67 | int mode; | ||
68 | char *restart_cmd; | ||
69 | }; | ||
70 | |||
71 | static void | ||
72 | common_shutdown_1(void *generic_ptr) | ||
73 | { | ||
74 | struct halt_info *how = (struct halt_info *)generic_ptr; | ||
75 | struct percpu_struct *cpup; | ||
76 | unsigned long *pflags, flags; | ||
77 | int cpuid = smp_processor_id(); | ||
78 | |||
79 | /* No point in taking interrupts anymore. */ | ||
80 | local_irq_disable(); | ||
81 | |||
82 | cpup = (struct percpu_struct *) | ||
83 | ((unsigned long)hwrpb + hwrpb->processor_offset | ||
84 | + hwrpb->processor_size * cpuid); | ||
85 | pflags = &cpup->flags; | ||
86 | flags = *pflags; | ||
87 | |||
88 | /* Clear reason to "default"; clear "bootstrap in progress". */ | ||
89 | flags &= ~0x00ff0001UL; | ||
90 | |||
91 | #ifdef CONFIG_SMP | ||
92 | /* Secondaries halt here. */ | ||
93 | if (cpuid != boot_cpuid) { | ||
94 | flags |= 0x00040000UL; /* "remain halted" */ | ||
95 | *pflags = flags; | ||
96 | clear_bit(cpuid, &cpu_present_mask); | ||
97 | halt(); | ||
98 | } | ||
99 | #endif | ||
100 | |||
101 | if (how->mode == LINUX_REBOOT_CMD_RESTART) { | ||
102 | if (!how->restart_cmd) { | ||
103 | flags |= 0x00020000UL; /* "cold bootstrap" */ | ||
104 | } else { | ||
105 | /* For SRM, we could probably set environment | ||
106 | variables to get this to work. We'd have to | ||
107 | delay this until after srm_paging_stop unless | ||
108 | we ever got srm_fixup working. | ||
109 | |||
110 | At the moment, SRM will use the last boot device, | ||
111 | but the file and flags will be the defaults, when | ||
112 | doing a "warm" bootstrap. */ | ||
113 | flags |= 0x00030000UL; /* "warm bootstrap" */ | ||
114 | } | ||
115 | } else { | ||
116 | flags |= 0x00040000UL; /* "remain halted" */ | ||
117 | } | ||
118 | *pflags = flags; | ||
119 | |||
120 | #ifdef CONFIG_SMP | ||
121 | /* Wait for the secondaries to halt. */ | ||
122 | cpu_clear(boot_cpuid, cpu_possible_map); | ||
123 | while (cpus_weight(cpu_possible_map)) | ||
124 | barrier(); | ||
125 | #endif | ||
126 | |||
127 | /* If booted from SRM, reset some of the original environment. */ | ||
128 | if (alpha_using_srm) { | ||
129 | #ifdef CONFIG_DUMMY_CONSOLE | ||
130 | /* This has the effect of resetting the VGA video origin. */ | ||
131 | take_over_console(&dummy_con, 0, MAX_NR_CONSOLES-1, 1); | ||
132 | #endif | ||
133 | pci_restore_srm_config(); | ||
134 | set_hae(srm_hae); | ||
135 | } | ||
136 | |||
137 | if (alpha_mv.kill_arch) | ||
138 | alpha_mv.kill_arch(how->mode); | ||
139 | |||
140 | if (! alpha_using_srm && how->mode != LINUX_REBOOT_CMD_RESTART) { | ||
141 | /* Unfortunately, since MILO doesn't currently understand | ||
142 | the hwrpb bits above, we can't reliably halt the | ||
143 | processor and keep it halted. So just loop. */ | ||
144 | return; | ||
145 | } | ||
146 | |||
147 | if (alpha_using_srm) | ||
148 | srm_paging_stop(); | ||
149 | |||
150 | halt(); | ||
151 | } | ||
152 | |||
153 | static void | ||
154 | common_shutdown(int mode, char *restart_cmd) | ||
155 | { | ||
156 | struct halt_info args; | ||
157 | args.mode = mode; | ||
158 | args.restart_cmd = restart_cmd; | ||
159 | on_each_cpu(common_shutdown_1, &args, 1, 0); | ||
160 | } | ||
161 | |||
162 | void | ||
163 | machine_restart(char *restart_cmd) | ||
164 | { | ||
165 | common_shutdown(LINUX_REBOOT_CMD_RESTART, restart_cmd); | ||
166 | } | ||
167 | |||
168 | EXPORT_SYMBOL(machine_restart); | ||
169 | |||
170 | void | ||
171 | machine_halt(void) | ||
172 | { | ||
173 | common_shutdown(LINUX_REBOOT_CMD_HALT, NULL); | ||
174 | } | ||
175 | |||
176 | EXPORT_SYMBOL(machine_halt); | ||
177 | |||
178 | void | ||
179 | machine_power_off(void) | ||
180 | { | ||
181 | common_shutdown(LINUX_REBOOT_CMD_POWER_OFF, NULL); | ||
182 | } | ||
183 | |||
184 | EXPORT_SYMBOL(machine_power_off); | ||
185 | |||
186 | /* Used by sysrq-p, among others. I don't believe r9-r15 are ever | ||
187 | saved in the context it's used. */ | ||
188 | |||
189 | void | ||
190 | show_regs(struct pt_regs *regs) | ||
191 | { | ||
192 | dik_show_regs(regs, NULL); | ||
193 | } | ||
194 | |||
195 | /* | ||
196 | * Re-start a thread when doing execve() | ||
197 | */ | ||
198 | void | ||
199 | start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp) | ||
200 | { | ||
201 | set_fs(USER_DS); | ||
202 | regs->pc = pc; | ||
203 | regs->ps = 8; | ||
204 | wrusp(sp); | ||
205 | } | ||
206 | |||
207 | /* | ||
208 | * Free current thread data structures etc.. | ||
209 | */ | ||
210 | void | ||
211 | exit_thread(void) | ||
212 | { | ||
213 | } | ||
214 | |||
215 | void | ||
216 | flush_thread(void) | ||
217 | { | ||
218 | /* Arrange for each exec'ed process to start off with a clean slate | ||
219 | with respect to the FPU. This is all exceptions disabled. */ | ||
220 | current_thread_info()->ieee_state = 0; | ||
221 | wrfpcr(FPCR_DYN_NORMAL | ieee_swcr_to_fpcr(0)); | ||
222 | |||
223 | /* Clean slate for TLS. */ | ||
224 | current_thread_info()->pcb.unique = 0; | ||
225 | } | ||
226 | |||
227 | void | ||
228 | release_thread(struct task_struct *dead_task) | ||
229 | { | ||
230 | } | ||
231 | |||
232 | /* | ||
233 | * "alpha_clone()".. By the time we get here, the | ||
234 | * non-volatile registers have also been saved on the | ||
235 | * stack. We do some ugly pointer stuff here.. (see | ||
236 | * also copy_thread) | ||
237 | * | ||
238 | * Notice that "fork()" is implemented in terms of clone, | ||
239 | * with parameters (SIGCHLD, 0). | ||
240 | */ | ||
241 | int | ||
242 | alpha_clone(unsigned long clone_flags, unsigned long usp, | ||
243 | int __user *parent_tid, int __user *child_tid, | ||
244 | unsigned long tls_value, struct pt_regs *regs) | ||
245 | { | ||
246 | if (!usp) | ||
247 | usp = rdusp(); | ||
248 | |||
249 | return do_fork(clone_flags, usp, regs, 0, parent_tid, child_tid); | ||
250 | } | ||
251 | |||
252 | int | ||
253 | alpha_vfork(struct pt_regs *regs) | ||
254 | { | ||
255 | return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), | ||
256 | regs, 0, NULL, NULL); | ||
257 | } | ||
258 | |||
259 | /* | ||
260 | * Copy an alpha thread.. | ||
261 | * | ||
262 | * Note the "stack_offset" stuff: when returning to kernel mode, we need | ||
263 | * to have some extra stack-space for the kernel stack that still exists | ||
264 | * after the "ret_from_fork". When returning to user mode, we only want | ||
265 | * the space needed by the syscall stack frame (ie "struct pt_regs"). | ||
266 | * Use the passed "regs" pointer to determine how much space we need | ||
267 | * for a kernel fork(). | ||
268 | */ | ||
269 | |||
270 | int | ||
271 | copy_thread(int nr, unsigned long clone_flags, unsigned long usp, | ||
272 | unsigned long unused, | ||
273 | struct task_struct * p, struct pt_regs * regs) | ||
274 | { | ||
275 | extern void ret_from_fork(void); | ||
276 | |||
277 | struct thread_info *childti = p->thread_info; | ||
278 | struct pt_regs * childregs; | ||
279 | struct switch_stack * childstack, *stack; | ||
280 | unsigned long stack_offset, settls; | ||
281 | |||
282 | stack_offset = PAGE_SIZE - sizeof(struct pt_regs); | ||
283 | if (!(regs->ps & 8)) | ||
284 | stack_offset = (PAGE_SIZE-1) & (unsigned long) regs; | ||
285 | childregs = (struct pt_regs *) | ||
286 | (stack_offset + PAGE_SIZE + (long) childti); | ||
287 | |||
288 | *childregs = *regs; | ||
289 | settls = regs->r20; | ||
290 | childregs->r0 = 0; | ||
291 | childregs->r19 = 0; | ||
292 | childregs->r20 = 1; /* OSF/1 has some strange fork() semantics. */ | ||
293 | regs->r20 = 0; | ||
294 | stack = ((struct switch_stack *) regs) - 1; | ||
295 | childstack = ((struct switch_stack *) childregs) - 1; | ||
296 | *childstack = *stack; | ||
297 | childstack->r26 = (unsigned long) ret_from_fork; | ||
298 | childti->pcb.usp = usp; | ||
299 | childti->pcb.ksp = (unsigned long) childstack; | ||
300 | childti->pcb.flags = 1; /* set FEN, clear everything else */ | ||
301 | |||
302 | /* Set a new TLS for the child thread? Peek back into the | ||
303 | syscall arguments that we saved on syscall entry. Oops, | ||
304 | except we'd have clobbered it with the parent/child set | ||
305 | of r20. Read the saved copy. */ | ||
306 | /* Note: if CLONE_SETTLS is not set, then we must inherit the | ||
307 | value from the parent, which will have been set by the block | ||
308 | copy in dup_task_struct. This is non-intuitive, but is | ||
309 | required for proper operation in the case of a threaded | ||
310 | application calling fork. */ | ||
311 | if (clone_flags & CLONE_SETTLS) | ||
312 | childti->pcb.unique = settls; | ||
313 | |||
314 | return 0; | ||
315 | } | ||
316 | |||
317 | /* | ||
318 | * Fill in the user structure for an ECOFF core dump. | ||
319 | */ | ||
320 | void | ||
321 | dump_thread(struct pt_regs * pt, struct user * dump) | ||
322 | { | ||
323 | /* switch stack follows right below pt_regs: */ | ||
324 | struct switch_stack * sw = ((struct switch_stack *) pt) - 1; | ||
325 | |||
326 | dump->magic = CMAGIC; | ||
327 | dump->start_code = current->mm->start_code; | ||
328 | dump->start_data = current->mm->start_data; | ||
329 | dump->start_stack = rdusp() & ~(PAGE_SIZE - 1); | ||
330 | dump->u_tsize = ((current->mm->end_code - dump->start_code) | ||
331 | >> PAGE_SHIFT); | ||
332 | dump->u_dsize = ((current->mm->brk + PAGE_SIZE-1 - dump->start_data) | ||
333 | >> PAGE_SHIFT); | ||
334 | dump->u_ssize = (current->mm->start_stack - dump->start_stack | ||
335 | + PAGE_SIZE-1) >> PAGE_SHIFT; | ||
336 | |||
337 | /* | ||
338 | * We store the registers in an order/format that is | ||
339 | * compatible with DEC Unix/OSF/1 as this makes life easier | ||
340 | * for gdb. | ||
341 | */ | ||
342 | dump->regs[EF_V0] = pt->r0; | ||
343 | dump->regs[EF_T0] = pt->r1; | ||
344 | dump->regs[EF_T1] = pt->r2; | ||
345 | dump->regs[EF_T2] = pt->r3; | ||
346 | dump->regs[EF_T3] = pt->r4; | ||
347 | dump->regs[EF_T4] = pt->r5; | ||
348 | dump->regs[EF_T5] = pt->r6; | ||
349 | dump->regs[EF_T6] = pt->r7; | ||
350 | dump->regs[EF_T7] = pt->r8; | ||
351 | dump->regs[EF_S0] = sw->r9; | ||
352 | dump->regs[EF_S1] = sw->r10; | ||
353 | dump->regs[EF_S2] = sw->r11; | ||
354 | dump->regs[EF_S3] = sw->r12; | ||
355 | dump->regs[EF_S4] = sw->r13; | ||
356 | dump->regs[EF_S5] = sw->r14; | ||
357 | dump->regs[EF_S6] = sw->r15; | ||
358 | dump->regs[EF_A3] = pt->r19; | ||
359 | dump->regs[EF_A4] = pt->r20; | ||
360 | dump->regs[EF_A5] = pt->r21; | ||
361 | dump->regs[EF_T8] = pt->r22; | ||
362 | dump->regs[EF_T9] = pt->r23; | ||
363 | dump->regs[EF_T10] = pt->r24; | ||
364 | dump->regs[EF_T11] = pt->r25; | ||
365 | dump->regs[EF_RA] = pt->r26; | ||
366 | dump->regs[EF_T12] = pt->r27; | ||
367 | dump->regs[EF_AT] = pt->r28; | ||
368 | dump->regs[EF_SP] = rdusp(); | ||
369 | dump->regs[EF_PS] = pt->ps; | ||
370 | dump->regs[EF_PC] = pt->pc; | ||
371 | dump->regs[EF_GP] = pt->gp; | ||
372 | dump->regs[EF_A0] = pt->r16; | ||
373 | dump->regs[EF_A1] = pt->r17; | ||
374 | dump->regs[EF_A2] = pt->r18; | ||
375 | memcpy((char *)dump->regs + EF_SIZE, sw->fp, 32 * 8); | ||
376 | } | ||
377 | |||
378 | /* | ||
379 | * Fill in the user structure for a ELF core dump. | ||
380 | */ | ||
381 | void | ||
382 | dump_elf_thread(elf_greg_t *dest, struct pt_regs *pt, struct thread_info *ti) | ||
383 | { | ||
384 | /* switch stack follows right below pt_regs: */ | ||
385 | struct switch_stack * sw = ((struct switch_stack *) pt) - 1; | ||
386 | |||
387 | dest[ 0] = pt->r0; | ||
388 | dest[ 1] = pt->r1; | ||
389 | dest[ 2] = pt->r2; | ||
390 | dest[ 3] = pt->r3; | ||
391 | dest[ 4] = pt->r4; | ||
392 | dest[ 5] = pt->r5; | ||
393 | dest[ 6] = pt->r6; | ||
394 | dest[ 7] = pt->r7; | ||
395 | dest[ 8] = pt->r8; | ||
396 | dest[ 9] = sw->r9; | ||
397 | dest[10] = sw->r10; | ||
398 | dest[11] = sw->r11; | ||
399 | dest[12] = sw->r12; | ||
400 | dest[13] = sw->r13; | ||
401 | dest[14] = sw->r14; | ||
402 | dest[15] = sw->r15; | ||
403 | dest[16] = pt->r16; | ||
404 | dest[17] = pt->r17; | ||
405 | dest[18] = pt->r18; | ||
406 | dest[19] = pt->r19; | ||
407 | dest[20] = pt->r20; | ||
408 | dest[21] = pt->r21; | ||
409 | dest[22] = pt->r22; | ||
410 | dest[23] = pt->r23; | ||
411 | dest[24] = pt->r24; | ||
412 | dest[25] = pt->r25; | ||
413 | dest[26] = pt->r26; | ||
414 | dest[27] = pt->r27; | ||
415 | dest[28] = pt->r28; | ||
416 | dest[29] = pt->gp; | ||
417 | dest[30] = rdusp(); | ||
418 | dest[31] = pt->pc; | ||
419 | |||
420 | /* Once upon a time this was the PS value. Which is stupid | ||
421 | since that is always 8 for usermode. Usurped for the more | ||
422 | useful value of the thread's UNIQUE field. */ | ||
423 | dest[32] = ti->pcb.unique; | ||
424 | } | ||
425 | |||
426 | int | ||
427 | dump_elf_task(elf_greg_t *dest, struct task_struct *task) | ||
428 | { | ||
429 | struct thread_info *ti; | ||
430 | struct pt_regs *pt; | ||
431 | |||
432 | ti = task->thread_info; | ||
433 | pt = (struct pt_regs *)((unsigned long)ti + 2*PAGE_SIZE) - 1; | ||
434 | |||
435 | dump_elf_thread(dest, pt, ti); | ||
436 | |||
437 | return 1; | ||
438 | } | ||
439 | |||
440 | int | ||
441 | dump_elf_task_fp(elf_fpreg_t *dest, struct task_struct *task) | ||
442 | { | ||
443 | struct thread_info *ti; | ||
444 | struct pt_regs *pt; | ||
445 | struct switch_stack *sw; | ||
446 | |||
447 | ti = task->thread_info; | ||
448 | pt = (struct pt_regs *)((unsigned long)ti + 2*PAGE_SIZE) - 1; | ||
449 | sw = (struct switch_stack *)pt - 1; | ||
450 | |||
451 | memcpy(dest, sw->fp, 32 * 8); | ||
452 | |||
453 | return 1; | ||
454 | } | ||
455 | |||
456 | /* | ||
457 | * sys_execve() executes a new program. | ||
458 | */ | ||
459 | asmlinkage int | ||
460 | do_sys_execve(char __user *ufilename, char __user * __user *argv, | ||
461 | char __user * __user *envp, struct pt_regs *regs) | ||
462 | { | ||
463 | int error; | ||
464 | char *filename; | ||
465 | |||
466 | filename = getname(ufilename); | ||
467 | error = PTR_ERR(filename); | ||
468 | if (IS_ERR(filename)) | ||
469 | goto out; | ||
470 | error = do_execve(filename, argv, envp, regs); | ||
471 | putname(filename); | ||
472 | out: | ||
473 | return error; | ||
474 | } | ||
475 | |||
476 | /* | ||
477 | * Return saved PC of a blocked thread. This assumes the frame | ||
478 | * pointer is the 6th saved long on the kernel stack and that the | ||
479 | * saved return address is the first long in the frame. This all | ||
480 | * holds provided the thread blocked through a call to schedule() ($15 | ||
481 | * is the frame pointer in schedule() and $15 is saved at offset 48 by | ||
482 | * entry.S:do_switch_stack). | ||
483 | * | ||
484 | * Under heavy swap load I've seen this lose in an ugly way. So do | ||
485 | * some extra sanity checking on the ranges we expect these pointers | ||
486 | * to be in so that we can fail gracefully. This is just for ps after | ||
487 | * all. -- r~ | ||
488 | */ | ||
489 | |||
490 | unsigned long | ||
491 | thread_saved_pc(task_t *t) | ||
492 | { | ||
493 | unsigned long base = (unsigned long)t->thread_info; | ||
494 | unsigned long fp, sp = t->thread_info->pcb.ksp; | ||
495 | |||
496 | if (sp > base && sp+6*8 < base + 16*1024) { | ||
497 | fp = ((unsigned long*)sp)[6]; | ||
498 | if (fp > sp && fp < base + 16*1024) | ||
499 | return *(unsigned long *)fp; | ||
500 | } | ||
501 | |||
502 | return 0; | ||
503 | } | ||
504 | |||
505 | unsigned long | ||
506 | get_wchan(struct task_struct *p) | ||
507 | { | ||
508 | unsigned long schedule_frame; | ||
509 | unsigned long pc; | ||
510 | if (!p || p == current || p->state == TASK_RUNNING) | ||
511 | return 0; | ||
512 | /* | ||
513 | * This one depends on the frame size of schedule(). Do a | ||
514 | * "disass schedule" in gdb to find the frame size. Also, the | ||
515 | * code assumes that sleep_on() follows immediately after | ||
516 | * interruptible_sleep_on() and that add_timer() follows | ||
517 | * immediately after interruptible_sleep(). Ugly, isn't it? | ||
518 | * Maybe adding a wchan field to task_struct would be better, | ||
519 | * after all... | ||
520 | */ | ||
521 | |||
522 | pc = thread_saved_pc(p); | ||
523 | if (in_sched_functions(pc)) { | ||
524 | schedule_frame = ((unsigned long *)p->thread_info->pcb.ksp)[6]; | ||
525 | return ((unsigned long *)schedule_frame)[12]; | ||
526 | } | ||
527 | return pc; | ||
528 | } | ||