[deliverable/linux.git] / arch / tile / kernel / stack.c

/*
 * Copyright 2010 Tilera Corporation. All Rights Reserved.
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation, version 2.
 *
 *   This program is distributed in the hope that it will be useful, but
 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 *   NON INFRINGEMENT.  See the GNU General Public License for
 *   more details.
 */

#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/kprobes.h>
#include <linux/module.h>
#include <linux/pfn.h>
#include <linux/kallsyms.h>
#include <linux/stacktrace.h>
#include <linux/uaccess.h>
#include <linux/mmzone.h>
#include <linux/dcache.h>
#include <linux/fs.h>
#include <linux/hardirq.h>
#include <linux/string.h>
#include <asm/backtrace.h>
#include <asm/page.h>
#include <asm/ucontext.h>
#include <asm/switch_to.h>
#include <asm/sigframe.h>
#include <asm/stack.h>
#include <asm/vdso.h>
#include <arch/abi.h>
#include <arch/interrupts.h>

#define KBT_ONGOING	0  /* Backtrace still ongoing */
#define KBT_DONE	1  /* Backtrace cleanly completed */
#define KBT_RUNNING	2  /* Can't run backtrace on a running task */
#define KBT_LOOP	3  /* Backtrace entered a loop */

/* Is address on the specified kernel stack? */
static int in_kernel_stack(struct KBacktraceIterator *kbt, unsigned long sp)
{
	ulong kstack_base = (ulong) kbt->task->stack;
	if (kstack_base == 0)  /* corrupt task pointer; just follow stack... */
		return sp >= PAGE_OFFSET && sp < (unsigned long)high_memory;
	return sp >= kstack_base && sp < kstack_base + THREAD_SIZE;
}

/* Callback for backtracer; basically a glorified memcpy */
static bool read_memory_func(void *result, unsigned long address,
			     unsigned int size, void *vkbt)
{
	int retval;
	struct KBacktraceIterator *kbt = (struct KBacktraceIterator *)vkbt;

	if (address == 0)
		return 0;
	if (__kernel_text_address(address)) {
		/* OK to read kernel code. */
	} else if (address >= PAGE_OFFSET) {
		/* We only tolerate kernel-space reads of this task's stack */
		if (!in_kernel_stack(kbt, address))
			return 0;
	} else if (!kbt->is_current) {
		return 0;	/* can't read from other user address spaces */
	}
	pagefault_disable();
	retval = __copy_from_user_inatomic(result,
					   (void __user __force *)address,
					   size);
	pagefault_enable();
	return (retval == 0);
}

/* Return a pt_regs pointer for a valid fault handler frame */
static struct pt_regs *valid_fault_handler(struct KBacktraceIterator* kbt)
{
	char fault[64];
	unsigned long sp = kbt->it.sp;
	struct pt_regs *p;

	if (sp % sizeof(long) != 0)
		return NULL;
	if (!in_kernel_stack(kbt, sp))
		return NULL;
	if (!in_kernel_stack(kbt, sp + C_ABI_SAVE_AREA_SIZE + PTREGS_SIZE-1))
		return NULL;
	p = (struct pt_regs *)(sp + C_ABI_SAVE_AREA_SIZE);
	if (kbt->verbose) {     /* else we aren't going to use it */
		if (p->faultnum == INT_SWINT_1 ||
		    p->faultnum == INT_SWINT_1_SIGRETURN)
			snprintf(fault, sizeof(fault),
				 "syscall %ld", p->regs[TREG_SYSCALL_NR]);
		else
			snprintf(fault, sizeof(fault),
				 "interrupt %ld", p->faultnum);
	}
	if (EX1_PL(p->ex1) == KERNEL_PL &&
	    __kernel_text_address(p->pc) &&
	    in_kernel_stack(kbt, p->sp) &&
	    p->sp >= sp) {
		if (kbt->verbose)
			pr_err("  <%s while in kernel mode>\n", fault);
	} else if (user_mode(p) &&
		   p->sp < PAGE_OFFSET && p->sp != 0) {
		if (kbt->verbose)
			pr_err("  <%s while in user mode>\n", fault);
	} else {
		if (kbt->verbose && (p->pc != 0 || p->sp != 0 || p->ex1 != 0))
			pr_err("  (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
			       p->pc, p->sp, p->ex1);
		return NULL;
	}
	if (kbt->profile && ((1ULL << p->faultnum) & QUEUED_INTERRUPTS) != 0)
		return NULL;
	return p;
}

/* Is the iterator pointing to a sigreturn trampoline? */
static int is_sigreturn(struct KBacktraceIterator *kbt)
{
	return kbt->task->mm &&
		(kbt->it.pc == ((ulong)kbt->task->mm->context.vdso_base +
				(ulong)&__vdso_rt_sigreturn));
}

/* Return a pt_regs pointer for a valid signal handler frame */
static struct pt_regs *valid_sigframe(struct KBacktraceIterator* kbt,
				      struct rt_sigframe* kframe)
{
	BacktraceIterator *b = &kbt->it;

