[net-next-2.6.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 <asm/backtrace.h>
#include <asm/page.h>
#include <asm/tlbflush.h>
#include <asm/ucontext.h>
#include <asm/sigframe.h>
#include <asm/stack.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, VirtualAddress 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;
}

/* Is address in the specified kernel code? */
static int in_kernel_text(VirtualAddress address)
{
	return (address >= MEM_SV_INTRPT &&
		address < MEM_SV_INTRPT + HPAGE_SIZE);
}

/* Is address valid for reading? */
static int valid_address(struct KBacktraceIterator *kbt, VirtualAddress address)
{
	HV_PTE *l1_pgtable = kbt->pgtable;
	HV_PTE *l2_pgtable;
	unsigned long pfn;
	HV_PTE pte;
	struct page *page;

	if (l1_pgtable == NULL)
		return 0;	/* can't read user space in other tasks */

	pte = l1_pgtable[HV_L1_INDEX(address)];
	if (!hv_pte_get_present(pte))
		return 0;
	pfn = hv_pte_get_pfn(pte);
	if (pte_huge(pte)) {
		if (!pfn_valid(pfn)) {
			pr_err("huge page has bad pfn %#lx\n", pfn);
			return 0;
		}
		return hv_pte_get_present(pte) && hv_pte_get_readable(pte);
	}

	page = pfn_to_page(pfn);
	if (PageHighMem(page)) {
		pr_err("L2 page table not in LOWMEM (%#llx)\n",
		       HV_PFN_TO_CPA(pfn));
		return 0;
	}
	l2_pgtable = (HV_PTE *)pfn_to_kaddr(pfn);
	pte = l2_pgtable[HV_L2_INDEX(address)];
	return hv_pte_get_present(pte) && hv_pte_get_readable(pte);
}

