blob: ec8209f3a0c68af6c70df1e43403ab23687f62f6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
Ralf Baechle40ac5d42006-02-08 13:38:18 +00007 * Copyright (C) 2005, 2006 by Ralf Baechle (ralf@linux-mips.org)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
9 * Copyright (C) 2004 Thiemo Seufer
10 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#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>
Atsushi Nemoto63077512006-02-08 01:48:03 +090027#include <linux/kallsyms.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Ralf Baechlee50c0a82005-05-31 11:49:19 +000029#include <asm/abi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/bootinfo.h>
31#include <asm/cpu.h>
Ralf Baechlee50c0a82005-05-31 11:49:19 +000032#include <asm/dsp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#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>
Atsushi Nemoto1df0f0f2006-09-26 23:44:01 +090043#include <asm/stacktrace.h>
Ralf Baechle41c594a2006-04-05 09:45:45 +010044#ifdef CONFIG_MIPS_MT_SMTC
45#include <asm/mipsmtregs.h>
46extern void smtc_idle_loop_hook(void);
47#endif /* CONFIG_MIPS_MT_SMTC */
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 * 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 */
54ATTRIB_NORET void cpu_idle(void)
55{
56 /* endless idle loop with no priority at all */
57 while (1) {
Ralf Baechle41c594a2006-04-05 09:45:45 +010058 while (!need_resched()) {
59#ifdef CONFIG_MIPS_MT_SMTC
60 smtc_idle_loop_hook();
61#endif /* CONFIG_MIPS_MT_SMTC */
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 if (cpu_wait)
63 (*cpu_wait)();
Ralf Baechle41c594a2006-04-05 09:45:45 +010064 }
Nick Piggin5bfb5d62005-11-08 21:39:01 -080065 preempt_enable_no_resched();
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 schedule();
Nick Piggin5bfb5d62005-11-08 21:39:01 -080067 preempt_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 }
69}
70
Ralf Baechlee50c0a82005-05-31 11:49:19 +000071/*
72 * Native o32 and N64 ABI without DSP ASE
73 */
Ralf Baechlee50c0a82005-05-31 11:49:19 +000074struct 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 */
Ralf Baechlee50c0a82005-05-31 11:49:19 +000086struct 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 */
Ralf Baechlee50c0a82005-05-31 11:49:19 +000097struct 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103asmlinkage void ret_from_fork(void);
104
105void 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);
Ralf Baechle875d43e2005-09-03 15:56:16 -0700111#ifdef CONFIG_64BIT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 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();
Atsushi Nemotoe04582b2006-10-09 00:10:01 +0900118 clear_fpu_owner();
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000119 if (cpu_has_dsp)
120 __init_dsp();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 regs->cp0_epc = pc;
122 regs->regs[29] = sp;
123 current_thread_info()->addr_limit = USER_DS;
124}
125
126void exit_thread(void)
127{
128}
129
130void flush_thread(void)
131{
132}
133
134int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
135 unsigned long unused, struct task_struct *p, struct pt_regs *regs)
136{
Al Viro75bb07e2006-01-12 01:06:08 -0800137 struct thread_info *ti = task_thread_info(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 struct pt_regs *childregs;
139 long childksp;
Ralf Baechle3c370262005-04-13 17:43:59 +0000140 p->set_child_tid = p->clear_child_tid = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Al Viro75bb07e2006-01-12 01:06:08 -0800142 childksp = (unsigned long)task_stack_page(p) + THREAD_SIZE - 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
144 preempt_disable();
145
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000146 if (is_fpu_owner())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 save_fp(p);
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000148
149 if (cpu_has_dsp)
150 save_dsp(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
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
Ralf Baechlef088fc82006-04-05 09:45:47 +0100188#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
Ralf Baechle3c370262005-04-13 17:43:59 +0000199 if (clone_flags & CLONE_SETTLS)
200 ti->tp_value = regs->regs[7];
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 return 0;
203}
204
205/* Fill in the fpu structure for a core dump.. */
206int dump_fpu(struct pt_regs *regs, elf_fpregset_t *r)
207{
208 memcpy(r, &current->thread.fpu, sizeof(current->thread.fpu));
209
210 return 1;
211}
212
Al Virod56efda2005-12-16 22:40:47 +0000213void elf_dump_regs(elf_greg_t *gp, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214{
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
Ralf Baechle71e0e552005-03-14 10:16:59 +0000235int dump_task_regs (struct task_struct *tsk, elf_gregset_t *regs)
236{
Al Viro40bc9c62006-01-12 01:06:07 -0800237 elf_dump_regs(*regs, task_pt_regs(tsk));
Ralf Baechle71e0e552005-03-14 10:16:59 +0000238 return 1;
239}
240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241int 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 */
251ATTRIB_NORET void kernel_thread_helper(void *arg, int (*fn)(void *))
252{
253 do_exit(fn(arg));
254}
255
256long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
257{
258 struct pt_regs regs;
259
260 memset(&regs, 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, &regs, 0, NULL, NULL);
275}
276
Franck Bui-Huub5943182006-08-18 16:18:09 +0200277/*
278 *
279 */
280struct mips_frame_info {
281 void *func;
282 unsigned long func_size;
283 int frame_size;
284 int pc_offset;
285};
Thiemo Seuferdc953df2005-02-21 10:55:16 +0000286
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200287static inline int is_ra_save_ins(union mips_instruction *ip)
288{
289 /* sw / sd $ra, offset($sp) */
290 return (ip->i_format.opcode == sw_op || ip->i_format.opcode == sd_op) &&
291 ip->i_format.rs == 29 &&
292 ip->i_format.rt == 31;
293}
294
295static inline int is_jal_jalr_jr_ins(union mips_instruction *ip)
296{
297 if (ip->j_format.opcode == jal_op)
298 return 1;
299 if (ip->r_format.opcode != spec_op)
300 return 0;
301 return ip->r_format.func == jalr_op || ip->r_format.func == jr_op;
302}
303
304static inline int is_sp_move_ins(union mips_instruction *ip)
305{
306 /* addiu/daddiu sp,sp,-imm */
307 if (ip->i_format.rs != 29 || ip->i_format.rt != 29)
308 return 0;
309 if (ip->i_format.opcode == addiu_op || ip->i_format.opcode == daddiu_op)
310 return 1;
311 return 0;
312}
313
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900314static int get_frame_info(struct mips_frame_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200316 union mips_instruction *ip = info->func;
Franck Bui-Huu29b376f2006-08-18 16:18:08 +0200317 unsigned max_insns = info->func_size / sizeof(union mips_instruction);
318 unsigned i;
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 info->pc_offset = -1;
Atsushi Nemoto63077512006-02-08 01:48:03 +0900321 info->frame_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Franck Bui-Huu29b376f2006-08-18 16:18:08 +0200323 if (!ip)
324 goto err;
325
326 if (max_insns == 0)
327 max_insns = 128U; /* unknown function size */
328 max_insns = min(128U, max_insns);
329
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200330 for (i = 0; i < max_insns; i++, ip++) {
331
332 if (is_jal_jalr_jr_ins(ip))
Atsushi Nemoto63077512006-02-08 01:48:03 +0900333 break;
Franck Bui-Huu0cceb4a2006-08-03 09:29:20 +0200334 if (!info->frame_size) {
335 if (is_sp_move_ins(ip))
336 info->frame_size = - ip->i_format.simmediate;
337 continue;
Atsushi Nemoto63077512006-02-08 01:48:03 +0900338 }
Franck Bui-Huu0cceb4a2006-08-03 09:29:20 +0200339 if (info->pc_offset == -1 && is_ra_save_ins(ip)) {
Atsushi Nemoto63077512006-02-08 01:48:03 +0900340 info->pc_offset =
341 ip->i_format.simmediate / sizeof(long);
Franck Bui-Huu0cceb4a2006-08-03 09:29:20 +0200342 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 }
344 }
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900345 if (info->frame_size && info->pc_offset >= 0) /* nested */
346 return 0;
347 if (info->pc_offset < 0) /* leaf */
348 return 1;
349 /* prologue seems boggus... */
Franck Bui-Huu29b376f2006-08-18 16:18:08 +0200350err:
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900351 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352}
353
Franck Bui-Huub5943182006-08-18 16:18:09 +0200354static struct mips_frame_info schedule_mfi __read_mostly;
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356static int __init frame_info_init(void)
357{
Franck Bui-Huub5943182006-08-18 16:18:09 +0200358 unsigned long size = 0;
Atsushi Nemoto63077512006-02-08 01:48:03 +0900359#ifdef CONFIG_KALLSYMS
Franck Bui-Huub5943182006-08-18 16:18:09 +0200360 unsigned long ofs;
Atsushi Nemoto63077512006-02-08 01:48:03 +0900361
Franck Bui-Huu55b74282006-10-13 13:37:35 +0200362 kallsyms_lookup_size_offset((unsigned long)schedule, &size, &ofs);
Atsushi Nemoto63077512006-02-08 01:48:03 +0900363#endif
Franck Bui-Huub5943182006-08-18 16:18:09 +0200364 schedule_mfi.func = schedule;
365 schedule_mfi.func_size = size;
366
367 get_frame_info(&schedule_mfi);
Franck Bui-Huu6057a792006-08-03 09:29:18 +0200368
369 /*
370 * Without schedule() frame info, result given by
371 * thread_saved_pc() and get_wchan() are not reliable.
372 */
Franck Bui-Huub5943182006-08-18 16:18:09 +0200373 if (schedule_mfi.pc_offset < 0)
Franck Bui-Huu6057a792006-08-03 09:29:18 +0200374 printk("Can't analyze schedule() prologue at %p\n", schedule);
Atsushi Nemoto63077512006-02-08 01:48:03 +0900375
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 return 0;
377}
378
379arch_initcall(frame_info_init);
380
381/*
382 * Return saved PC of a blocked thread.
383 */
384unsigned long thread_saved_pc(struct task_struct *tsk)
385{
386 struct thread_struct *t = &tsk->thread;
387
388 /* New born processes are a special case */
389 if (t->reg31 == (unsigned long) ret_from_fork)
390 return t->reg31;
Franck Bui-Huub5943182006-08-18 16:18:09 +0200391 if (schedule_mfi.pc_offset < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 return 0;
Franck Bui-Huub5943182006-08-18 16:18:09 +0200393 return ((unsigned long *)t->reg29)[schedule_mfi.pc_offset];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394}
395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900397#ifdef CONFIG_KALLSYMS
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200398/* used by show_backtrace() */
399unsigned long unwind_stack(struct task_struct *task, unsigned long *sp,
Atsushi Nemoto19246002006-09-29 18:02:51 +0900400 unsigned long pc, unsigned long *ra)
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900401{
402 unsigned long stack_page;
403 struct mips_frame_info info;
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900404 unsigned long size, ofs;
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200405 int leaf;
Atsushi Nemoto19246002006-09-29 18:02:51 +0900406 extern void ret_from_irq(void);
407 extern void ret_from_exception(void);
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900408
409 stack_page = (unsigned long)task_stack_page(task);
410 if (!stack_page)
411 return 0;
412
Atsushi Nemoto19246002006-09-29 18:02:51 +0900413 /*
414 * If we reached the bottom of interrupt context,
415 * return saved pc in pt_regs.
416 */
417 if (pc == (unsigned long)ret_from_irq ||
418 pc == (unsigned long)ret_from_exception) {
419 struct pt_regs *regs;
420 if (*sp >= stack_page &&
421 *sp + sizeof(*regs) <= stack_page + THREAD_SIZE - 32) {
422 regs = (struct pt_regs *)*sp;
423 pc = regs->cp0_epc;
424 if (__kernel_text_address(pc)) {
425 *sp = regs->regs[29];
426 *ra = regs->regs[31];
427 return pc;
428 }
429 }
430 return 0;
431 }
Franck Bui-Huu55b74282006-10-13 13:37:35 +0200432 if (!kallsyms_lookup_size_offset(pc, &size, &ofs))
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900433 return 0;
Franck Bui-Huu1fd69092006-08-18 16:18:07 +0200434 /*
435 * Return ra if an exception occured at the first instruction
436 */
Atsushi Nemoto19246002006-09-29 18:02:51 +0900437 if (unlikely(ofs == 0)) {
438 pc = *ra;
439 *ra = 0;
440 return pc;
441 }
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900442
443 info.func = (void *)(pc - ofs);
444 info.func_size = ofs; /* analyze from start to ofs */
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200445 leaf = get_frame_info(&info);
446 if (leaf < 0)
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900447 return 0;
448
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200449 if (*sp < stack_page ||
450 *sp + info.frame_size > stack_page + THREAD_SIZE - 32)
451 return 0;
452
453 if (leaf)
454 /*
455 * For some extreme cases, get_frame_info() can
456 * consider wrongly a nested function as a leaf
457 * one. In that cases avoid to return always the
458 * same value.
459 */
Atsushi Nemoto19246002006-09-29 18:02:51 +0900460 pc = pc != *ra ? *ra : 0;
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200461 else
462 pc = ((unsigned long *)(*sp))[info.pc_offset];
463
464 *sp += info.frame_size;
Atsushi Nemoto19246002006-09-29 18:02:51 +0900465 *ra = 0;
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200466 return __kernel_text_address(pc) ? pc : 0;
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900467}
468#endif
Franck Bui-Huub5943182006-08-18 16:18:09 +0200469
470/*
471 * get_wchan - a maintenance nightmare^W^Wpain in the ass ...
472 */
473unsigned long get_wchan(struct task_struct *task)
474{
475 unsigned long pc = 0;
476#ifdef CONFIG_KALLSYMS
477 unsigned long sp;
Atsushi Nemoto19246002006-09-29 18:02:51 +0900478 unsigned long ra = 0;
Franck Bui-Huub5943182006-08-18 16:18:09 +0200479#endif
480
481 if (!task || task == current || task->state == TASK_RUNNING)
482 goto out;
483 if (!task_stack_page(task))
484 goto out;
485
486 pc = thread_saved_pc(task);
487
488#ifdef CONFIG_KALLSYMS
489 sp = task->thread.reg29 + schedule_mfi.frame_size;
490
491 while (in_sched_functions(pc))
Atsushi Nemoto19246002006-09-29 18:02:51 +0900492 pc = unwind_stack(task, &sp, pc, &ra);
Franck Bui-Huub5943182006-08-18 16:18:09 +0200493#endif
494
495out:
496 return pc;
497}