	if (is_sigreturn(kbt) && b->sp < PAGE_OFFSET &&
	    b->sp % sizeof(long) == 0) {
		int retval;
		pagefault_disable();
		retval = __copy_from_user_inatomic(
			kframe, (void __user __force *)b->sp,
			sizeof(*kframe));
		pagefault_enable();
		if (retval != 0 ||
		    (unsigned int)(kframe->info.si_signo) >= _NSIG)
			return NULL;
		if (kbt->verbose) {
			pr_err("  <received signal %d>\n",
			       kframe->info.si_signo);
		}
		return (struct pt_regs *)&kframe->uc.uc_mcontext;
	}
	return NULL;
}

static int KBacktraceIterator_restart(struct KBacktraceIterator *kbt)
{
	struct pt_regs *p;
	struct rt_sigframe kframe;

	p = valid_fault_handler(kbt);
	if (p == NULL)
		p = valid_sigframe(kbt, &kframe);
	if (p == NULL)
		return 0;
	backtrace_init(&kbt->it, read_memory_func, kbt,
		       p->pc, p->lr, p->sp, p->regs[52]);
	kbt->new_context = 1;
	return 1;
}

/* Find a frame that isn't a sigreturn, if there is one. */
static int KBacktraceIterator_next_item_inclusive(
	struct KBacktraceIterator *kbt)
{
	for (;;) {
		do {
			if (!is_sigreturn(kbt))
				return KBT_ONGOING;
		} while (backtrace_next(&kbt->it));

		if (!KBacktraceIterator_restart(kbt))
			return KBT_DONE;
	}
}

/*
 * If the current sp is on a page different than what we recorded
 * as the top-of-kernel-stack last time we context switched, we have
 * probably blown the stack, and nothing is going to work out well.
 * If we can at least get out a warning, that may help the debug,
 * though we probably won't be able to backtrace into the code that
 * actually did the recursive damage.
 */
static void validate_stack(struct pt_regs *regs)
{
	int cpu = raw_smp_processor_id();
	unsigned long ksp0 = get_current_ksp0();
	unsigned long ksp0_base = ksp0 & -THREAD_SIZE;
	unsigned long sp = stack_pointer;

	if (EX1_PL(regs->ex1) == KERNEL_PL && regs->sp >= ksp0) {
		pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx underrun!\n"
		       "  sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
		       cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
	}

	else if (sp < ksp0_base + sizeof(struct thread_info)) {
		pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx overrun!\n"
		       "  sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
		       cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
	}
}

void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
			     struct task_struct *t, struct pt_regs *regs)
{
	unsigned long pc, lr, sp, r52;
	int is_current;

	/*
	 * Set up callback information.  We grab the kernel stack base
	 * so we will allow reads of that address range.
	 */
	is_current = (t == NULL || t == current);
	kbt->is_current = is_current;
	if (is_current)
		t = validate_current();
	kbt->task = t;
	kbt->verbose = 0;   /* override in caller if desired */
	kbt->profile = 0;   /* override in caller if desired */
	kbt->end = KBT_ONGOING;
	kbt->new_context = 1;
	if (is_current)
		validate_stack(regs);

	if (regs == NULL) {
		if (is_current || t->state == TASK_RUNNING) {
			/* Can't do this; we need registers */
			kbt->end = KBT_RUNNING;
			return;
		}
		pc = get_switch_to_pc();
		lr = t->thread.pc;
		sp = t->thread.ksp;
		r52 = 0;
	} else {
		pc = regs->pc;
		lr = regs->lr;
		sp = regs->sp;
		r52 = regs->regs[52];
	}

	backtrace_init(&kbt->it, read_memory_func, kbt, pc, lr, sp, r52);
	kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
}
EXPORT_SYMBOL(KBacktraceIterator_init);

int KBacktraceIterator_end(struct KBacktraceIterator *kbt)
{
	return kbt->end != KBT_ONGOING;
}
EXPORT_SYMBOL(KBacktraceIterator_end);

void KBacktraceIterator_next(struct KBacktraceIterator *kbt)
{
	unsigned long old_pc = kbt->it.pc, old_sp = kbt->it.sp;
	kbt->new_context = 0;
	if (!backtrace_next(&kbt->it) && !KBacktraceIterator_restart(kbt)) {
		kbt->end = KBT_DONE;
		return;
	}
	kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
	if (old_pc == kbt->it.pc && old_sp == kbt->it.sp) {
		/* Trapped in a loop; give up. */
		kbt->end = KBT_LOOP;
	}
}
EXPORT_SYMBOL(KBacktraceIterator_next);