/* Callback for backtracer; basically a glorified memcpy */
static bool read_memory_func(void *result, VirtualAddress address,
			     unsigned int size, void *vkbt)
{
	int retval;
	struct KBacktraceIterator *kbt = (struct KBacktraceIterator *)vkbt;
	if (in_kernel_text(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 (!valid_address(kbt, address)) {
		return 0;	/* invalid user-space address */
	}
	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)
{
	const char *fault = NULL;  /* happy compiler */
	char fault_buf[64];
	VirtualAddress sp = kbt->it.sp;
	struct pt_regs *p;

	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 (p->faultnum == INT_SWINT_1 || p->faultnum == INT_SWINT_1_SIGRETURN)
		fault = "syscall";
	else {
		if (kbt->verbose) {     /* else we aren't going to use it */
			snprintf(fault_buf, sizeof(fault_buf),
				 "interrupt %ld", p->faultnum);
			fault = fault_buf;
		}
	}
	if (EX1_PL(p->ex1) == KERNEL_PL &&
	    in_kernel_text(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 (EX1_PL(p->ex1) == USER_PL &&
	    p->pc < PAGE_OFFSET &&
	    p->sp < PAGE_OFFSET) {
		if (kbt->verbose)
			pr_err("  <%s while in user mode>\n", fault);
	} else if (kbt->verbose) {
		pr_err("  (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
		       p->pc, p->sp, p->ex1);
		p = NULL;
	}
	if (!kbt->profile || (INT_MASK(p->faultnum) & QUEUED_INTERRUPTS) == 0)
		return p;
	return NULL;
}

/* Is the pc pointing to a sigreturn trampoline? */
static int is_sigreturn(VirtualAddress pc)
{
	return (pc == VDSO_BASE);
}

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

	if (b->pc == VDSO_BASE) {
		struct rt_sigframe *frame;
		unsigned long sigframe_top =
			b->sp + sizeof(struct rt_sigframe) - 1;
		if (!valid_address(kbt, b->sp) ||
		    !valid_address(kbt, sigframe_top)) {
			if (kbt->verbose)
				pr_err("  (odd signal: sp %#lx?)\n",
				       (unsigned long)(b->sp));
			return NULL;
		}
		frame = (struct rt_sigframe *)b->sp;
		if (kbt->verbose) {
			pr_err("  <received signal %d>\n",
			       frame->info.si_signo);
		}
		return (struct pt_regs *)&frame->uc.uc_mcontext;
	}
	return NULL;
}

static int KBacktraceIterator_is_sigreturn(struct KBacktraceIterator *kbt)
{
	return is_sigreturn(kbt->it.pc);
}

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

	p = valid_fault_handler(kbt);
	if (p == NULL)
		p = valid_sigframe(kbt);
	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 (!KBacktraceIterator_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 = 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 page %#lx underrun!\n"
		       "  sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
		       cpu, ksp0_base, sp, regs->sp, regs->pc, regs->lr);
	}

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

void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
			     struct task_struct *t, struct pt_regs *regs)
{
	VirtualAddress 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, and if we're
	 * asking about the current process we grab the page table
	 * so we can check user accesses before trying to read them.
	 * We flush the TLB to avoid any weird skew issues.
	 */
	is_current = (t == NULL);
	kbt->is_current = is_current;
	if (is_current)
		t = validate_current();
	kbt->task = t;
	kbt->pgtable = NULL;
	kbt->verbose = 0;   /* override in caller if desired */
	kbt->profile = 0;   /* override in caller if desired */
	kbt->end = KBT_ONGOING;
	kbt->new_context = 0;
	if (is_current) {
		HV_PhysAddr pgdir_pa = hv_inquire_context().page_table;
		if (pgdir_pa == (unsigned long)swapper_pg_dir - PAGE_OFFSET) {
			/*
			 * Not just an optimization: this also allows
			 * this to work at all before va/pa mappings
			 * are set up.
			 */
			kbt->pgtable = swapper_pg_dir;
		} else {
			struct page *page = pfn_to_page(PFN_DOWN(pgdir_pa));
			if (!PageHighMem(page))
				kbt->pgtable = __va(pgdir_pa);
			else
				pr_err("page table not in LOWMEM"
				       " (%#llx)\n", pgdir_pa);
		}
		local_flush_tlb_all();
		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)
{
	VirtualAddress 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);

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

	if (headers) {
		/*
		 * Add a blank line since if we are called from panic(),
		 * then bust_spinlocks() spit out a space in front of us
		 * and it will mess up our KERN_ERR.
		 */
		pr_err("\n");
		pr_err("Starting stack dump of tid %d, pid %d (%s)"
		       " on cpu %d at cycle %lld\n",
		       kbt->task->pid, kbt->task->tgid, kbt->task->comm,
		       smp_processor_id(), get_cycles());
	}
	kbt->verbose = 1;
	i = 0;
	for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
		char *modname;
		const char *name;
		unsigned long address = kbt->it.pc;
		unsigned long offset, size;
		char namebuf[KSYM_NAME_LEN+100];

		if (address >= PAGE_OFFSET)
			name = kallsyms_lookup(address, &size, &offset,
					       &modname, namebuf);
		else
			name = NULL;

		if (!name)
			namebuf[0] = '\0';
		else {
			size_t namelen = strlen(namebuf);
			size_t remaining = (sizeof(namebuf) - 1) - namelen;
			char *p = namebuf + namelen;
			int rc = snprintf(p, remaining, "+%#lx/%#lx ",
					  offset, size);
			if (modname && rc < remaining)
				snprintf(p + rc, remaining - rc,
					 "[%s] ", modname);
			namebuf[sizeof(namebuf)-1] = '\0';
		}

		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 (headers)
		pr_err("Stack dump complete\n");
}
EXPORT_SYMBOL(tile_show_stack);


/* This is called from show_regs() and _dump_stack() */
void dump_stack_regs(struct pt_regs *regs)
{
	struct KBacktraceIterator kbt;
	KBacktraceIterator_init(&kbt, NULL, regs);
	tile_show_stack(&kbt, 1);
}
EXPORT_SYMBOL(dump_stack_regs);

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;
}

/* This is called from dump_stack() and just converts to pt_regs */
void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
{
	struct pt_regs regs;
	dump_stack_regs(regs_to_pt_regs(&regs, pc, lr, sp, r52));
}

