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