static void describe_addr(struct KBacktraceIterator *kbt,
			  unsigned long address,
			  int have_mmap_sem, char *buf, size_t bufsize)
{
	struct vm_area_struct *vma;
	size_t namelen, remaining;
	unsigned long size, offset, adjust;
	char *p, *modname;
	const char *name;
	int rc;

	/*
	 * Look one byte back for every caller frame (i.e. those that
	 * aren't a new context) so we look up symbol data for the
	 * call itself, not the following instruction, which may be on
	 * a different line (or in a different function).
	 */
	adjust = !kbt->new_context;
	address -= adjust;

	if (address >= PAGE_OFFSET) {
		/* Handle kernel symbols. */
		BUG_ON(bufsize < KSYM_NAME_LEN);
		name = kallsyms_lookup(address, &size, &offset,
				       &modname, buf);
		if (name == NULL) {
			buf[0] = '\0';
			return;
		}
		namelen = strlen(buf);
		remaining = (bufsize - 1) - namelen;
		p = buf + namelen;
		rc = snprintf(p, remaining, "+%#lx/%#lx ",
			      offset + adjust, size);
		if (modname && rc < remaining)
			snprintf(p + rc, remaining - rc, "[%s] ", modname);
		buf[bufsize-1] = '\0';
		return;
	}

	/* If we don't have the mmap_sem, we can't show any more info. */
	buf[0] = '\0';
	if (!have_mmap_sem)
		return;

	/* Find vma info. */
	vma = find_vma(kbt->task->mm, address);
	if (vma == NULL || address < vma->vm_start) {
		snprintf(buf, bufsize, "[unmapped address] ");
		return;
	}

	if (vma->vm_file) {
		p = file_path(vma->vm_file, buf, bufsize);
		if (IS_ERR(p))
			p = "?";
		name = kbasename(p);
	} else {
		name = "anon";
	}

	/* Generate a string description of the vma info. */
	namelen = strlen(name);
	remaining = (bufsize - 1) - namelen;
	memmove(buf, name, namelen);
	snprintf(buf + namelen, remaining, "[%lx+%lx] ",
		 vma->vm_start, vma->vm_end - vma->vm_start);
}

/*
 * Avoid possible crash recursion during backtrace.  If it happens, it
 * makes it easy to lose the actual root cause of the failure, so we
 * put a simple guard on all the backtrace loops.
 */
static bool start_backtrace(void)
{
	if (current_thread_info()->in_backtrace) {
		pr_err("Backtrace requested while in backtrace!\n");
		return false;
	}
	current_thread_info()->in_backtrace = true;
	return true;
}

static void end_backtrace(void)
{
	current_thread_info()->in_backtrace = false;
}

/*
 * This method wraps the backtracer's more generic support.
 * It is only invoked from the architecture-specific code; show_stack()
 * and dump_stack() are architecture-independent entry points.
 */
void tile_show_stack(struct KBacktraceIterator *kbt)
{
	int i;
	int have_mmap_sem = 0;

	if (!start_backtrace())
		return;
	kbt->verbose = 1;
	i = 0;
	for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
		char namebuf[KSYM_NAME_LEN+100];
		unsigned long address = kbt->it.pc;

		/*
		 * Try to acquire the mmap_sem as we pass into userspace.
		 * If we're in an interrupt context, don't even try, since
		 * it's not safe to call e.g. d_path() from an interrupt,
		 * since it uses spin locks without disabling interrupts.
		 * Note we test "kbt->task == current", not "kbt->is_current",
		 * since we're checking that "current" will work in d_path().
		 */
		if (kbt->task == current && address < PAGE_OFFSET &&
		    !have_mmap_sem && kbt->task->mm && !in_interrupt()) {
			have_mmap_sem =
				down_read_trylock(&kbt->task->mm->mmap_sem);
		}

		describe_addr(kbt, address, have_mmap_sem,
			      namebuf, sizeof(namebuf));

		pr_err("  frame %d: 0x%lx %s(sp 0x%lx)\n",
		       i++, address, namebuf, (unsigned long)(kbt->it.sp));

		if (i >= 100) {
			pr_err("Stack dump truncated (%d frames)\n", i);
			break;
		}
	}
	if (kbt->end == KBT_LOOP)
		pr_err("Stack dump stopped; next frame identical to this one\n");
	if (have_mmap_sem)
		up_read(&kbt->task->mm->mmap_sem);
	end_backtrace();
}
EXPORT_SYMBOL(tile_show_stack);

static struct pt_regs *regs_to_pt_regs(struct pt_regs *regs,
				       ulong pc, ulong lr, ulong sp, ulong r52)
{
	memset(regs, 0, sizeof(struct pt_regs));
	regs->pc = pc;
	regs->lr = lr;
	regs->sp = sp;
	regs->regs[52] = r52;
	return regs;
}

/* Deprecated function currently only used by kernel_double_fault(). */
void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
{
	struct KBacktraceIterator kbt;
	struct pt_regs regs;

	regs_to_pt_regs(&regs, pc, lr, sp, r52);
	KBacktraceIterator_init(&kbt, NULL, &regs);
	tile_show_stack(&kbt);
}

/* This is called from KBacktraceIterator_init_current() */
void _KBacktraceIterator_init_current(struct KBacktraceIterator *kbt, ulong pc,
				      ulong lr, ulong sp, ulong r52)
{
	struct pt_regs regs;
	KBacktraceIterator_init(kbt, NULL,
				regs_to_pt_regs(&regs, pc, lr, sp, r52));
}

/*
 * Called from sched_show_task() with task != NULL, or dump_stack()
 * with task == NULL.  The esp argument is always NULL.
 */
void show_stack(struct task_struct *task, unsigned long *esp)
{
	struct KBacktraceIterator kbt;
	if (task == NULL || task == current) {
		KBacktraceIterator_init_current(&kbt);
		KBacktraceIterator_next(&kbt);  /* don't show first frame */
	} else {
		KBacktraceIterator_init(&kbt, task, NULL);
	}
	tile_show_stack(&kbt);
}

#ifdef CONFIG_STACKTRACE