/* 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));
}

/* This is called only from kernel/sched.c, with esp == NULL */
void show_stack(struct task_struct *task, unsigned long *esp)
{
	struct KBacktraceIterator kbt;
	if (task == NULL || task == current)
		KBacktraceIterator_init_current(&kbt);
	else
		KBacktraceIterator_init(&kbt, task, NULL);
	tile_show_stack(&kbt, 0);
}

#ifdef CONFIG_STACKTRACE

/* Support generic Linux stack API too */

void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
{
	struct KBacktraceIterator kbt;
	int skip = trace->skip;
	int i = 0;

	if (task == NULL || task == current)
		KBacktraceIterator_init_current(&kbt);
	else
		KBacktraceIterator_init(&kbt, task, NULL);
	for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
		if (skip) {
			--skip;
			continue;
		}
		if (i >= trace->max_entries || kbt.it.pc < PAGE_OFFSET)
			break;
		trace->entries[i++] = kbt.it.pc;
	}
	trace->nr_entries = i;
}
EXPORT_SYMBOL(save_stack_trace_tsk);

void save_stack_trace(struct stack_trace *trace)
{
	save_stack_trace_tsk(NULL, trace);
}

#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>
	24	#include <asm/backtrace.h>
	25	#include <asm/page.h>
	26	#include <asm/tlbflush.h>
	27	#include <asm/ucontext.h>
	28	#include <asm/sigframe.h>
	29	#include <asm/stack.h>
	30	#include <arch/abi.h>
	31	#include <arch/interrupts.h>
	32
dabe98c9 CM	33	#define KBT_ONGOING 0 /* Backtrace still ongoing */
	34	#define KBT_DONE 1 /* Backtrace cleanly completed */
	35	#define KBT_RUNNING 2 /* Can't run backtrace on a running task */
	36	#define KBT_LOOP 3 /* Backtrace entered a loop */
