1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 1994 - 1999, 2000 by Ralf Baechle and others. 7 * Copyright (C) 2005, 2006 by Ralf Baechle ([email protected]) 8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc. 9 * Copyright (C) 2004 Thiemo Seufer 10 */ 11 #include <linux/errno.h> 12 #include <linux/module.h> 13 #include <linux/sched.h> 14 #include <linux/kernel.h> 15 #include <linux/mm.h> 16 #include <linux/stddef.h> 17 #include <linux/unistd.h> 18 #include <linux/ptrace.h> 19 #include <linux/slab.h> 20 #include <linux/mman.h> 21 #include <linux/personality.h> 22 #include <linux/sys.h> 23 #include <linux/user.h> 24 #include <linux/a.out.h> 25 #include <linux/init.h> 26 #include <linux/completion.h> 27 #include <linux/kallsyms.h> 28 29 #include <asm/abi.h> 30 #include <asm/bootinfo.h> 31 #include <asm/cpu.h> 32 #include <asm/dsp.h> 33 #include <asm/fpu.h> 34 #include <asm/pgtable.h> 35 #include <asm/system.h> 36 #include <asm/mipsregs.h> 37 #include <asm/processor.h> 38 #include <asm/uaccess.h> 39 #include <asm/io.h> 40 #include <asm/elf.h> 41 #include <asm/isadep.h> 42 #include <asm/inst.h> 43 #ifdef CONFIG_MIPS_MT_SMTC 44 #include <asm/mipsmtregs.h> 45 extern void smtc_idle_loop_hook(void); 46 #endif /* CONFIG_MIPS_MT_SMTC */ 47 48 /* 49 * The idle thread. There's no useful work to be done, so just try to conserve 50 * power and have a low exit latency (ie sit in a loop waiting for somebody to 51 * say that they'd like to reschedule) 52 */ 53 ATTRIB_NORET void cpu_idle(void) 54 { 55 /* endless idle loop with no priority at all */ 56 while (1) { 57 while (!need_resched()) { 58 #ifdef CONFIG_MIPS_MT_SMTC 59 smtc_idle_loop_hook(); 60 #endif /* CONFIG_MIPS_MT_SMTC */ 61 if (cpu_wait) 62 (*cpu_wait)(); 63 } 64 preempt_enable_no_resched(); 65 schedule(); 66 preempt_disable(); 67 } 68 } 69 70 /* 71 * Native o32 and N64 ABI without DSP ASE 72 */ 73 struct mips_abi mips_abi = { 74 .do_signal = do_signal, 75 #ifdef CONFIG_TRAD_SIGNALS 76 .setup_frame = setup_frame, 77 #endif 78 .setup_rt_frame = setup_rt_frame 79 }; 80 81 #ifdef CONFIG_MIPS32_O32 82 /* 83 * o32 compatibility on 64-bit kernels, without DSP ASE 84 */ 85 struct mips_abi mips_abi_32 = { 86 .do_signal = do_signal32, 87 .setup_frame = setup_frame_32, 88 .setup_rt_frame = setup_rt_frame_32 89 }; 90 #endif /* CONFIG_MIPS32_O32 */ 91 92 #ifdef CONFIG_MIPS32_N32 93 /* 94 * N32 on 64-bit kernels, without DSP ASE 95 */ 96 struct mips_abi mips_abi_n32 = { 97 .do_signal = do_signal, 98 .setup_rt_frame = setup_rt_frame_n32 99 }; 100 #endif /* CONFIG_MIPS32_N32 */ 101 102 asmlinkage void ret_from_fork(void); 103 104 void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp) 105 { 106 unsigned long status; 107 108 /* New thread loses kernel privileges. */ 109 status = regs->cp0_status & ~(ST0_CU0|ST0_CU1|KU_MASK); 110 #ifdef CONFIG_64BIT 111 status &= ~ST0_FR; 112 status |= (current->thread.mflags & MF_32BIT_REGS) ? 0 : ST0_FR; 113 #endif 114 status |= KU_USER; 115 regs->cp0_status = status; 116 clear_used_math(); 117 lose_fpu(); 118 if (cpu_has_dsp) 119 __init_dsp(); 120 regs->cp0_epc = pc; 121 regs->regs[29] = sp; 122 current_thread_info()->addr_limit = USER_DS; 123 } 124 125 void exit_thread(void) 126 { 127 } 128 129 void flush_thread(void) 130 { 131 } 132 133 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp, 134 unsigned long unused, struct task_struct *p, struct pt_regs *regs) 135 { 136 struct thread_info *ti = task_thread_info(p); 137 struct pt_regs *childregs; 138 long childksp; 139 p->set_child_tid = p->clear_child_tid = NULL; 140 141 childksp = (unsigned long)task_stack_page(p) + THREAD_SIZE - 32; 142 143 preempt_disable(); 144 145 if (is_fpu_owner()) 146 save_fp(p); 147 148 if (cpu_has_dsp) 149 save_dsp(p); 150 151 preempt_enable(); 152 153 /* set up new TSS. */ 154 childregs = (struct pt_regs *) childksp - 1; 155 *childregs = *regs; 156 childregs->regs[7] = 0; /* Clear error flag */ 157 158 #if defined(CONFIG_BINFMT_IRIX) 159 if (current->personality != PER_LINUX) { 160 /* Under IRIX things are a little different. */ 161 childregs->regs[3] = 1; 162 regs->regs[3] = 0; 163 } 164 #endif 165 childregs->regs[2] = 0; /* Child gets zero as return value */ 166 regs->regs[2] = p->pid; 167 168 if (childregs->cp0_status & ST0_CU0) { 169 childregs->regs[28] = (unsigned long) ti; 170 childregs->regs[29] = childksp; 171 ti->addr_limit = KERNEL_DS; 172 } else { 173 childregs->regs[29] = usp; 174 ti->addr_limit = USER_DS; 175 } 176 p->thread.reg29 = (unsigned long) childregs; 177 p->thread.reg31 = (unsigned long) ret_from_fork; 178 179 /* 180 * New tasks lose permission to use the fpu. This accelerates context 181 * switching for most programs since they don't use the fpu. 182 */ 183 p->thread.cp0_status = read_c0_status() & ~(ST0_CU2|ST0_CU1); 184 childregs->cp0_status &= ~(ST0_CU2|ST0_CU1); 185 clear_tsk_thread_flag(p, TIF_USEDFPU); 186 187 #ifdef CONFIG_MIPS_MT_FPAFF 188 /* 189 * FPU affinity support is cleaner if we track the 190 * user-visible CPU affinity from the very beginning. 191 * The generic cpus_allowed mask will already have 192 * been copied from the parent before copy_thread 193 * is invoked. 194 */ 195 p->thread.user_cpus_allowed = p->cpus_allowed; 196 #endif /* CONFIG_MIPS_MT_FPAFF */ 197 198 if (clone_flags & CLONE_SETTLS) 199 ti->tp_value = regs->regs[7]; 200 201 return 0; 202 } 203 204 /* Fill in the fpu structure for a core dump.. */ 205 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *r) 206 { 207 memcpy(r, ¤t->thread.fpu, sizeof(current->thread.fpu)); 208 209 return 1; 210 } 211 212 void elf_dump_regs(elf_greg_t *gp, struct pt_regs *regs) 213 { 214 int i; 215 216 for (i = 0; i < EF_R0; i++) 217 gp[i] = 0; 218 gp[EF_R0] = 0; 219 for (i = 1; i <= 31; i++) 220 gp[EF_R0 + i] = regs->regs[i]; 221 gp[EF_R26] = 0; 222 gp[EF_R27] = 0; 223 gp[EF_LO] = regs->lo; 224 gp[EF_HI] = regs->hi; 225 gp[EF_CP0_EPC] = regs->cp0_epc; 226 gp[EF_CP0_BADVADDR] = regs->cp0_badvaddr; 227 gp[EF_CP0_STATUS] = regs->cp0_status; 228 gp[EF_CP0_CAUSE] = regs->cp0_cause; 229 #ifdef EF_UNUSED0 230 gp[EF_UNUSED0] = 0; 231 #endif 232 } 233 234 int dump_task_regs (struct task_struct *tsk, elf_gregset_t *regs) 235 { 236 elf_dump_regs(*regs, task_pt_regs(tsk)); 237 return 1; 238 } 239 240 int dump_task_fpu (struct task_struct *t, elf_fpregset_t *fpr) 241 { 242 memcpy(fpr, &t->thread.fpu, sizeof(current->thread.fpu)); 243 244 return 1; 245 } 246 247 /* 248 * Create a kernel thread 249 */ 250 ATTRIB_NORET void kernel_thread_helper(void *arg, int (*fn)(void *)) 251 { 252 do_exit(fn(arg)); 253 } 254 255 long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags) 256 { 257 struct pt_regs regs; 258 259 memset(®s, 0, sizeof(regs)); 260 261 regs.regs[4] = (unsigned long) arg; 262 regs.regs[5] = (unsigned long) fn; 263 regs.cp0_epc = (unsigned long) kernel_thread_helper; 264 regs.cp0_status = read_c0_status(); 265 #if defined(CONFIG_CPU_R3000) || defined(CONFIG_CPU_TX39XX) 266 regs.cp0_status &= ~(ST0_KUP | ST0_IEC); 267 regs.cp0_status |= ST0_IEP; 268 #else 269 regs.cp0_status |= ST0_EXL; 270 #endif 271 272 /* Ok, create the new process.. */ 273 return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, ®s, 0, NULL, NULL); 274 } 275 276 static struct mips_frame_info { 277 void *func; 278 unsigned long func_size; 279 int frame_size; 280 int pc_offset; 281 } *schedule_frame, mfinfo[64]; 282 static int mfinfo_num; 283 284 static int __init get_frame_info(struct mips_frame_info *info) 285 { 286 int i; 287 void *func = info->func; 288 union mips_instruction *ip = (union mips_instruction *)func; 289 info->pc_offset = -1; 290 info->frame_size = 0; 291 for (i = 0; i < 128; i++, ip++) { 292 /* if jal, jalr, jr, stop. */ 293 if (ip->j_format.opcode == jal_op || 294 (ip->r_format.opcode == spec_op && 295 (ip->r_format.func == jalr_op || 296 ip->r_format.func == jr_op))) 297 break; 298 299 if (info->func_size && i >= info->func_size / 4) 300 break; 301 if ( 302 #ifdef CONFIG_32BIT 303 ip->i_format.opcode == addiu_op && 304 #endif 305 #ifdef CONFIG_64BIT 306 ip->i_format.opcode == daddiu_op && 307 #endif 308 ip->i_format.rs == 29 && 309 ip->i_format.rt == 29) { 310 /* addiu/daddiu sp,sp,-imm */ 311 if (info->frame_size) 312 continue; 313 info->frame_size = - ip->i_format.simmediate; 314 } 315 316 if ( 317 #ifdef CONFIG_32BIT 318 ip->i_format.opcode == sw_op && 319 #endif 320 #ifdef CONFIG_64BIT 321 ip->i_format.opcode == sd_op && 322 #endif 323 ip->i_format.rs == 29 && 324 ip->i_format.rt == 31) { 325 /* sw / sd $ra, offset($sp) */ 326 if (info->pc_offset != -1) 327 continue; 328 info->pc_offset = 329 ip->i_format.simmediate / sizeof(long); 330 } 331 } 332 if (info->pc_offset == -1 || info->frame_size == 0) { 333 if (func == schedule) 334 printk("Can't analyze prologue code at %p\n", func); 335 info->pc_offset = -1; 336 info->frame_size = 0; 337 } 338 339 return 0; 340 } 341 342 static int __init frame_info_init(void) 343 { 344 int i; 345 #ifdef CONFIG_KALLSYMS 346 char *modname; 347 char namebuf[KSYM_NAME_LEN + 1]; 348 unsigned long start, size, ofs; 349 extern char __sched_text_start[], __sched_text_end[]; 350 extern char __lock_text_start[], __lock_text_end[]; 351 352 start = (unsigned long)__sched_text_start; 353 for (i = 0; i < ARRAY_SIZE(mfinfo); i++) { 354 if (start == (unsigned long)schedule) 355 schedule_frame = &mfinfo[i]; 356 if (!kallsyms_lookup(start, &size, &ofs, &modname, namebuf)) 357 break; 358 mfinfo[i].func = (void *)(start + ofs); 359 mfinfo[i].func_size = size; 360 start += size - ofs; 361 if (start >= (unsigned long)__lock_text_end) 362 break; 363 if (start == (unsigned long)__sched_text_end) 364 start = (unsigned long)__lock_text_start; 365 } 366 #else 367 mfinfo[0].func = schedule; 368 schedule_frame = &mfinfo[0]; 369 #endif 370 for (i = 0; i < ARRAY_SIZE(mfinfo) && mfinfo[i].func; i++) 371 get_frame_info(&mfinfo[i]); 372 373 mfinfo_num = i; 374 return 0; 375 } 376 377 arch_initcall(frame_info_init); 378 379 /* 380 * Return saved PC of a blocked thread. 381 */ 382 unsigned long thread_saved_pc(struct task_struct *tsk) 383 { 384 struct thread_struct *t = &tsk->thread; 385 386 /* New born processes are a special case */ 387 if (t->reg31 == (unsigned long) ret_from_fork) 388 return t->reg31; 389 390 if (!schedule_frame || schedule_frame->pc_offset < 0) 391 return 0; 392 return ((unsigned long *)t->reg29)[schedule_frame->pc_offset]; 393 } 394 395 /* get_wchan - a maintenance nightmare^W^Wpain in the ass ... */ 396 unsigned long get_wchan(struct task_struct *p) 397 { 398 unsigned long stack_page; 399 unsigned long pc; 400 #ifdef CONFIG_KALLSYMS 401 unsigned long frame; 402 #endif 403 404 if (!p || p == current || p->state == TASK_RUNNING) 405 return 0; 406 407 stack_page = (unsigned long)task_stack_page(p); 408 if (!stack_page || !mfinfo_num) 409 return 0; 410 411 pc = thread_saved_pc(p); 412 #ifdef CONFIG_KALLSYMS 413 if (!in_sched_functions(pc)) 414 return pc; 415 416 frame = p->thread.reg29 + schedule_frame->frame_size; 417 do { 418 int i; 419 420 if (frame < stack_page || frame > stack_page + THREAD_SIZE - 32) 421 return 0; 422 423 for (i = mfinfo_num - 1; i >= 0; i--) { 424 if (pc >= (unsigned long) mfinfo[i].func) 425 break; 426 } 427 if (i < 0) 428 break; 429 430 pc = ((unsigned long *)frame)[mfinfo[i].pc_offset]; 431 if (!mfinfo[i].frame_size) 432 break; 433 frame += mfinfo[i].frame_size; 434 } while (in_sched_functions(pc)); 435 #endif 436 437 return pc; 438 } 439 440