/* Support generic Linux stack API too */

static void save_stack_trace_common(struct task_struct *task,
				    struct pt_regs *regs,
				    bool user,
				    struct stack_trace *trace)
{
	struct KBacktraceIterator kbt;
	int skip = trace->skip;
	int i = 0;

	if (!start_backtrace())
		goto done;
	if (regs != NULL) {
		KBacktraceIterator_init(&kbt, NULL, regs);
	} else if (task == NULL || task == current) {
		KBacktraceIterator_init_current(&kbt);
		skip++;  /* don't show KBacktraceIterator_init_current */
	} else {
		KBacktraceIterator_init(&kbt, task, NULL);
	}
	for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
		if (skip) {
			--skip;
			continue;
		}
		if (i >= trace->max_entries ||
		    (!user && kbt.it.pc < PAGE_OFFSET))
			break;
		trace->entries[i++] = kbt.it.pc;
	}
	end_backtrace();
done:
	if (i < trace->max_entries)
		trace->entries[i++] = ULONG_MAX;
	trace->nr_entries = i;
}

void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
{
	save_stack_trace_common(task, NULL, false, trace);
}
EXPORT_SYMBOL(save_stack_trace_tsk);

void save_stack_trace(struct stack_trace *trace)
{
	save_stack_trace_common(NULL, NULL, false, trace);
}
EXPORT_SYMBOL_GPL(save_stack_trace);

void save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace)
{
	save_stack_trace_common(NULL, regs, false, trace);
}

void save_stack_trace_user(struct stack_trace *trace)
{
	/* Trace user stack if we are not a kernel thread. */
	if (current->mm)
		save_stack_trace_common(NULL, task_pt_regs(current),
					true, trace);
	else if (trace->nr_entries < trace->max_entries)
		trace->entries[trace->nr_entries++] = ULONG_MAX;
}
#endif

/* In entry.S */
EXPORT_SYMBOL(KBacktraceIterator_init_current);
Commit	Line	Data
867e359b CM	1	/*
	2	* Copyright 2010 Tilera Corporation. All Rights Reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation, version 2.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
	11	* NON INFRINGEMENT. See the GNU General Public License for
	12	* more details.
	13	*/
	14
	15	#include <linux/sched.h>
	16	#include <linux/kernel.h>
	17	#include <linux/kprobes.h>
	18	#include <linux/module.h>
	19	#include <linux/pfn.h>
	20	#include <linux/kallsyms.h>
	21	#include <linux/stacktrace.h>
	22	#include <linux/uaccess.h>
	23	#include <linux/mmzone.h>
5f639fdc CM	24	#include <linux/dcache.h>
5f639fdc CM	25	#include <linux/fs.h>
47ad7b9b	26	#include <linux/hardirq.h>
0cc96a74	27	#include <linux/string.h>
867e359b CM	28	#include <asm/backtrace.h>
867e359b CM	29	#include <asm/page.h>
867e359b	30	#include <asm/ucontext.h>
34f2c0ac	31	#include <asm/switch_to.h>
867e359b CM	32	#include <asm/sigframe.h>
867e359b CM	33	#include <asm/stack.h>
4a556f4f	34	#include <asm/vdso.h>
867e359b CM	35	#include <arch/abi.h>
	36	#include <arch/interrupts.h>
	37
dabe98c9 CM	38	#define KBT_ONGOING 0 /* Backtrace still ongoing */
	39	#define KBT_DONE 1 /* Backtrace cleanly completed */
	40	#define KBT_RUNNING 2 /* Can't run backtrace on a running task */
	41	#define KBT_LOOP 3 /* Backtrace entered a loop */
867e359b CM	42
867e359b CM	43	/* Is address on the specified kernel stack? */
93013a0f	44	static int in_kernel_stack(struct KBacktraceIterator *kbt, unsigned long sp)
867e359b CM	45	{
	46	ulong kstack_base = (ulong) kbt->task->stack;
	47	if (kstack_base == 0) /* corrupt task pointer; just follow stack... */
	48	return sp >= PAGE_OFFSET && sp < (unsigned long)high_memory;
	49	return sp >= kstack_base && sp < kstack_base + THREAD_SIZE;
	50	}
	51