867e359b CM	37
	38	/* Is address on the specified kernel stack? */
	39	static int in_kernel_stack(struct KBacktraceIterator *kbt, VirtualAddress sp)
	40	{
	41	ulong kstack_base = (ulong) kbt->task->stack;
	42	if (kstack_base == 0) /* corrupt task pointer; just follow stack... */
	43	return sp >= PAGE_OFFSET && sp < (unsigned long)high_memory;
	44	return sp >= kstack_base && sp < kstack_base + THREAD_SIZE;
	45	}
	46
	47	/* Is address in the specified kernel code? */
	48	static int in_kernel_text(VirtualAddress address)
	49	{
	50	return (address >= MEM_SV_INTRPT &&
	51	address < MEM_SV_INTRPT + HPAGE_SIZE);
	52	}
	53
	54	/* Is address valid for reading? */
	55	static int valid_address(struct KBacktraceIterator *kbt, VirtualAddress address)
	56	{
	57	HV_PTE *l1_pgtable = kbt->pgtable;
	58	HV_PTE *l2_pgtable;
	59	unsigned long pfn;
	60	HV_PTE pte;
	61	struct page *page;
	62
0707ad30 CM	63	if (l1_pgtable == NULL)
	64	return 0; /* can't read user space in other tasks */
	65
867e359b CM	66	pte = l1_pgtable[HV_L1_INDEX(address)];
	67	if (!hv_pte_get_present(pte))
	68	return 0;
	69	pfn = hv_pte_get_pfn(pte);
	70	if (pte_huge(pte)) {
	71	if (!pfn_valid(pfn)) {
0707ad30	72	pr_err("huge page has bad pfn %#lx\n", pfn);
867e359b CM	73	return 0;
	74	}
	75	return hv_pte_get_present(pte) && hv_pte_get_readable(pte);
	76	}
	77
	78	page = pfn_to_page(pfn);
	79	if (PageHighMem(page)) {
0707ad30	80	pr_err("L2 page table not in LOWMEM (%#llx)\n",
867e359b CM	81	HV_PFN_TO_CPA(pfn));
	82	return 0;
	83	}
	84	l2_pgtable = (HV_PTE *)pfn_to_kaddr(pfn);
	85	pte = l2_pgtable[HV_L2_INDEX(address)];
	86	return hv_pte_get_present(pte) && hv_pte_get_readable(pte);
	87	}
	88
	89	/* Callback for backtracer; basically a glorified memcpy */
	90	static bool read_memory_func(void *result, VirtualAddress address,
	91	unsigned int size, void *vkbt)
	92	{
	93	int retval;
	94	struct KBacktraceIterator kbt = (struct KBacktraceIterator )vkbt;
	95	if (in_kernel_text(address)) {
	96	/* OK to read kernel code. */
	97	} else if (address >= PAGE_OFFSET) {
	98	/* We only tolerate kernel-space reads of this task's stack */
	99	if (!in_kernel_stack(kbt, address))
	100	return 0;
867e359b CM	101	} else if (!valid_address(kbt, address)) {
	102	return 0; /* invalid user-space address */
	103	}
	104	pagefault_disable();
0707ad30 CM	105	retval = __copy_from_user_inatomic(result,
0707ad30 CM	106	(void __user __force *)address,
867e359b CM	107	size);
	108	pagefault_enable();
	109	return (retval == 0);
	110	}
	111
	112	/* Return a pt_regs pointer for a valid fault handler frame */
	113	static struct pt_regs valid_fault_handler(struct KBacktraceIterator kbt)
	114	{
867e359b CM	115	const char fault = NULL; / happy compiler */
	116	char fault_buf[64];
	117	VirtualAddress sp = kbt->it.sp;
	118	struct pt_regs *p;
	119
	120	if (!in_kernel_stack(kbt, sp))
	121	return NULL;
	122	if (!in_kernel_stack(kbt, sp + C_ABI_SAVE_AREA_SIZE + PTREGS_SIZE-1))
	123	return NULL;
	124	p = (struct pt_regs *)(sp + C_ABI_SAVE_AREA_SIZE);
	125	if (p->faultnum == INT_SWINT_1 \|\| p->faultnum == INT_SWINT_1_SIGRETURN)
	126	fault = "syscall";
	127	else {
	128	if (kbt->verbose) { /* else we aren't going to use it */
	129	snprintf(fault_buf, sizeof(fault_buf),
	130	"interrupt %ld", p->faultnum);
	131	fault = fault_buf;
	132	}
	133	}
	134	if (EX1_PL(p->ex1) == KERNEL_PL &&
	135	in_kernel_text(p->pc) &&
	136	in_kernel_stack(kbt, p->sp) &&
	137	p->sp >= sp) {
	138	if (kbt->verbose)
0707ad30	139	pr_err(" <%s while in kernel mode>\n", fault);
867e359b CM	140	} else if (EX1_PL(p->ex1) == USER_PL &&
	141	p->pc < PAGE_OFFSET &&
	142	p->sp < PAGE_OFFSET) {
	143	if (kbt->verbose)
0707ad30	144	pr_err(" <%s while in user mode>\n", fault);
867e359b	145	} else if (kbt->verbose) {
0707ad30	146	pr_err(" (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
867e359b CM	147	p->pc, p->sp, p->ex1);
	148	p = NULL;
	149	}
	150	if (!kbt->profile \|\| (INT_MASK(p->faultnum) & QUEUED_INTERRUPTS) == 0)
	151	return p;
867e359b CM	152	return NULL;
	153	}
	154
	155	/* Is the pc pointing to a sigreturn trampoline? */
	156	static int is_sigreturn(VirtualAddress pc)
	157	{
	158	return (pc == VDSO_BASE);
	159	}
	160
	161	/* Return a pt_regs pointer for a valid signal handler frame */
	162	static struct pt_regs valid_sigframe(struct KBacktraceIterator kbt)
	163	{
	164	BacktraceIterator *b = &kbt->it;
	165
	166	if (b->pc == VDSO_BASE) {
	167	struct rt_sigframe *frame;
	168	unsigned long sigframe_top =
	169	b->sp + sizeof(struct rt_sigframe) - 1;
	170	if (!valid_address(kbt, b->sp) \|\|
	171	!valid_address(kbt, sigframe_top)) {
	172	if (kbt->verbose)
0707ad30	173	pr_err(" (odd signal: sp %#lx?)\n",
867e359b CM	174	(unsigned long)(b->sp));
	175	return NULL;
	176	}
	177	frame = (struct rt_sigframe *)b->sp;
	178	if (kbt->verbose) {
0707ad30	179	pr_err(" <received signal %d>\n",
867e359b CM	180	frame->info.si_signo);
867e359b CM	181	}
74fca9da	182	return (struct pt_regs *)&frame->uc.uc_mcontext;
867e359b CM	183	}
	184	return NULL;
	185	}
	186
