Commit 9d1ee8ce authored by Richard Weinberger's avatar Richard Weinberger
Browse files

um: Rewrite show_stack() 



Currently on UML stack traces are not very reliable and both
x86 and x86_64 have their on implementations.
This patch unifies both and adds support to outline unreliable
functions calls.

Signed-off-by: default avatarRichard Weinberger <richard@nod.at>
parent 5e01dc7b

arch/um/kernel/sysrq.c

+53 −32
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)

 * Licensed under the GPL

 * Copyright (C) 2013 Richard Weinberger <richrd@nod.at>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/kallsyms.h>
@@ -9,58 +13,75 @@ 
#include <linux/sched.h>

#include <asm/sysrq.h>



/* Catch non-i386 SUBARCH's. */

#if !defined(CONFIG_UML_X86) || defined(CONFIG_64BIT)

void show_trace(struct task_struct *task, unsigned long * stack)

struct stack_frame {

	struct stack_frame *next_frame;

	unsigned long return_address;

};



static void print_stack_trace(unsigned long *sp, unsigned long bp)

{

	int reliable;

	unsigned long addr;



	if (!stack) {

		stack = (unsigned long*) &stack;

		WARN_ON(1);

	}

	struct stack_frame *frame = (struct stack_frame *)bp;



	printk(KERN_INFO "Call Trace:\n");

	while (((long) stack & (THREAD_SIZE-1)) != 0) {

		addr = *stack;

	while (((long) sp & (THREAD_SIZE-1)) != 0) {

		addr = *sp;

		if (__kernel_text_address(addr)) {

			printk(KERN_INFO "%08lx:  [<%08lx>]",

			       (unsigned long) stack, addr);

			reliable = 0;

			if ((unsigned long) sp == bp + sizeof(long)) {

				frame = frame ? frame->next_frame : NULL;

				bp = (unsigned long)frame;

				reliable = 1;

			}



			printk(KERN_INFO " [<%08lx>]", addr);

			printk(KERN_CONT " %s", reliable ? "" : "? ");

			print_symbol(KERN_CONT "%s", addr);

			printk(KERN_CONT "\n");

		}

		stack++;

		sp++;

	}

	printk(KERN_INFO "\n");

}

#endif



/*Stolen from arch/i386/kernel/traps.c */

static const int kstack_depth_to_print = 24;



/* This recently started being used in arch-independent code too, as in

 * kernel/sched/core.c.*/

void show_stack(struct task_struct *task, unsigned long *esp)

static unsigned long get_frame_pointer(struct task_struct *task)

{

	if (!task || task == current)

		return current_bp();

	else

		return KSTK_EBP(task);

}



void show_stack(struct task_struct *task, unsigned long *stack)

{

	unsigned long *stack;

	unsigned long *sp = stack, bp = 0;

	int i;



	if (esp == NULL) {

		if (task != current && task != NULL) {

			esp = (unsigned long *) KSTK_ESP(task);

		} else {

			esp = (unsigned long *) &esp;

		}

#ifdef CONFIG_FRAME_POINTER

	bp = get_frame_pointer(task);

#endif



	if (!stack) {

		if (!task || task == current)

			sp = current_sp();

		else

			sp = (unsigned long *)KSTK_ESP(task);

	}



	stack = esp;

	printk(KERN_INFO "Stack:\n");

	stack = sp;

	for (i = 0; i < kstack_depth_to_print; i++) {

		if (kstack_end(stack))

			break;

		if (i && ((i % 8) == 0))

			printk(KERN_INFO "       ");

		if (i && ((i % STACKSLOTS_PER_LINE) == 0))

			printk(KERN_CONT "\n");

		printk(KERN_CONT " %08lx", *stack++);

	}

	printk(KERN_CONT "\n");



	show_trace(task, esp);

	print_stack_trace(sp, bp);

}

arch/um/kernel/um_arch.c

+0 −1
Original line number Diff line number Diff line
@@ -234,7 +234,6 @@ static int panic_exit(struct notifier_block *self, unsigned long unused1, 
		      void *unused2)

{

	bust_spinlocks(1);

	show_regs(&(current->thread.regs));

	bust_spinlocks(0);

	uml_exitcode = 1;

	os_dump_core();

arch/x86/um/asm/processor_32.h

+5 −0
Original line number Diff line number Diff line
@@ -33,6 +33,8 @@ struct arch_thread { 
	.faultinfo		= { 0, 0, 0 } \

}



#define STACKSLOTS_PER_LINE 8



static inline void arch_flush_thread(struct arch_thread *thread)

{

	/* Clear any TLS still hanging */
@@ -53,4 +55,7 @@ static inline void arch_copy_thread(struct arch_thread *from, 
#define current_text_addr() \

	({ void *pc; __asm__("movl $1f,%0\n1:":"=g" (pc)); pc; })



#define current_sp() ({ void *sp; __asm__("movl %%esp, %0" : "=r" (sp) : ); sp; })

#define current_bp() ({ unsigned long bp; __asm__("movl %%ebp, %0" : "=r" (bp) : ); bp; })



#endif

arch/x86/um/asm/processor_64.h

+5 −0
Original line number Diff line number Diff line
@@ -19,6 +19,8 @@ struct arch_thread { 
			   .fs			= 0, \

			   .faultinfo		= { 0, 0, 0 } }



#define STACKSLOTS_PER_LINE 4



static inline void arch_flush_thread(struct arch_thread *thread)

{

}
@@ -32,4 +34,7 @@ static inline void arch_copy_thread(struct arch_thread *from, 
#define current_text_addr() \

	({ void *pc; __asm__("movq $1f,%0\n1:":"=g" (pc)); pc; })



#define current_sp() ({ void *sp; __asm__("movq %%rsp, %0" : "=r" (sp) : ); sp; })

#define current_bp() ({ unsigned long bp; __asm__("movq %%rbp, %0" : "=r" (bp) : ); bp; })



#endif

arch/x86/um/sysrq_32.c

+0 −66
Original line number Diff line number Diff line
@@ -30,70 +30,4 @@ void show_regs(struct pt_regs *regs) 
        printk(" DS: %04lx ES: %04lx\n",

	       0xffff & PT_REGS_DS(regs), 

	       0xffff & PT_REGS_ES(regs));



        show_trace(NULL, (unsigned long *) &regs);

}



/* Copied from i386. */

static inline int valid_stack_ptr(struct thread_info *tinfo, void *p)

{

	return	p > (void *)tinfo &&

		p < (void *)tinfo + THREAD_SIZE - 3;

}



/* Adapted from i386 (we also print the address we read from). */

static inline unsigned long print_context_stack(struct thread_info *tinfo,

				unsigned long *stack, unsigned long ebp)

{

	unsigned long addr;



#ifdef CONFIG_FRAME_POINTER

	while (valid_stack_ptr(tinfo, (void *)ebp)) {

		addr = *(unsigned long *)(ebp + 4);

		printk("%08lx:  [<%08lx>]", ebp + 4, addr);

		print_symbol(" %s", addr);

		printk("\n");

		ebp = *(unsigned long *)ebp;

	}

#else

	while (valid_stack_ptr(tinfo, stack)) {

		addr = *stack;

		if (__kernel_text_address(addr)) {

			printk("%08lx:  [<%08lx>]", (unsigned long) stack, addr);

			print_symbol(" %s", addr);

			printk("\n");

		}

		stack++;

	}

#endif

	return ebp;

}
 


void show_trace(struct task_struct* task, unsigned long * stack)

{

	unsigned long ebp;

	struct thread_info *context;



	/* Turn this into BUG_ON if possible. */

	if (!stack) {

		stack = (unsigned long*) &stack;

		printk("show_trace: got NULL stack, implicit assumption task == current");

		WARN_ON(1);

	}



	if (!task)

		task = current;



	if (task != current) {

		ebp = (unsigned long) KSTK_EBP(task);

	} else {

		asm ("movl %%ebp, %0" : "=r" (ebp) : );

	}



	context = (struct thread_info *)

		((unsigned long)stack & (~(THREAD_SIZE - 1)));

	print_context_stack(context, stack, ebp);



	printk("\n");

}