867e359b	52	/* Callback for backtracer; basically a glorified memcpy */
93013a0f	53	static bool read_memory_func(void *result, unsigned long address,
867e359b CM	54	unsigned int size, void *vkbt)
	55	{
	56	int retval;
	57	struct KBacktraceIterator kbt = (struct KBacktraceIterator )vkbt;
5f639fdc CM	58
	59	if (address == 0)
	60	return 0;
3cebbafd	61	if (__kernel_text_address(address)) {
867e359b CM	62	/* OK to read kernel code. */
	63	} else if (address >= PAGE_OFFSET) {
	64	/* We only tolerate kernel-space reads of this task's stack */
	65	if (!in_kernel_stack(kbt, address))
	66	return 0;
5f639fdc CM	67	} else if (!kbt->is_current) {
5f639fdc CM	68	return 0; /* can't read from other user address spaces */
867e359b CM	69	}
867e359b CM	70	pagefault_disable();
0707ad30 CM	71	retval = __copy_from_user_inatomic(result,
0707ad30 CM	72	(void __user __force *)address,
867e359b CM	73	size);
	74	pagefault_enable();
	75	return (retval == 0);
	76	}
	77
	78	/* Return a pt_regs pointer for a valid fault handler frame */
	79	static struct pt_regs valid_fault_handler(struct KBacktraceIterator kbt)
	80	{
5ac65abd	81	char fault[64];
93013a0f	82	unsigned long sp = kbt->it.sp;
867e359b CM	83	struct pt_regs *p;
867e359b CM	84
5f639fdc CM	85	if (sp % sizeof(long) != 0)
5f639fdc CM	86	return NULL;
867e359b CM	87	if (!in_kernel_stack(kbt, sp))
	88	return NULL;
	89	if (!in_kernel_stack(kbt, sp + C_ABI_SAVE_AREA_SIZE + PTREGS_SIZE-1))
	90	return NULL;
	91	p = (struct pt_regs *)(sp + C_ABI_SAVE_AREA_SIZE);
5ac65abd CM	92	if (kbt->verbose) { /* else we aren't going to use it */
	93	if (p->faultnum == INT_SWINT_1 \|\|
	94	p->faultnum == INT_SWINT_1_SIGRETURN)
	95	snprintf(fault, sizeof(fault),
	96	"syscall %ld", p->regs[TREG_SYSCALL_NR]);
	97	else
	98	snprintf(fault, sizeof(fault),
867e359b	99	"interrupt %ld", p->faultnum);
867e359b CM	100	}
867e359b CM	101	if (EX1_PL(p->ex1) == KERNEL_PL &&
3cebbafd	102	__kernel_text_address(p->pc) &&
867e359b CM	103	in_kernel_stack(kbt, p->sp) &&
	104	p->sp >= sp) {
	105	if (kbt->verbose)
0707ad30	106	pr_err(" <%s while in kernel mode>\n", fault);
051168df	107	} else if (user_mode(p) &&
3ef23111	108	p->sp < PAGE_OFFSET && p->sp != 0) {
867e359b	109	if (kbt->verbose)
0707ad30	110	pr_err(" <%s while in user mode>\n", fault);
9088616f	111	} else {
47ad7b9b	112	if (kbt->verbose && (p->pc != 0 \|\| p->sp != 0 \|\| p->ex1 != 0))
9088616f CIK	113	pr_err(" (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
	114	p->pc, p->sp, p->ex1);
	115	return NULL;
867e359b	116	}
9088616f CIK	117	if (kbt->profile && ((1ULL << p->faultnum) & QUEUED_INTERRUPTS) != 0)
	118	return NULL;
	119	return p;
867e359b CM	120	}
867e359b CM	121
47ad7b9b CM	122	/* Is the iterator pointing to a sigreturn trampoline? */
47ad7b9b CM	123	static int is_sigreturn(struct KBacktraceIterator *kbt)
867e359b	124	{
47ad7b9b CM	125	return kbt->task->mm &&
	126	(kbt->it.pc == ((ulong)kbt->task->mm->context.vdso_base +
	127	(ulong)&__vdso_rt_sigreturn));
867e359b CM	128	}
	129
	130	/* Return a pt_regs pointer for a valid signal handler frame */
5f639fdc CM	131	static struct pt_regs valid_sigframe(struct KBacktraceIterator kbt,
5f639fdc CM	132	struct rt_sigframe* kframe)
867e359b CM	133	{
	134	BacktraceIterator *b = &kbt->it;
	135
47ad7b9b	136	if (is_sigreturn(kbt) && b->sp < PAGE_OFFSET &&
5f639fdc CM	137	b->sp % sizeof(long) == 0) {
	138	int retval;
	139	pagefault_disable();
	140	retval = __copy_from_user_inatomic(
	141	kframe, (void __user __force *)b->sp,
	142	sizeof(*kframe));
	143	pagefault_enable();
	144	if (retval != 0 \|\|
	145	(unsigned int)(kframe->info.si_signo) >= _NSIG)
867e359b	146	return NULL;
867e359b	147	if (kbt->verbose) {
0707ad30	148	pr_err(" <received signal %d>\n",
5f639fdc	149	kframe->info.si_signo);
867e359b	150	}
5f639fdc	151	return (struct pt_regs *)&kframe->uc.uc_mcontext;
867e359b CM	152	}
	153	return NULL;
	154	}
	155