0707ad30	187	static int KBacktraceIterator_is_sigreturn(struct KBacktraceIterator *kbt)
867e359b CM	188	{
	189	return is_sigreturn(kbt->it.pc);
	190	}
	191
	192	static int KBacktraceIterator_restart(struct KBacktraceIterator *kbt)
	193	{
	194	struct pt_regs *p;
	195
	196	p = valid_fault_handler(kbt);
	197	if (p == NULL)
	198	p = valid_sigframe(kbt);
	199	if (p == NULL)
	200	return 0;
	201	backtrace_init(&kbt->it, read_memory_func, kbt,
	202	p->pc, p->lr, p->sp, p->regs[52]);
	203	kbt->new_context = 1;
	204	return 1;
	205	}
	206
	207	/* Find a frame that isn't a sigreturn, if there is one. */
	208	static int KBacktraceIterator_next_item_inclusive(
	209	struct KBacktraceIterator *kbt)
	210	{
	211	for (;;) {
	212	do {
	213	if (!KBacktraceIterator_is_sigreturn(kbt))
dabe98c9	214	return KBT_ONGOING;
867e359b CM	215	} while (backtrace_next(&kbt->it));
	216
	217	if (!KBacktraceIterator_restart(kbt))
dabe98c9	218	return KBT_DONE;
867e359b CM	219	}
	220	}
	221
	222	/*
	223	* If the current sp is on a page different than what we recorded
	224	* as the top-of-kernel-stack last time we context switched, we have
	225	* probably blown the stack, and nothing is going to work out well.
	226	* If we can at least get out a warning, that may help the debug,
	227	* though we probably won't be able to backtrace into the code that
	228	* actually did the recursive damage.
	229	*/
	230	static void validate_stack(struct pt_regs *regs)
	231	{
	232	int cpu = smp_processor_id();
	233	unsigned long ksp0 = get_current_ksp0();
	234	unsigned long ksp0_base = ksp0 - THREAD_SIZE;
	235	unsigned long sp = stack_pointer;
	236
	237	if (EX1_PL(regs->ex1) == KERNEL_PL && regs->sp >= ksp0) {
0707ad30	238	pr_err("WARNING: cpu %d: kernel stack page %#lx underrun!\n"
867e359b CM	239	" sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
	240	cpu, ksp0_base, sp, regs->sp, regs->pc, regs->lr);
	241	}
	242
	243	else if (sp < ksp0_base + sizeof(struct thread_info)) {
0707ad30	244	pr_err("WARNING: cpu %d: kernel stack page %#lx overrun!\n"
867e359b CM	245	" sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
	246	cpu, ksp0_base, sp, regs->sp, regs->pc, regs->lr);
	247	}
	248	}
	249
	250	void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
	251	struct task_struct t, struct pt_regs regs)
	252	{
	253	VirtualAddress pc, lr, sp, r52;
	254	int is_current;
	255
	256	/*
	257	* Set up callback information. We grab the kernel stack base
	258	* so we will allow reads of that address range, and if we're
	259	* asking about the current process we grab the page table
	260	* so we can check user accesses before trying to read them.
	261	* We flush the TLB to avoid any weird skew issues.
	262	*/
	263	is_current = (t == NULL);
	264	kbt->is_current = is_current;
	265	if (is_current)
	266	t = validate_current();
	267	kbt->task = t;
	268	kbt->pgtable = NULL;
	269	kbt->verbose = 0; /* override in caller if desired */
	270	kbt->profile = 0; /* override in caller if desired */
dabe98c9	271	kbt->end = KBT_ONGOING;
867e359b CM	272	kbt->new_context = 0;
	273	if (is_current) {
	274	HV_PhysAddr pgdir_pa = hv_inquire_context().page_table;
	275	if (pgdir_pa == (unsigned long)swapper_pg_dir - PAGE_OFFSET) {
	276	/*
	277	* Not just an optimization: this also allows
	278	* this to work at all before va/pa mappings
	279	* are set up.
	280	*/
	281	kbt->pgtable = swapper_pg_dir;
	282	} else {
	283	struct page *page = pfn_to_page(PFN_DOWN(pgdir_pa));
	284	if (!PageHighMem(page))
	285	kbt->pgtable = __va(pgdir_pa);
	286	else
0707ad30	287	pr_err("page table not in LOWMEM"
867e359b CM	288	" (%#llx)\n", pgdir_pa);
	289	}
	290	local_flush_tlb_all();
	291	validate_stack(regs);
	292	}
	293
	294	if (regs == NULL) {
867e359b CM	295	if (is_current \|\| t->state == TASK_RUNNING) {
867e359b CM	296	/* Can't do this; we need registers */
dabe98c9	297	kbt->end = KBT_RUNNING;
867e359b CM	298	return;
867e359b CM	299	}
0707ad30	300	pc = get_switch_to_pc();
867e359b CM	301	lr = t->thread.pc;
	302	sp = t->thread.ksp;
	303	r52 = 0;
	304	} else {
	305	pc = regs->pc;
	306	lr = regs->lr;
	307	sp = regs->sp;
	308	r52 = regs->regs[52];
	309	}
	310
	311	backtrace_init(&kbt->it, read_memory_func, kbt, pc, lr, sp, r52);
dabe98c9	312	kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
867e359b CM	313	}
	314	EXPORT_SYMBOL(KBacktraceIterator_init);
	315
	316	int KBacktraceIterator_end(struct KBacktraceIterator *kbt)
	317	{
dabe98c9	318	return kbt->end != KBT_ONGOING;
867e359b CM	319	}
	320	EXPORT_SYMBOL(KBacktraceIterator_end);
	321
	322	void KBacktraceIterator_next(struct KBacktraceIterator *kbt)
	323	{
dabe98c9	324	VirtualAddress old_pc = kbt->it.pc, old_sp = kbt->it.sp;
867e359b	325	kbt->new_context = 0;
dabe98c9 CM	326	if (!backtrace_next(&kbt->it) && !KBacktraceIterator_restart(kbt)) {
	327	kbt->end = KBT_DONE;
	328	return;
	329	}
	330	kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
	331	if (old_pc == kbt->it.pc && old_sp == kbt->it.sp) {
	332	/* Trapped in a loop; give up. */
	333	kbt->end = KBT_LOOP;
	334	}
867e359b CM	335	}
	336	EXPORT_SYMBOL(KBacktraceIterator_next);
	337
	338	/*
	339	* This method wraps the backtracer's more generic support.
	340	* It is only invoked from the architecture-specific code; show_stack()
	341	* and dump_stack() (in entry.S) are architecture-independent entry points.
	342	*/
	343	void tile_show_stack(struct KBacktraceIterator *kbt, int headers)
	344	{
	345	int i;
	346
	347	if (headers) {
	348	/*
	349	* Add a blank line since if we are called from panic(),
	350	* then bust_spinlocks() spit out a space in front of us
	351	* and it will mess up our KERN_ERR.
	352	*/
0707ad30 CM	353	pr_err("\n");
0707ad30 CM	354	pr_err("Starting stack dump of tid %d, pid %d (%s)"
867e359b CM	355	" on cpu %d at cycle %lld\n",
	356	kbt->task->pid, kbt->task->tgid, kbt->task->comm,
	357	smp_processor_id(), get_cycles());
	358	}
867e359b CM	359	kbt->verbose = 1;
	360	i = 0;
	361	for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
	362	char *modname;
	363	const char *name;
	364	unsigned long address = kbt->it.pc;
	365	unsigned long offset, size;
	366	char namebuf[KSYM_NAME_LEN+100];
	367
	368	if (address >= PAGE_OFFSET)
	369	name = kallsyms_lookup(address, &size, &offset,
	370	&modname, namebuf);
	371	else
	372	name = NULL;
	373
	374	if (!name)
	375	namebuf[0] = '\0';
	376	else {
	377	size_t namelen = strlen(namebuf);
	378	size_t remaining = (sizeof(namebuf) - 1) - namelen;
	379	char *p = namebuf + namelen;
	380	int rc = snprintf(p, remaining, "+%#lx/%#lx ",
	381	offset, size);
	382	if (modname && rc < remaining)
	383	snprintf(p + rc, remaining - rc,
	384	"[%s] ", modname);
	385	namebuf[sizeof(namebuf)-1] = '\0';
	386	}
	387
0707ad30	388	pr_err(" frame %d: 0x%lx %s(sp 0x%lx)\n",
867e359b CM	389	i++, address, namebuf, (unsigned long)(kbt->it.sp));
	390
	391	if (i >= 100) {
0707ad30	392	pr_err("Stack dump truncated"
867e359b CM	393	" (%d frames)\n", i);
	394	break;
	395	}
	396	}
