blob: c6a041d9d05d57fcd71f91a228c86524e00efd08 [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
Leonid Yegoshin34c2f662013-03-25 13:18:07 -050010 * Copyright (C) 2013 Imagination Technologies Ltd.
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/sched.h>
Ralf Baechle7bcf7712007-10-11 23:46:09 +010014#include <linux/tick.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/kernel.h>
16#include <linux/mm.h>
17#include <linux/stddef.h>
18#include <linux/unistd.h>
Paul Gortmakercae39d12011-07-28 18:46:31 -040019#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/ptrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/mman.h>
22#include <linux/personality.h>
23#include <linux/sys.h>
24#include <linux/user.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/init.h>
26#include <linux/completion.h>
Atsushi Nemoto63077512006-02-08 01:48:03 +090027#include <linux/kallsyms.h>
Franck Bui-Huu94109102007-07-19 14:04:21 +020028#include <linux/random.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Franck Bui-Huu94109102007-07-19 14:04:21 +020030#include <asm/asm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <asm/bootinfo.h>
32#include <asm/cpu.h>
Ralf Baechlee50c0a82005-05-31 11:49:19 +000033#include <asm/dsp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <asm/fpu.h>
35#include <asm/pgtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Ralf Baechle1b2bc752009-06-23 10:00:31 +010045#ifdef CONFIG_HOTPLUG_CPU
Thomas Gleixnercdbedc62013-03-21 22:49:52 +010046void arch_cpu_idle_dead(void)
47{
48 /* What the heck is this check doing ? */
49 if (!cpu_isset(smp_processor_id(), cpu_callin_map))
50 play_dead();
51}
Ralf Baechle1b2bc752009-06-23 10:00:31 +010052#endif
Thomas Gleixnercdbedc62013-03-21 22:49:52 +010053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054asmlinkage void ret_from_fork(void);
Al Viro8f54bca2012-10-09 16:27:45 -040055asmlinkage void ret_from_kernel_thread(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
58{
59 unsigned long status;
60
61 /* New thread loses kernel privileges. */
Chris Dearmanbbaf2382007-12-13 22:42:19 +000062 status = regs->cp0_status & ~(ST0_CU0|ST0_CU1|ST0_FR|KU_MASK);
Ralf Baechle875d43e2005-09-03 15:56:16 -070063#ifdef CONFIG_64BIT
Ralf Baechle293c5bd2007-07-25 16:19:33 +010064 status |= test_thread_flag(TIF_32BIT_REGS) ? 0 : ST0_FR;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#endif
66 status |= KU_USER;
67 regs->cp0_status = status;
68 clear_used_math();
Atsushi Nemotoe04582b2006-10-09 00:10:01 +090069 clear_fpu_owner();
Ralf Baechlee50c0a82005-05-31 11:49:19 +000070 if (cpu_has_dsp)
71 __init_dsp();
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 regs->cp0_epc = pc;
73 regs->regs[29] = sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074}
75
76void exit_thread(void)
77{
78}
79
80void flush_thread(void)
81{
82}
83
Alexey Dobriyan6f2c55b2009-04-02 16:56:59 -070084int copy_thread(unsigned long clone_flags, unsigned long usp,
Al Viroafa86fc2012-10-22 22:51:14 -040085 unsigned long arg, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086{
Al Viro75bb07e2006-01-12 01:06:08 -080087 struct thread_info *ti = task_thread_info(p);
Al Viroafa86fc2012-10-22 22:51:14 -040088 struct pt_regs *childregs, *regs = current_pt_regs();
David Daney484889f2009-07-08 10:07:50 -070089 unsigned long childksp;
Ralf Baechle3c370262005-04-13 17:43:59 +000090 p->set_child_tid = p->clear_child_tid = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Al Viro75bb07e2006-01-12 01:06:08 -080092 childksp = (unsigned long)task_stack_page(p) + THREAD_SIZE - 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94 preempt_disable();
95
Ralf Baechlee50c0a82005-05-31 11:49:19 +000096 if (is_fpu_owner())
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 save_fp(p);
Ralf Baechlee50c0a82005-05-31 11:49:19 +000098
99 if (cpu_has_dsp)
100 save_dsp(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
102 preempt_enable();
103
104 /* set up new TSS. */
105 childregs = (struct pt_regs *) childksp - 1;
David Daney484889f2009-07-08 10:07:50 -0700106 /* Put the stack after the struct pt_regs. */
107 childksp = (unsigned long) childregs;
Al Viro8f54bca2012-10-09 16:27:45 -0400108 p->thread.cp0_status = read_c0_status() & ~(ST0_CU2|ST0_CU1);
109 if (unlikely(p->flags & PF_KTHREAD)) {
110 unsigned long status = p->thread.cp0_status;
111 memset(childregs, 0, sizeof(struct pt_regs));
112 ti->addr_limit = KERNEL_DS;
113 p->thread.reg16 = usp; /* fn */
114 p->thread.reg17 = arg;
115 p->thread.reg29 = childksp;
116 p->thread.reg31 = (unsigned long) ret_from_kernel_thread;
117#if defined(CONFIG_CPU_R3000) || defined(CONFIG_CPU_TX39XX)
118 status = (status & ~(ST0_KUP | ST0_IEP | ST0_IEC)) |
119 ((status & (ST0_KUC | ST0_IEC)) << 2);
120#else
121 status |= ST0_EXL;
122#endif
123 childregs->cp0_status = status;
124 return 0;
125 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 *childregs = *regs;
Ralf Baechle70342282013-01-22 12:59:30 +0100127 childregs->regs[7] = 0; /* Clear error flag */
128 childregs->regs[2] = 0; /* Child gets zero as return value */
Al Viro64b31222012-12-27 11:52:32 -0500129 if (usp)
130 childregs->regs[29] = usp;
Al Viro8f54bca2012-10-09 16:27:45 -0400131 ti->addr_limit = USER_DS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 p->thread.reg29 = (unsigned long) childregs;
134 p->thread.reg31 = (unsigned long) ret_from_fork;
135
136 /*
137 * New tasks lose permission to use the fpu. This accelerates context
138 * switching for most programs since they don't use the fpu.
139 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 childregs->cp0_status &= ~(ST0_CU2|ST0_CU1);
Kevin D. Kissell9cc12362008-09-09 21:33:36 +0200141
142#ifdef CONFIG_MIPS_MT_SMTC
143 /*
144 * SMTC restores TCStatus after Status, and the CU bits
145 * are aliased there.
146 */
147 childregs->cp0_tcstatus &= ~(ST0_CU2|ST0_CU1);
148#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 clear_tsk_thread_flag(p, TIF_USEDFPU);
150
Ralf Baechlef088fc82006-04-05 09:45:47 +0100151#ifdef CONFIG_MIPS_MT_FPAFF
Ralf Baechle6657fe02008-09-09 15:19:10 +0200152 clear_tsk_thread_flag(p, TIF_FPUBOUND);
Ralf Baechlef088fc82006-04-05 09:45:47 +0100153#endif /* CONFIG_MIPS_MT_FPAFF */
154
Ralf Baechle3c370262005-04-13 17:43:59 +0000155 if (clone_flags & CLONE_SETTLS)
156 ti->tp_value = regs->regs[7];
157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 return 0;
159}
160
161/* Fill in the fpu structure for a core dump.. */
162int dump_fpu(struct pt_regs *regs, elf_fpregset_t *r)
163{
164 memcpy(r, &current->thread.fpu, sizeof(current->thread.fpu));
165
166 return 1;
167}
168
Al Virod56efda2005-12-16 22:40:47 +0000169void elf_dump_regs(elf_greg_t *gp, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
171 int i;
172
173 for (i = 0; i < EF_R0; i++)
174 gp[i] = 0;
175 gp[EF_R0] = 0;
176 for (i = 1; i <= 31; i++)
177 gp[EF_R0 + i] = regs->regs[i];
178 gp[EF_R26] = 0;
179 gp[EF_R27] = 0;
180 gp[EF_LO] = regs->lo;
181 gp[EF_HI] = regs->hi;
182 gp[EF_CP0_EPC] = regs->cp0_epc;
183 gp[EF_CP0_BADVADDR] = regs->cp0_badvaddr;
184 gp[EF_CP0_STATUS] = regs->cp0_status;
185 gp[EF_CP0_CAUSE] = regs->cp0_cause;
186#ifdef EF_UNUSED0
187 gp[EF_UNUSED0] = 0;
188#endif
189}
190
Ralf Baechle49a89ef2007-10-11 23:46:15 +0100191int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
Ralf Baechle71e0e552005-03-14 10:16:59 +0000192{
Al Viro40bc9c62006-01-12 01:06:07 -0800193 elf_dump_regs(*regs, task_pt_regs(tsk));
Ralf Baechle71e0e552005-03-14 10:16:59 +0000194 return 1;
195}
196
Ralf Baechle49a89ef2007-10-11 23:46:15 +0100197int dump_task_fpu(struct task_struct *t, elf_fpregset_t *fpr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
199 memcpy(fpr, &t->thread.fpu, sizeof(current->thread.fpu));
200
201 return 1;
202}
203
204/*
Franck Bui-Huub5943182006-08-18 16:18:09 +0200205 *
206 */
207struct mips_frame_info {
208 void *func;
209 unsigned long func_size;
210 int frame_size;
211 int pc_offset;
212};
Thiemo Seuferdc953df2005-02-21 10:55:16 +0000213
Tony Wu5000653e2013-05-12 15:05:34 +0000214#define J_TARGET(pc,target) \
215 (((unsigned long)(pc) & 0xf0000000) | ((target) << 2))
216
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200217static inline int is_ra_save_ins(union mips_instruction *ip)
218{
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500219#ifdef CONFIG_CPU_MICROMIPS
220 union mips_instruction mmi;
221
222 /*
223 * swsp ra,offset
224 * swm16 reglist,offset(sp)
225 * swm32 reglist,offset(sp)
226 * sw32 ra,offset(sp)
227 * jradiussp - NOT SUPPORTED
228 *
229 * microMIPS is way more fun...
230 */
231 if (mm_insn_16bit(ip->halfword[0])) {
232 mmi.word = (ip->halfword[0] << 16);
233 return ((mmi.mm16_r5_format.opcode == mm_swsp16_op &&
234 mmi.mm16_r5_format.rt == 31) ||
235 (mmi.mm16_m_format.opcode == mm_pool16c_op &&
236 mmi.mm16_m_format.func == mm_swm16_op));
237 }
238 else {
239 mmi.halfword[0] = ip->halfword[1];
240 mmi.halfword[1] = ip->halfword[0];
241 return ((mmi.mm_m_format.opcode == mm_pool32b_op &&
242 mmi.mm_m_format.rd > 9 &&
243 mmi.mm_m_format.base == 29 &&
244 mmi.mm_m_format.func == mm_swm32_func) ||
245 (mmi.i_format.opcode == mm_sw32_op &&
246 mmi.i_format.rs == 29 &&
247 mmi.i_format.rt == 31));
248 }
249#else
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200250 /* sw / sd $ra, offset($sp) */
251 return (ip->i_format.opcode == sw_op || ip->i_format.opcode == sd_op) &&
252 ip->i_format.rs == 29 &&
253 ip->i_format.rt == 31;
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500254#endif
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200255}
256
Tony Wue7438c42013-05-12 15:04:29 +0000257static inline int is_jump_ins(union mips_instruction *ip)
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200258{
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500259#ifdef CONFIG_CPU_MICROMIPS
260 /*
261 * jr16,jrc,jalr16,jalr16
262 * jal
263 * jalr/jr,jalr.hb/jr.hb,jalrs,jalrs.hb
264 * jraddiusp - NOT SUPPORTED
265 *
266 * microMIPS is kind of more fun...
267 */
268 union mips_instruction mmi;
269
270 mmi.word = (ip->halfword[0] << 16);
271
272 if ((mmi.mm16_r5_format.opcode == mm_pool16c_op &&
273 (mmi.mm16_r5_format.rt & mm_jr16_op) == mm_jr16_op) ||
274 ip->j_format.opcode == mm_jal32_op)
275 return 1;
276 if (ip->r_format.opcode != mm_pool32a_op ||
277 ip->r_format.func != mm_pool32axf_op)
278 return 0;
279 return (((ip->u_format.uimmediate >> 6) & mm_jalr_op) == mm_jalr_op);
280#else
Tony Wue7438c42013-05-12 15:04:29 +0000281 if (ip->j_format.opcode == j_op)
282 return 1;
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200283 if (ip->j_format.opcode == jal_op)
284 return 1;
285 if (ip->r_format.opcode != spec_op)
286 return 0;
287 return ip->r_format.func == jalr_op || ip->r_format.func == jr_op;
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500288#endif
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200289}
290
291static inline int is_sp_move_ins(union mips_instruction *ip)
292{
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500293#ifdef CONFIG_CPU_MICROMIPS
294 /*
295 * addiusp -imm
296 * addius5 sp,-imm
297 * addiu32 sp,sp,-imm
298 * jradiussp - NOT SUPPORTED
299 *
300 * microMIPS is not more fun...
301 */
302 if (mm_insn_16bit(ip->halfword[0])) {
303 union mips_instruction mmi;
304
305 mmi.word = (ip->halfword[0] << 16);
306 return ((mmi.mm16_r3_format.opcode == mm_pool16d_op &&
307 mmi.mm16_r3_format.simmediate && mm_addiusp_func) ||
308 (mmi.mm16_r5_format.opcode == mm_pool16d_op &&
309 mmi.mm16_r5_format.rt == 29));
310 }
311 return (ip->mm_i_format.opcode == mm_addiu32_op &&
312 ip->mm_i_format.rt == 29 && ip->mm_i_format.rs == 29);
313#else
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200314 /* addiu/daddiu sp,sp,-imm */
315 if (ip->i_format.rs != 29 || ip->i_format.rt != 29)
316 return 0;
317 if (ip->i_format.opcode == addiu_op || ip->i_format.opcode == daddiu_op)
318 return 1;
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500319#endif
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200320 return 0;
321}
322
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900323static int get_frame_info(struct mips_frame_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500325#ifdef CONFIG_CPU_MICROMIPS
326 union mips_instruction *ip = (void *) (((char *) info->func) - 1);
327#else
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200328 union mips_instruction *ip = info->func;
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500329#endif
Franck Bui-Huu29b376f2006-08-18 16:18:08 +0200330 unsigned max_insns = info->func_size / sizeof(union mips_instruction);
331 unsigned i;
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 info->pc_offset = -1;
Atsushi Nemoto63077512006-02-08 01:48:03 +0900334 info->frame_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
Franck Bui-Huu29b376f2006-08-18 16:18:08 +0200336 if (!ip)
337 goto err;
338
339 if (max_insns == 0)
340 max_insns = 128U; /* unknown function size */
341 max_insns = min(128U, max_insns);
342
Franck Bui-Huuc0efbb62006-08-03 09:29:15 +0200343 for (i = 0; i < max_insns; i++, ip++) {
344
Tony Wue7438c42013-05-12 15:04:29 +0000345 if (is_jump_ins(ip))
Atsushi Nemoto63077512006-02-08 01:48:03 +0900346 break;
Franck Bui-Huu0cceb4a2006-08-03 09:29:20 +0200347 if (!info->frame_size) {
348 if (is_sp_move_ins(ip))
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500349 {
350#ifdef CONFIG_CPU_MICROMIPS
351 if (mm_insn_16bit(ip->halfword[0]))
352 {
353 unsigned short tmp;
354
355 if (ip->halfword[0] & mm_addiusp_func)
356 {
357 tmp = (((ip->halfword[0] >> 1) & 0x1ff) << 2);
358 info->frame_size = -(signed short)(tmp | ((tmp & 0x100) ? 0xfe00 : 0));
359 } else {
360 tmp = (ip->halfword[0] >> 1);
361 info->frame_size = -(signed short)(tmp & 0xf);
362 }
363 ip = (void *) &ip->halfword[1];
364 ip--;
365 } else
366#endif
Franck Bui-Huu0cceb4a2006-08-03 09:29:20 +0200367 info->frame_size = - ip->i_format.simmediate;
Leonid Yegoshin34c2f662013-03-25 13:18:07 -0500368 }
Franck Bui-Huu0cceb4a2006-08-03 09:29:20 +0200369 continue;
Atsushi Nemoto63077512006-02-08 01:48:03 +0900370 }
Franck Bui-Huu0cceb4a2006-08-03 09:29:20 +0200371 if (info->pc_offset == -1 && is_ra_save_ins(ip)) {
Atsushi Nemoto63077512006-02-08 01:48:03 +0900372 info->pc_offset =
373 ip->i_format.simmediate / sizeof(long);
Franck Bui-Huu0cceb4a2006-08-03 09:29:20 +0200374 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 }
376 }
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900377 if (info->frame_size && info->pc_offset >= 0) /* nested */
378 return 0;
379 if (info->pc_offset < 0) /* leaf */
380 return 1;
381 /* prologue seems boggus... */
Franck Bui-Huu29b376f2006-08-18 16:18:08 +0200382err:
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900383 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384}
385
Franck Bui-Huub5943182006-08-18 16:18:09 +0200386static struct mips_frame_info schedule_mfi __read_mostly;
387
Tony Wu5000653e2013-05-12 15:05:34 +0000388#ifdef CONFIG_KALLSYMS
389static unsigned long get___schedule_addr(void)
390{
391 return kallsyms_lookup_name("__schedule");
392}
393#else
394static unsigned long get___schedule_addr(void)
395{
396 union mips_instruction *ip = (void *)schedule;
397 int max_insns = 8;
398 int i;
399
400 for (i = 0; i < max_insns; i++, ip++) {
401 if (ip->j_format.opcode == j_op)
402 return J_TARGET(ip, ip->j_format.target);
403 }
404 return 0;
405}
406#endif
407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408static int __init frame_info_init(void)
409{
Franck Bui-Huub5943182006-08-18 16:18:09 +0200410 unsigned long size = 0;
Atsushi Nemoto63077512006-02-08 01:48:03 +0900411#ifdef CONFIG_KALLSYMS
Franck Bui-Huub5943182006-08-18 16:18:09 +0200412 unsigned long ofs;
Atsushi Nemoto63077512006-02-08 01:48:03 +0900413#endif
Tony Wu5000653e2013-05-12 15:05:34 +0000414 unsigned long addr;
415
416 addr = get___schedule_addr();
417 if (!addr)
418 addr = (unsigned long)schedule;
419
420#ifdef CONFIG_KALLSYMS
421 kallsyms_lookup_size_offset(addr, &size, &ofs);
422#endif
423 schedule_mfi.func = (void *)addr;
Franck Bui-Huub5943182006-08-18 16:18:09 +0200424 schedule_mfi.func_size = size;
425
426 get_frame_info(&schedule_mfi);
Franck Bui-Huu6057a792006-08-03 09:29:18 +0200427
428 /*
429 * Without schedule() frame info, result given by
430 * thread_saved_pc() and get_wchan() are not reliable.
431 */
Franck Bui-Huub5943182006-08-18 16:18:09 +0200432 if (schedule_mfi.pc_offset < 0)
Franck Bui-Huu6057a792006-08-03 09:29:18 +0200433 printk("Can't analyze schedule() prologue at %p\n", schedule);
Atsushi Nemoto63077512006-02-08 01:48:03 +0900434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 return 0;
436}
437
438arch_initcall(frame_info_init);
439
440/*
441 * Return saved PC of a blocked thread.
442 */
443unsigned long thread_saved_pc(struct task_struct *tsk)
444{
445 struct thread_struct *t = &tsk->thread;
446
447 /* New born processes are a special case */
448 if (t->reg31 == (unsigned long) ret_from_fork)
449 return t->reg31;
Franck Bui-Huub5943182006-08-18 16:18:09 +0200450 if (schedule_mfi.pc_offset < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 return 0;
Franck Bui-Huub5943182006-08-18 16:18:09 +0200452 return ((unsigned long *)t->reg29)[schedule_mfi.pc_offset];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453}
454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900456#ifdef CONFIG_KALLSYMS
Daniel Kalmar94ea09c2011-05-13 08:38:04 -0400457/* generic stack unwinding function */
458unsigned long notrace unwind_stack_by_address(unsigned long stack_page,
459 unsigned long *sp,
460 unsigned long pc,
461 unsigned long *ra)
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900462{
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900463 struct mips_frame_info info;
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900464 unsigned long size, ofs;
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200465 int leaf;
Atsushi Nemoto19246002006-09-29 18:02:51 +0900466 extern void ret_from_irq(void);
467 extern void ret_from_exception(void);
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900468
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900469 if (!stack_page)
470 return 0;
471
Atsushi Nemoto19246002006-09-29 18:02:51 +0900472 /*
473 * If we reached the bottom of interrupt context,
474 * return saved pc in pt_regs.
475 */
476 if (pc == (unsigned long)ret_from_irq ||
477 pc == (unsigned long)ret_from_exception) {
478 struct pt_regs *regs;
479 if (*sp >= stack_page &&
480 *sp + sizeof(*regs) <= stack_page + THREAD_SIZE - 32) {
481 regs = (struct pt_regs *)*sp;
482 pc = regs->cp0_epc;
483 if (__kernel_text_address(pc)) {
484 *sp = regs->regs[29];
485 *ra = regs->regs[31];
486 return pc;
487 }
488 }
489 return 0;
490 }
Franck Bui-Huu55b742832006-10-13 13:37:35 +0200491 if (!kallsyms_lookup_size_offset(pc, &size, &ofs))
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900492 return 0;
Franck Bui-Huu1fd69092006-08-18 16:18:07 +0200493 /*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300494 * Return ra if an exception occurred at the first instruction
Franck Bui-Huu1fd69092006-08-18 16:18:07 +0200495 */
Atsushi Nemoto19246002006-09-29 18:02:51 +0900496 if (unlikely(ofs == 0)) {
497 pc = *ra;
498 *ra = 0;
499 return pc;
500 }
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900501
502 info.func = (void *)(pc - ofs);
503 info.func_size = ofs; /* analyze from start to ofs */
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200504 leaf = get_frame_info(&info);
505 if (leaf < 0)
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900506 return 0;
507
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200508 if (*sp < stack_page ||
509 *sp + info.frame_size > stack_page + THREAD_SIZE - 32)
510 return 0;
511
512 if (leaf)
513 /*
514 * For some extreme cases, get_frame_info() can
515 * consider wrongly a nested function as a leaf
516 * one. In that cases avoid to return always the
517 * same value.
518 */
Atsushi Nemoto19246002006-09-29 18:02:51 +0900519 pc = pc != *ra ? *ra : 0;
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200520 else
521 pc = ((unsigned long *)(*sp))[info.pc_offset];
522
523 *sp += info.frame_size;
Atsushi Nemoto19246002006-09-29 18:02:51 +0900524 *ra = 0;
Franck Bui-Huu4d157d52006-08-03 09:29:21 +0200525 return __kernel_text_address(pc) ? pc : 0;
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900526}
Daniel Kalmar94ea09c2011-05-13 08:38:04 -0400527EXPORT_SYMBOL(unwind_stack_by_address);
528
529/* used by show_backtrace() */
530unsigned long unwind_stack(struct task_struct *task, unsigned long *sp,
531 unsigned long pc, unsigned long *ra)
532{
533 unsigned long stack_page = (unsigned long)task_stack_page(task);
534 return unwind_stack_by_address(stack_page, sp, pc, ra);
535}
Atsushi Nemotof66686f2006-07-29 23:27:20 +0900536#endif
Franck Bui-Huub5943182006-08-18 16:18:09 +0200537
538/*
539 * get_wchan - a maintenance nightmare^W^Wpain in the ass ...
540 */
541unsigned long get_wchan(struct task_struct *task)
542{
543 unsigned long pc = 0;
544#ifdef CONFIG_KALLSYMS
545 unsigned long sp;
Atsushi Nemoto19246002006-09-29 18:02:51 +0900546 unsigned long ra = 0;
Franck Bui-Huub5943182006-08-18 16:18:09 +0200547#endif
548
549 if (!task || task == current || task->state == TASK_RUNNING)
550 goto out;
551 if (!task_stack_page(task))
552 goto out;
553
554 pc = thread_saved_pc(task);
555
556#ifdef CONFIG_KALLSYMS
557 sp = task->thread.reg29 + schedule_mfi.frame_size;
558
559 while (in_sched_functions(pc))
Atsushi Nemoto19246002006-09-29 18:02:51 +0900560 pc = unwind_stack(task, &sp, pc, &ra);
Franck Bui-Huub5943182006-08-18 16:18:09 +0200561#endif
562
563out:
564 return pc;
565}
Franck Bui-Huu94109102007-07-19 14:04:21 +0200566
567/*
568 * Don't forget that the stack pointer must be aligned on a 8 bytes
569 * boundary for 32-bits ABI and 16 bytes for 64-bits ABI.
570 */
571unsigned long arch_align_stack(unsigned long sp)
572{
573 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
574 sp -= get_random_int() & ~PAGE_MASK;
575
576 return sp & ALMASK;
577}