867e359b CM	156	static int KBacktraceIterator_restart(struct KBacktraceIterator *kbt)
	157	{
	158	struct pt_regs *p;
5f639fdc	159	struct rt_sigframe kframe;
867e359b CM	160
	161	p = valid_fault_handler(kbt);
	162	if (p == NULL)
5f639fdc	163	p = valid_sigframe(kbt, &kframe);
867e359b CM	164	if (p == NULL)
	165	return 0;
	166	backtrace_init(&kbt->it, read_memory_func, kbt,
	167	p->pc, p->lr, p->sp, p->regs[52]);
	168	kbt->new_context = 1;
	169	return 1;
	170	}
	171
	172	/* Find a frame that isn't a sigreturn, if there is one. */
	173	static int KBacktraceIterator_next_item_inclusive(
	174	struct KBacktraceIterator *kbt)
	175	{
	176	for (;;) {
	177	do {
47ad7b9b	178	if (!is_sigreturn(kbt))
dabe98c9	179	return KBT_ONGOING;
867e359b CM	180	} while (backtrace_next(&kbt->it));
	181
	182	if (!KBacktraceIterator_restart(kbt))
dabe98c9	183	return KBT_DONE;
867e359b CM	184	}
	185	}
	186
	187	/*
	188	* If the current sp is on a page different than what we recorded
	189	* as the top-of-kernel-stack last time we context switched, we have
	190	* probably blown the stack, and nothing is going to work out well.
	191	* If we can at least get out a warning, that may help the debug,
	192	* though we probably won't be able to backtrace into the code that
	193	* actually did the recursive damage.
	194	*/
	195	static void validate_stack(struct pt_regs *regs)
	196	{
bc1a298f	197	int cpu = raw_smp_processor_id();
867e359b	198	unsigned long ksp0 = get_current_ksp0();
35f05976	199	unsigned long ksp0_base = ksp0 & -THREAD_SIZE;
867e359b CM	200	unsigned long sp = stack_pointer;
	201
	202	if (EX1_PL(regs->ex1) == KERNEL_PL && regs->sp >= ksp0) {
35f05976	203	pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx underrun!\n"
867e359b	204	" sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
35f05976	205	cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
867e359b CM	206	}
	207
	208	else if (sp < ksp0_base + sizeof(struct thread_info)) {
35f05976	209	pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx overrun!\n"
867e359b	210	" sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
35f05976	211	cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
867e359b CM	212	}
	213	}
	214
	215	void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
	216	struct task_struct t, struct pt_regs regs)
	217	{
93013a0f	218	unsigned long pc, lr, sp, r52;
867e359b CM	219	int is_current;
	220
	221	/*
	222	* Set up callback information. We grab the kernel stack base
5f639fdc	223	* so we will allow reads of that address range.
867e359b	224	*/
5f639fdc	225	is_current = (t == NULL \|\| t == current);
867e359b CM	226	kbt->is_current = is_current;
	227	if (is_current)
	228	t = validate_current();
	229	kbt->task = t;
867e359b CM	230	kbt->verbose = 0; /* override in caller if desired */
867e359b CM	231	kbt->profile = 0; /* override in caller if desired */
dabe98c9	232	kbt->end = KBT_ONGOING;
5f639fdc CM	233	kbt->new_context = 1;
5f639fdc CM	234	if (is_current)
867e359b	235	validate_stack(regs);
867e359b CM	236
867e359b CM	237	if (regs == NULL) {
867e359b CM	238	if (is_current \|\| t->state == TASK_RUNNING) {
867e359b CM	239	/* Can't do this; we need registers */
dabe98c9	240	kbt->end = KBT_RUNNING;
867e359b CM	241	return;
867e359b CM	242	}
0707ad30	243	pc = get_switch_to_pc();
867e359b CM	244	lr = t->thread.pc;
	245	sp = t->thread.ksp;
	246	r52 = 0;
	247	} else {
	248	pc = regs->pc;
	249	lr = regs->lr;
	250	sp = regs->sp;
	251	r52 = regs->regs[52];
	252	}
	253
	254	backtrace_init(&kbt->it, read_memory_func, kbt, pc, lr, sp, r52);
dabe98c9	255	kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
867e359b CM	256	}
	257	EXPORT_SYMBOL(KBacktraceIterator_init);
	258
	259	int KBacktraceIterator_end(struct KBacktraceIterator *kbt)
	260	{
dabe98c9	261	return kbt->end != KBT_ONGOING;
867e359b CM	262	}
	263	EXPORT_SYMBOL(KBacktraceIterator_end);
	264
	265	void KBacktraceIterator_next(struct KBacktraceIterator *kbt)
	266	{
93013a0f	267	unsigned long old_pc = kbt->it.pc, old_sp = kbt->it.sp;
867e359b	268	kbt->new_context = 0;
dabe98c9 CM	269	if (!backtrace_next(&kbt->it) && !KBacktraceIterator_restart(kbt)) {
	270	kbt->end = KBT_DONE;
	271	return;
	272	}
	273	kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
	274	if (old_pc == kbt->it.pc && old_sp == kbt->it.sp) {
	275	/* Trapped in a loop; give up. */
	276	kbt->end = KBT_LOOP;
	277	}
867e359b CM	278	}
	279	EXPORT_SYMBOL(KBacktraceIterator_next);
	280
