1 /* 2 * linux/arch/m68k/kernel/process.c 3 * 4 * Copyright (C) 1995 Hamish Macdonald 5 * 6 * 68060 fixes by Jesper Skov 7 */ 8 9 /* 10 * This file handles the architecture-dependent parts of process handling.. 11 */ 12 13 #include <linux/errno.h> 14 #include <linux/module.h> 15 #include <linux/sched.h> 16 #include <linux/kernel.h> 17 #include <linux/mm.h> 18 #include <linux/slab.h> 19 #include <linux/fs.h> 20 #include <linux/smp.h> 21 #include <linux/stddef.h> 22 #include <linux/unistd.h> 23 #include <linux/ptrace.h> 24 #include <linux/user.h> 25 #include <linux/reboot.h> 26 #include <linux/init_task.h> 27 #include <linux/mqueue.h> 28 #include <linux/rcupdate.h> 29 30 #include <asm/uaccess.h> 31 #include <asm/traps.h> 32 #include <asm/machdep.h> 33 #include <asm/setup.h> 34 #include <asm/pgtable.h> 35 36 37 asmlinkage void ret_from_fork(void); 38 asmlinkage void ret_from_kernel_thread(void); 39 40 41 /* 42 * Return saved PC from a blocked thread 43 */ 44 unsigned long thread_saved_pc(struct task_struct *tsk) 45 { 46 struct switch_stack *sw = (struct switch_stack *)tsk->thread.ksp; 47 /* Check whether the thread is blocked in resume() */ 48 if (in_sched_functions(sw->retpc)) 49 return ((unsigned long *)sw->a6)[1]; 50 else 51 return sw->retpc; 52 } 53 54 void arch_cpu_idle(void) 55 { 56 #if defined(MACH_ATARI_ONLY) 57 /* block out HSYNC on the atari (falcon) */ 58 __asm__("stop #0x2200" : : : "cc"); 59 #else 60 __asm__("stop #0x2000" : : : "cc"); 61 #endif 62 } 63 64 void machine_restart(char * __unused) 65 { 66 if (mach_reset) 67 mach_reset(); 68 for (;;); 69 } 70 71 void machine_halt(void) 72 { 73 if (mach_halt) 74 mach_halt(); 75 for (;;); 76 } 77 78 void machine_power_off(void) 79 { 80 if (mach_power_off) 81 mach_power_off(); 82 for (;;); 83 } 84 85 void (*pm_power_off)(void) = machine_power_off; 86 EXPORT_SYMBOL(pm_power_off); 87 88 void show_regs(struct pt_regs * regs) 89 { 90 printk("\n"); 91 printk("Format %02x Vector: %04x PC: %08lx Status: %04x %s\n", 92 regs->format, regs->vector, regs->pc, regs->sr, print_tainted()); 93 printk("ORIG_D0: %08lx D0: %08lx A2: %08lx A1: %08lx\n", 94 regs->orig_d0, regs->d0, regs->a2, regs->a1); 95 printk("A0: %08lx D5: %08lx D4: %08lx\n", 96 regs->a0, regs->d5, regs->d4); 97 printk("D3: %08lx D2: %08lx D1: %08lx\n", 98 regs->d3, regs->d2, regs->d1); 99 if (!(regs->sr & PS_S)) 100 printk("USP: %08lx\n", rdusp()); 101 } 102 103 void flush_thread(void) 104 { 105 current->thread.fs = __USER_DS; 106 #ifdef CONFIG_FPU 107 if (!FPU_IS_EMU) { 108 unsigned long zero = 0; 109 asm volatile("frestore %0": :"m" (zero)); 110 } 111 #endif 112 } 113 114 /* 115 * Why not generic sys_clone, you ask? m68k passes all arguments on stack. 116 * And we need all registers saved, which means a bunch of stuff pushed 117 * on top of pt_regs, which means that sys_clone() arguments would be 118 * buried. We could, of course, copy them, but it's too costly for no 119 * good reason - generic clone() would have to copy them *again* for 120 * do_fork() anyway. So in this case it's actually better to pass pt_regs * 121 * and extract arguments for do_fork() from there. Eventually we might 122 * go for calling do_fork() directly from the wrapper, but only after we 123 * are finished with do_fork() prototype conversion. 124 */ 125 asmlinkage int m68k_clone(struct pt_regs *regs) 126 { 127 /* regs will be equal to current_pt_regs() */ 128 return do_fork(regs->d1, regs->d2, 0, 129 (int __user *)regs->d3, (int __user *)regs->d4); 130 } 131 132 int copy_thread(unsigned long clone_flags, unsigned long usp, 133 unsigned long arg, struct task_struct *p) 134 { 135 struct fork_frame { 136 struct switch_stack sw; 137 struct pt_regs regs; 138 } *frame; 139 140 frame = (struct fork_frame *) (task_stack_page(p) + THREAD_SIZE) - 1; 141 142 p->thread.ksp = (unsigned long)frame; 143 p->thread.esp0 = (unsigned long)&frame->regs; 144 145 /* 146 * Must save the current SFC/DFC value, NOT the value when 147 * the parent was last descheduled - RGH 10-08-96 148 */ 149 p->thread.fs = get_fs().seg; 150 151 if (unlikely(p->flags & PF_KTHREAD)) { 152 /* kernel thread */ 153 memset(frame, 0, sizeof(struct fork_frame)); 154 frame->regs.sr = PS_S; 155 frame->sw.a3 = usp; /* function */ 156 frame->sw.d7 = arg; 157 frame->sw.retpc = (unsigned long)ret_from_kernel_thread; 158 p->thread.usp = 0; 159 return 0; 160 } 161 memcpy(frame, container_of(current_pt_regs(), struct fork_frame, regs), 162 sizeof(struct fork_frame)); 163 frame->regs.d0 = 0; 164 frame->sw.retpc = (unsigned long)ret_from_fork; 165 p->thread.usp = usp ?: rdusp(); 166 167 if (clone_flags & CLONE_SETTLS) 168 task_thread_info(p)->tp_value = frame->regs.d5; 169 170 #ifdef CONFIG_FPU 171 if (!FPU_IS_EMU) { 172 /* Copy the current fpu state */ 173 asm volatile ("fsave %0" : : "m" (p->thread.fpstate[0]) : "memory"); 174 175 if (!CPU_IS_060 ? p->thread.fpstate[0] : p->thread.fpstate[2]) { 176 if (CPU_IS_COLDFIRE) { 177 asm volatile ("fmovemd %/fp0-%/fp7,%0\n\t" 178 "fmovel %/fpiar,%1\n\t" 179 "fmovel %/fpcr,%2\n\t" 180 "fmovel %/fpsr,%3" 181 : 182 : "m" (p->thread.fp[0]), 183 "m" (p->thread.fpcntl[0]), 184 "m" (p->thread.fpcntl[1]), 185 "m" (p->thread.fpcntl[2]) 186 : "memory"); 187 } else { 188 asm volatile ("fmovemx %/fp0-%/fp7,%0\n\t" 189 "fmoveml %/fpiar/%/fpcr/%/fpsr,%1" 190 : 191 : "m" (p->thread.fp[0]), 192 "m" (p->thread.fpcntl[0]) 193 : "memory"); 194 } 195 } 196 197 /* Restore the state in case the fpu was busy */ 198 asm volatile ("frestore %0" : : "m" (p->thread.fpstate[0])); 199 } 200 #endif /* CONFIG_FPU */ 201 202 return 0; 203 } 204 205 /* Fill in the fpu structure for a core dump. */ 206 #ifdef CONFIG_FPU 207 int dump_fpu (struct pt_regs *regs, struct user_m68kfp_struct *fpu) 208 { 209 char fpustate[216]; 210 211 if (FPU_IS_EMU) { 212 int i; 213 214 memcpy(fpu->fpcntl, current->thread.fpcntl, 12); 215 memcpy(fpu->fpregs, current->thread.fp, 96); 216 /* Convert internal fpu reg representation 217 * into long double format 218 */ 219 for (i = 0; i < 24; i += 3) 220 fpu->fpregs[i] = ((fpu->fpregs[i] & 0xffff0000) << 15) | 221 ((fpu->fpregs[i] & 0x0000ffff) << 16); 222 return 1; 223 } 224 225 /* First dump the fpu context to avoid protocol violation. */ 226 asm volatile ("fsave %0" :: "m" (fpustate[0]) : "memory"); 227 if (!CPU_IS_060 ? !fpustate[0] : !fpustate[2]) 228 return 0; 229 230 if (CPU_IS_COLDFIRE) { 231 asm volatile ("fmovel %/fpiar,%0\n\t" 232 "fmovel %/fpcr,%1\n\t" 233 "fmovel %/fpsr,%2\n\t" 234 "fmovemd %/fp0-%/fp7,%3" 235 : 236 : "m" (fpu->fpcntl[0]), 237 "m" (fpu->fpcntl[1]), 238 "m" (fpu->fpcntl[2]), 239 "m" (fpu->fpregs[0]) 240 : "memory"); 241 } else { 242 asm volatile ("fmovem %/fpiar/%/fpcr/%/fpsr,%0" 243 : 244 : "m" (fpu->fpcntl[0]) 245 : "memory"); 246 asm volatile ("fmovemx %/fp0-%/fp7,%0" 247 : 248 : "m" (fpu->fpregs[0]) 249 : "memory"); 250 } 251 252 return 1; 253 } 254 EXPORT_SYMBOL(dump_fpu); 255 #endif /* CONFIG_FPU */ 256 257 unsigned long get_wchan(struct task_struct *p) 258 { 259 unsigned long fp, pc; 260 unsigned long stack_page; 261 int count = 0; 262 if (!p || p == current || p->state == TASK_RUNNING) 263 return 0; 264 265 stack_page = (unsigned long)task_stack_page(p); 266 fp = ((struct switch_stack *)p->thread.ksp)->a6; 267 do { 268 if (fp < stack_page+sizeof(struct thread_info) || 269 fp >= 8184+stack_page) 270 return 0; 271 pc = ((unsigned long *)fp)[1]; 272 if (!in_sched_functions(pc)) 273 return pc; 274 fp = *(unsigned long *) fp; 275 } while (count++ < 16); 276 return 0; 277 } 278