dabe98c9 CM	397	if (kbt->end == KBT_LOOP)
dabe98c9 CM	398	pr_err("Stack dump stopped; next frame identical to this one\n");
867e359b	399	if (headers)
0707ad30	400	pr_err("Stack dump complete\n");
867e359b CM	401	}
	402	EXPORT_SYMBOL(tile_show_stack);
	403
	404
	405	/* This is called from show_regs() and _dump_stack() */
	406	void dump_stack_regs(struct pt_regs *regs)
	407	{
	408	struct KBacktraceIterator kbt;
	409	KBacktraceIterator_init(&kbt, NULL, regs);
	410	tile_show_stack(&kbt, 1);
	411	}
	412	EXPORT_SYMBOL(dump_stack_regs);
	413
	414	static struct pt_regs regs_to_pt_regs(struct pt_regs regs,
	415	ulong pc, ulong lr, ulong sp, ulong r52)
	416	{
	417	memset(regs, 0, sizeof(struct pt_regs));
	418	regs->pc = pc;
	419	regs->lr = lr;
	420	regs->sp = sp;
	421	regs->regs[52] = r52;
	422	return regs;
	423	}
	424
	425	/* This is called from dump_stack() and just converts to pt_regs */
	426	void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
	427	{
	428	struct pt_regs regs;
	429	dump_stack_regs(regs_to_pt_regs(&regs, pc, lr, sp, r52));
	430	}
	431
	432	/* This is called from KBacktraceIterator_init_current() */
	433	void _KBacktraceIterator_init_current(struct KBacktraceIterator *kbt, ulong pc,
	434	ulong lr, ulong sp, ulong r52)
	435	{
	436	struct pt_regs regs;
	437	KBacktraceIterator_init(kbt, NULL,
	438	regs_to_pt_regs(&regs, pc, lr, sp, r52));
	439	}
	440
	441	/* This is called only from kernel/sched.c, with esp == NULL */
	442	void show_stack(struct task_struct task, unsigned long esp)
	443	{
	444	struct KBacktraceIterator kbt;
	445	if (task == NULL \|\| task == current)
	446	KBacktraceIterator_init_current(&kbt);
	447	else
	448	KBacktraceIterator_init(&kbt, task, NULL);
	449	tile_show_stack(&kbt, 0);
	450	}
	451
	452	#ifdef CONFIG_STACKTRACE
	453
	454	/* Support generic Linux stack API too */
	455
	456	void save_stack_trace_tsk(struct task_struct task, struct stack_trace trace)
	457	{
	458	struct KBacktraceIterator kbt;
	459	int skip = trace->skip;
	460	int i = 0;
	461
	462	if (task == NULL \|\| task == current)
	463	KBacktraceIterator_init_current(&kbt);
	464	else
465	KBacktraceIterator_init(&kbt, task, NULL);
466	for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
467	if (skip) {
468	--skip;
469	continue;
470	}
471	if (i >= trace->max_entries \|\| kbt.it.pc < PAGE_OFFSET)
472	break;
473	trace->entries[i++] = kbt.it.pc;
474	}
475	trace->nr_entries = i;
476	}
477	EXPORT_SYMBOL(save_stack_trace_tsk);
478
479	void save_stack_trace(struct stack_trace *trace)
480	{
481	save_stack_trace_tsk(NULL, trace);
482	}
483
484	#endif
485
486	/* In entry.S */
487	EXPORT_SYMBOL(KBacktraceIterator_init_current);