5f639fdc CM	281	static void describe_addr(struct KBacktraceIterator *kbt,
	282	unsigned long address,
	283	int have_mmap_sem, char *buf, size_t bufsize)
	284	{
	285	struct vm_area_struct *vma;
	286	size_t namelen, remaining;
	287	unsigned long size, offset, adjust;
	288	char p, modname;
	289	const char *name;
	290	int rc;
	291
	292	/*
	293	* Look one byte back for every caller frame (i.e. those that
	294	* aren't a new context) so we look up symbol data for the
	295	* call itself, not the following instruction, which may be on
	296	* a different line (or in a different function).
	297	*/
	298	adjust = !kbt->new_context;
	299	address -= adjust;
	300
	301	if (address >= PAGE_OFFSET) {
	302	/* Handle kernel symbols. */
	303	BUG_ON(bufsize < KSYM_NAME_LEN);
	304	name = kallsyms_lookup(address, &size, &offset,
	305	&modname, buf);
	306	if (name == NULL) {
	307	buf[0] = '\0';
	308	return;
	309	}
	310	namelen = strlen(buf);
	311	remaining = (bufsize - 1) - namelen;
	312	p = buf + namelen;
	313	rc = snprintf(p, remaining, "+%#lx/%#lx ",
	314	offset + adjust, size);
	315	if (modname && rc < remaining)
	316	snprintf(p + rc, remaining - rc, "[%s] ", modname);
	317	buf[bufsize-1] = '\0';
	318	return;
	319	}
	320
	321	/* If we don't have the mmap_sem, we can't show any more info. */
	322	buf[0] = '\0';
	323	if (!have_mmap_sem)
	324	return;
	325
	326	/* Find vma info. */
	327	vma = find_vma(kbt->task->mm, address);
	328	if (vma == NULL \|\| address < vma->vm_start) {
	329	snprintf(buf, bufsize, "[unmapped address] ");
	330	return;
	331	}
	332
	333	if (vma->vm_file) {
9bf39ab2	334	p = file_path(vma->vm_file, buf, bufsize);
5f639fdc CM	335	if (IS_ERR(p))
5f639fdc CM	336	p = "?";
0cc96a74	337	name = kbasename(p);
5f639fdc	338	} else {
0cc96a74	339	name = "anon";
5f639fdc CM	340	}
	341
	342	/* Generate a string description of the vma info. */
0cc96a74	343	namelen = strlen(name);
5f639fdc	344	remaining = (bufsize - 1) - namelen;
0cc96a74	345	memmove(buf, name, namelen);
5f639fdc CM	346	snprintf(buf + namelen, remaining, "[%lx+%lx] ",
	347	vma->vm_start, vma->vm_end - vma->vm_start);
	348	}
	349
3ef23111 CM	350	/*
	351	* Avoid possible crash recursion during backtrace. If it happens, it
	352	* makes it easy to lose the actual root cause of the failure, so we
	353	* put a simple guard on all the backtrace loops.
	354	*/
	355	static bool start_backtrace(void)
	356	{
47ad7b9b	357	if (current_thread_info()->in_backtrace) {
3ef23111 CM	358	pr_err("Backtrace requested while in backtrace!\n");
	359	return false;
	360	}
47ad7b9b	361	current_thread_info()->in_backtrace = true;
3ef23111 CM	362	return true;
	363	}
	364
	365	static void end_backtrace(void)
	366	{
47ad7b9b	367	current_thread_info()->in_backtrace = false;
3ef23111 CM	368	}
3ef23111 CM	369
867e359b CM	370	/*
	371	* This method wraps the backtracer's more generic support.
	372	* It is only invoked from the architecture-specific code; show_stack()
47ad7b9b	373	* and dump_stack() are architecture-independent entry points.
867e359b	374	*/
47ad7b9b	375	void tile_show_stack(struct KBacktraceIterator *kbt)
867e359b CM	376	{
867e359b CM	377	int i;
5f639fdc	378	int have_mmap_sem = 0;
867e359b	379
3ef23111 CM	380	if (!start_backtrace())
3ef23111 CM	381	return;
867e359b CM	382	kbt->verbose = 1;
	383	i = 0;
	384	for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
867e359b	385	char namebuf[KSYM_NAME_LEN+100];
5f639fdc	386	unsigned long address = kbt->it.pc;
867e359b	387
47ad7b9b CM	388	/*
	389	* Try to acquire the mmap_sem as we pass into userspace.
	390	* If we're in an interrupt context, don't even try, since
	391	* it's not safe to call e.g. d_path() from an interrupt,
	392	* since it uses spin locks without disabling interrupts.
	393	* Note we test "kbt->task == current", not "kbt->is_current",
	394	* since we're checking that "current" will work in d_path().
	395	*/
	396	if (kbt->task == current && address < PAGE_OFFSET &&
	397	!have_mmap_sem && kbt->task->mm && !in_interrupt()) {
5f639fdc CM	398	have_mmap_sem =
5f639fdc CM	399	down_read_trylock(&kbt->task->mm->mmap_sem);
47ad7b9b	400	}
5f639fdc CM	401
	402	describe_addr(kbt, address, have_mmap_sem,
	403	namebuf, sizeof(namebuf));
867e359b	404
0707ad30	405	pr_err(" frame %d: 0x%lx %s(sp 0x%lx)\n",
867e359b CM	406	i++, address, namebuf, (unsigned long)(kbt->it.sp));
	407
	408	if (i >= 100) {
f4743673	409	pr_err("Stack dump truncated (%d frames)\n", i);
867e359b CM	410	break;
	411	}
	412	}
dabe98c9 CM	413	if (kbt->end == KBT_LOOP)
dabe98c9 CM	414	pr_err("Stack dump stopped; next frame identical to this one\n");
5f639fdc CM	415	if (have_mmap_sem)
5f639fdc CM	416	up_read(&kbt->task->mm->mmap_sem);
3ef23111	417	end_backtrace();
867e359b CM	418	}
	419	EXPORT_SYMBOL(tile_show_stack);
	420
867e359b CM	421	static struct pt_regs regs_to_pt_regs(struct pt_regs regs,
	422	ulong pc, ulong lr, ulong sp, ulong r52)
	423	{
	424	memset(regs, 0, sizeof(struct pt_regs));
	425	regs->pc = pc;
	426	regs->lr = lr;
	427	regs->sp = sp;
	428	regs->regs[52] = r52;
	429	return regs;
	430	}
	431
47ad7b9b	432	/* Deprecated function currently only used by kernel_double_fault(). */
867e359b CM	433	void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
867e359b CM	434	{
47ad7b9b	435	struct KBacktraceIterator kbt;
867e359b	436	struct pt_regs regs;
47ad7b9b CM	437
	438	regs_to_pt_regs(&regs, pc, lr, sp, r52);
	439	KBacktraceIterator_init(&kbt, NULL, &regs);
	440	tile_show_stack(&kbt);
867e359b CM	441	}
	442
	443	/* This is called from KBacktraceIterator_init_current() */
	444	void _KBacktraceIterator_init_current(struct KBacktraceIterator *kbt, ulong pc,
	445	ulong lr, ulong sp, ulong r52)
	446	{
	447	struct pt_regs regs;
	448	KBacktraceIterator_init(kbt, NULL,
	449	regs_to_pt_regs(&regs, pc, lr, sp, r52));
	450	}
	451
47ad7b9b CM	452	/*
	453	* Called from sched_show_task() with task != NULL, or dump_stack()
	454	* with task == NULL. The esp argument is always NULL.
	455	*/
867e359b CM	456	void show_stack(struct task_struct task, unsigned long esp)
	457	{
	458	struct KBacktraceIterator kbt;
47ad7b9b	459	if (task == NULL \|\| task == current) {
867e359b	460	KBacktraceIterator_init_current(&kbt);
47ad7b9b CM	461	KBacktraceIterator_next(&kbt); /* don't show first frame */
47ad7b9b CM	462	} else {
867e359b	463	KBacktraceIterator_init(&kbt, task, NULL);
47ad7b9b CM	464	}
47ad7b9b CM	465	tile_show_stack(&kbt);
867e359b CM	466	}
	467
	468	#ifdef CONFIG_STACKTRACE
	469
	470	/* Support generic Linux stack API too */
	471
47ad7b9b CM	472	static void save_stack_trace_common(struct task_struct *task,
	473	struct pt_regs *regs,
	474	bool user,
	475	struct stack_trace *trace)
867e359b CM	476	{
	477	struct KBacktraceIterator kbt;
	478	int skip = trace->skip;
	479	int i = 0;
	480
3ef23111 CM	481	if (!start_backtrace())
3ef23111 CM	482	goto done;
47ad7b9b CM	483	if (regs != NULL) {
	484	KBacktraceIterator_init(&kbt, NULL, regs);
	485	} else if (task == NULL \|\| task == current) {
867e359b	486	KBacktraceIterator_init_current(&kbt);
47ad7b9b CM	487	skip++; /* don't show KBacktraceIterator_init_current */
47ad7b9b CM	488	} else {
867e359b	489	KBacktraceIterator_init(&kbt, task, NULL);
47ad7b9b	490	}
867e359b CM	491	for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
	492	if (skip) {
	493	--skip;
	494	continue;
	495	}
47ad7b9b CM	496	if (i >= trace->max_entries \|\|
47ad7b9b CM	497	(!user && kbt.it.pc < PAGE_OFFSET))
867e359b CM	498	break;
	499	trace->entries[i++] = kbt.it.pc;
	500	}
3ef23111 CM	501	end_backtrace();
3ef23111 CM	502	done:
47ad7b9b CM	503	if (i < trace->max_entries)
47ad7b9b CM	504	trace->entries[i++] = ULONG_MAX;
867e359b CM	505	trace->nr_entries = i;
867e359b CM	506	}
47ad7b9b CM	507
	508	void save_stack_trace_tsk(struct task_struct task, struct stack_trace trace)
	509	{
	510	save_stack_trace_common(task, NULL, false, trace);
	511	}
867e359b CM	512	EXPORT_SYMBOL(save_stack_trace_tsk);
	513
	514	void save_stack_trace(struct stack_trace *trace)
	515	{
47ad7b9b	516	save_stack_trace_common(NULL, NULL, false, trace);
867e359b	517	}
7c63e1ee	518	EXPORT_SYMBOL_GPL(save_stack_trace);
867e359b	519
47ad7b9b CM	520	void save_stack_trace_regs(struct pt_regs regs, struct stack_trace trace)
	521	{
	522	save_stack_trace_common(NULL, regs, false, trace);
	523	}
	524
	525	void save_stack_trace_user(struct stack_trace *trace)
	526	{
	527	/* Trace user stack if we are not a kernel thread. */
	528	if (current->mm)
	529	save_stack_trace_common(NULL, task_pt_regs(current),
	530	true, trace);
	531	else if (trace->nr_entries < trace->max_entries)
	532	trace->entries[trace->nr_entries++] = ULONG_MAX;
	533	}
867e359b CM	534	#endif
	535
	536	/* In entry.S */
	537	EXPORT_SYMBOL(KBacktraceIterator_init_current);