Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b5964405 authored by Ingo Molnar's avatar Ingo Molnar
Browse files

x86: clean up traps_32.c 



Before:
   total: 86 errors, 29 warnings, 1248 lines checked
After:
   total: 0 errors, 17 warnings, 1281 lines checked

No code changed:

arch/x86/kernel/traps_32.o:

   text	   data	    bss	    dec	    hex	filename
   8711	   2168	     72	  10951	   2ac7	traps_32.o.before
   8711	   2168	     72	  10951	   2ac7	traps_32.o.after

(md5 sums differ because some stack offset positions changed.)

Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent 10cd5a1e

arch/x86/kernel/traps_32.c

+318 −286
Original line number Diff line number Diff line
@@ -9,26 +9,28 @@ 
 * 'Traps.c' handles hardware traps and faults after we have saved some

 * state in 'asm.s'.

 */

#include <linux/sched.h>

#include <linux/interrupt.h>

#include <linux/kallsyms.h>

#include <linux/spinlock.h>

#include <linux/highmem.h>

#include <linux/kprobes.h>

#include <linux/uaccess.h>

#include <linux/utsname.h>

#include <linux/kdebug.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/ptrace.h>

#include <linux/string.h>

#include <linux/unwind.h>

#include <linux/delay.h>

#include <linux/errno.h>

#include <linux/kexec.h>

#include <linux/sched.h>

#include <linux/timer.h>

#include <linux/mm.h>

#include <linux/init.h>

#include <linux/delay.h>

#include <linux/spinlock.h>

#include <linux/interrupt.h>

#include <linux/highmem.h>

#include <linux/kallsyms.h>

#include <linux/ptrace.h>

#include <linux/utsname.h>

#include <linux/kprobes.h>

#include <linux/kexec.h>

#include <linux/unwind.h>

#include <linux/uaccess.h>

#include <linux/nmi.h>

#include <linux/bug.h>

#include <linux/nmi.h>

#include <linux/mm.h>



#ifdef CONFIG_EISA

#include <linux/ioport.h>
@@ -43,21 +45,18 @@ 
#include <linux/edac.h>

#endif



#include <asm/arch_hooks.h>

#include <asm/stacktrace.h>

#include <asm/processor.h>

#include <asm/system.h>

#include <asm/io.h>

#include <asm/atomic.h>

#include <asm/debugreg.h>

#include <asm/atomic.h>

#include <asm/system.h>

#include <asm/unwind.h>

#include <asm/desc.h>

#include <asm/i387.h>

#include <asm/nmi.h>

#include <asm/unwind.h>

#include <asm/smp.h>

#include <asm/arch_hooks.h>

#include <linux/kdebug.h>

#include <asm/stacktrace.h>



#include <linux/module.h>

#include <asm/io.h>



#include "mach_traps.h"
@@ -69,7 +68,7 @@ EXPORT_SYMBOL_GPL(used_vectors); 
asmlinkage int system_call(void);



/* Do we ignore FPU interrupts ? */

char ignore_fpu_irq = 0;

char ignore_fpu_irq;



/*

 * The IDT has to be page-aligned to simplify the Pentium
@@ -105,12 +104,13 @@ static unsigned int code_bytes = 64; 
void printk_address(unsigned long address, int reliable)

{

#ifdef CONFIG_KALLSYMS

	unsigned long offset = 0, symsize;

	char namebuf[KSYM_NAME_LEN];

	unsigned long offset = 0;

	unsigned long symsize;

	const char *symname;

	char *modname;

	char *delim = ":";

	char namebuf[128];

	char reliab[4] = "";

	char *delim = ":";

	char *modname;



	symname = kallsyms_lookup(address, &symsize, &offset,

					&modname, namebuf);
@@ -142,7 +142,8 @@ struct stack_frame { 
	unsigned long		return_address;

};



static inline unsigned long print_context_stack(struct thread_info *tinfo,

static inline unsigned long

print_context_stack(struct thread_info *tinfo,

		    unsigned long *stack, unsigned long bp,

		    const struct stacktrace_ops *ops, void *data)

{
@@ -177,6 +178,7 @@ void dump_trace(struct task_struct *task, struct pt_regs *regs, 


	if (!stack) {

		unsigned long dummy;



		stack = &dummy;

		if (task != current)

			stack = (unsigned long *)task->thread.sp;
@@ -196,12 +198,15 @@ void dump_trace(struct task_struct *task, struct pt_regs *regs, 


	while (1) {

		struct thread_info *context;



		context = (struct thread_info *)

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

		bp = print_context_stack(context, stack, bp, ops, data);

		/* Should be after the line below, but somewhere

		   in early boot context comes out corrupted and we

		   can't reference it -AK */

		/*

		 * Should be after the line below, but somewhere

		 * in early boot context comes out corrupted and we

		 * can't reference it:

		 */

		if (ops->stack(data, "IRQ") < 0)

			break;

		stack = (unsigned long *)context->previous_esp;
@@ -263,7 +268,8 @@ void show_trace(struct task_struct *task, struct pt_regs *regs, 
	show_trace_log_lvl(task, regs, stack, bp, "");

}



static void show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs,

static void

show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs,

		   unsigned long *sp, unsigned long bp, char *log_lvl)

{

	unsigned long *stack;
@@ -285,6 +291,7 @@ static void show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs, 
		printk("%08lx ", *stack++);

	}

	printk("\n%sCall Trace:\n", log_lvl);



	show_trace_log_lvl(task, regs, sp, bp, log_lvl);

}
@@ -299,8 +306,8 @@ void show_stack(struct task_struct *task, unsigned long *sp) 
 */

void dump_stack(void)

{

	unsigned long stack;

	unsigned long bp = 0;

	unsigned long stack;



#ifdef CONFIG_FRAME_POINTER

	if (!bp)
@@ -312,6 +319,7 @@ void dump_stack(void) 
		init_utsname()->release,

		(int)strcspn(init_utsname()->version, " "),

		init_utsname()->version);



	show_trace(current, NULL, &stack, bp);

}
@@ -323,6 +331,7 @@ void show_registers(struct pt_regs *regs) 


	print_modules();

	__show_registers(regs, 0);



	printk(KERN_EMERG "Process %.*s (pid: %d, ti=%p task=%p task.ti=%p)",

		TASK_COMM_LEN, current->comm, task_pid_nr(current),

		current_thread_info(), current, task_thread_info(current));
@@ -331,10 +340,10 @@ void show_registers(struct pt_regs *regs) 
	 * time of the fault..

	 */

	if (!user_mode_vm(regs)) {

		u8 *ip;

		unsigned int code_prologue = code_bytes * 43 / 64;

		unsigned int code_len = code_bytes;

		unsigned char c;

		u8 *ip;



		printk("\n" KERN_EMERG "Stack: ");

		show_stack_log_lvl(NULL, regs, &regs->sp, 0, KERN_EMERG);
@@ -379,8 +388,8 @@ static int die_counter; 


int __kprobes __die(const char *str, struct pt_regs *regs, long err)

{

	unsigned long sp;

	unsigned short ss;

	unsigned long sp;



	printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);

#ifdef CONFIG_PREEMPT
@@ -395,8 +404,8 @@ int __kprobes __die(const char * str, struct pt_regs * regs, long err) 
	printk("\n");



	if (notify_die(DIE_OOPS, str, regs, err,

				current->thread.trap_no, SIGSEGV) !=

			NOTIFY_STOP) {

			current->thread.trap_no, SIGSEGV) != NOTIFY_STOP) {



		show_registers(regs);

		/* Executive summary in case the oops scrolled away */

		sp = (unsigned long) (&regs->sp);
@@ -408,15 +417,16 @@ int __kprobes __die(const char * str, struct pt_regs * regs, long err) 
		printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip);

		print_symbol("%s", regs->ip);

		printk(" SS:ESP %04x:%08lx\n", ss, sp);



		return 0;

	} else {

		return 1;

	}



	return 1;

}



/*

 * This is gone through when something in the kernel has done something bad and

 * is about to be terminated.

 * This is gone through when something in the kernel has done something bad

 * and is about to be terminated:

 */

void die(const char *str, struct pt_regs *regs, long err)

{
@@ -440,8 +450,9 @@ void die(const char * str, struct pt_regs * regs, long err) 
		die.lock_owner = smp_processor_id();

		die.lock_owner_depth = 0;

		bust_spinlocks(1);

	} else

	} else {

		raw_local_irq_save(flags);

	}



	if (++die.lock_owner_depth < 3) {

		report_bug(regs->ip, regs);
@@ -474,15 +485,16 @@ void die(const char * str, struct pt_regs * regs, long err) 
	do_exit(SIGSEGV);

}



static inline void die_if_kernel(const char * str, struct pt_regs * regs, long err)

static inline void

die_if_kernel(const char *str, struct pt_regs *regs, long err)

{

	if (!user_mode_vm(regs))

		die(str, regs, err);

}



static void __kprobes do_trap(int trapnr, int signr, char *str, int vm86,

			      struct pt_regs * regs, long error_code,

			      siginfo_t *info)

static void __kprobes

do_trap(int trapnr, int signr, char *str, int vm86, struct pt_regs *regs,

	long error_code, siginfo_t *info)

{

	struct task_struct *tsk = current;
@@ -495,7 +507,7 @@ static void __kprobes do_trap(int trapnr, int signr, char *str, int vm86, 
	if (!user_mode(regs))

		goto kernel_trap;



	trap_signal: {

trap_signal:

	/*

	 * We want error_code and trap_no set for userspace faults and

	 * kernelspace faults which result in die(), but not
@@ -513,23 +525,21 @@ static void __kprobes do_trap(int trapnr, int signr, char *str, int vm86, 
	else

		force_sig(signr, tsk);

	return;

	}



	kernel_trap: {

kernel_trap:

	if (!fixup_exception(regs)) {

		tsk->thread.error_code = error_code;

		tsk->thread.trap_no = trapnr;

		die(str, regs, error_code);

	}

	return;

	}



	vm86_trap: {

		int ret = handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code, trapnr);

		if (ret) goto trap_signal;

vm86_trap:

	if (handle_vm86_trap((struct kernel_vm86_regs *) regs,

						error_code, trapnr))

		goto trap_signal;

	return;

}

}



#define DO_ERROR(trapnr, signr, str, name)				\

void do_##name(struct pt_regs *regs, long error_code)			\
@@ -594,12 +604,15 @@ DO_ERROR(12, SIGBUS, "stack segment", stack_segment) 
DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0, 0)

DO_ERROR_INFO(32, SIGSEGV, "iret exception", iret_error, ILL_BADSTK, 0, 1)



void __kprobes do_general_protection(struct pt_regs * regs,

					      long error_code)

void __kprobes do_general_protection(struct pt_regs *regs, long error_code)

{

	int cpu = get_cpu();

	struct tss_struct *tss = &per_cpu(init_tss, cpu);

	struct thread_struct *thread = &current->thread;

	struct thread_struct *thread;

	struct tss_struct *tss;

	int cpu;



	cpu = get_cpu();

	tss = &per_cpu(init_tss, cpu);

	thread = &current->thread;



	/*

	 * Perform the lazy TSS's I/O bitmap copy. If the TSS has an
@@ -616,14 +629,16 @@ void __kprobes do_general_protection(struct pt_regs * regs, 
		 * If the previously set map was extending to higher ports

		 * than the current one, pad extra space with 0xff (no access).

		 */

		if (thread->io_bitmap_max < tss->io_bitmap_max)

		if (thread->io_bitmap_max < tss->io_bitmap_max) {

			memset((char *) tss->io_bitmap +

				thread->io_bitmap_max, 0xff,

				tss->io_bitmap_max - thread->io_bitmap_max);

		}

		tss->io_bitmap_max = thread->io_bitmap_max;

		tss->x86_tss.io_bitmap_base = IO_BITMAP_OFFSET;

		tss->io_bitmap_owner = thread;

		put_cpu();



		return;

	}

	put_cpu();
@@ -636,6 +651,7 @@ void __kprobes do_general_protection(struct pt_regs * regs, 


	current->thread.error_code = error_code;

	current->thread.trap_no = 13;



	if (show_unhandled_signals && unhandled_signal(current, SIGSEGV) &&

	    printk_ratelimit()) {

		printk(KERN_INFO
@@ -668,9 +684,12 @@ gp_in_kernel: 
static __kprobes void

mem_parity_error(unsigned char reason, struct pt_regs *regs)

{

	printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x on "

		"CPU %d.\n", reason, smp_processor_id());

	printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");

	printk(KERN_EMERG

		"Uhhuh. NMI received for unknown reason %02x on CPU %d.\n",

			reason, smp_processor_id());



	printk(KERN_EMERG

		"You have some hardware problem, likely on the PCI bus.\n");



#if defined(CONFIG_EDAC)

	if (edac_handler_set()) {
@@ -699,8 +718,11 @@ io_check_error(unsigned char reason, struct pt_regs * regs) 
	/* Re-enable the IOCK line, wait for a few seconds */

	reason = (reason & 0xf) | 8;

	outb(reason, 0x61);



	i = 2000;

	while (--i) udelay(1000);

	while (--i)

		udelay(1000);



	reason &= ~8;

	outb(reason, 0x61);

}
@@ -709,15 +731,19 @@ static __kprobes void 
unknown_nmi_error(unsigned char reason, struct pt_regs *regs)

{

#ifdef CONFIG_MCA

	/* Might actually be able to figure out what the guilty party

	* is. */

	/*

	 * Might actually be able to figure out what the guilty party

	 * is:

	 */

	if (MCA_bus) {

		mca_handle_nmi();

		return;

	}

#endif

	printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x on "

		"CPU %d.\n", reason, smp_processor_id());

	printk(KERN_EMERG

		"Uhhuh. NMI received for unknown reason %02x on CPU %d.\n",

			reason, smp_processor_id());



	printk(KERN_EMERG "Do you have a strange power saving mode enabled?\n");

	if (panic_on_unrecovered_nmi)

		panic("NMI: Not continuing");
@@ -729,14 +755,13 @@ static DEFINE_SPINLOCK(nmi_print_lock); 


void __kprobes die_nmi(struct pt_regs *regs, const char *msg)

{

	if (notify_die(DIE_NMIWATCHDOG, msg, regs, 0, 2, SIGINT) ==

	    NOTIFY_STOP)

	if (notify_die(DIE_NMIWATCHDOG, msg, regs, 0, 2, SIGINT) == NOTIFY_STOP)

		return;



	spin_lock(&nmi_print_lock);

	/*

	* We are in trouble anyway, lets at least try

	* to get a message out.

	* to get a message out:

	*/

	bust_spinlocks(1);

	printk(KERN_EMERG "%s", msg);
@@ -747,8 +772,9 @@ void __kprobes die_nmi(struct pt_regs *regs, const char *msg) 
	spin_unlock(&nmi_print_lock);

	bust_spinlocks(0);



	/* If we are in kernel we are probably nested up pretty bad

	 * and might aswell get out now while we still can.

	/*

	 * If we are in kernel we are probably nested up pretty bad

	 * and might aswell get out now while we still can:

	 */

	if (!user_mode_vm(regs)) {

		current->thread.trap_no = 2;
@@ -762,7 +788,7 @@ static __kprobes void default_do_nmi(struct pt_regs * regs) 
{

	unsigned char reason = 0;



	/* Only the BSP gets external NMIs from the system.  */

	/* Only the BSP gets external NMIs from the system: */

	if (!smp_processor_id())

		reason = get_nmi_reason();
@@ -778,8 +804,10 @@ static __kprobes void default_do_nmi(struct pt_regs * regs) 
		if (nmi_watchdog_tick(regs, reason))

			return;

		if (!do_nmi_callback(regs, smp_processor_id()))

#endif

			unknown_nmi_error(reason, regs);

#else

		unknown_nmi_error(reason, regs);

#endif



		return;

	}
@@ -791,7 +819,7 @@ static __kprobes void default_do_nmi(struct pt_regs * regs) 
		io_check_error(reason, regs);

	/*

	 * Reassert NMI in case it became active meanwhile

	 * as it's edge-triggered.

	 * as it's edge-triggered:

	 */

	reassert_nmi();

}
@@ -834,9 +862,12 @@ void __kprobes do_int3(struct pt_regs *regs, long error_code) 
	if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP)

			== NOTIFY_STOP)

		return;

	/* This is an interrupt gate, because kprobes wants interrupts

	disabled.  Normal trap handlers don't. */

	/*

	 * This is an interrupt gate, because kprobes wants interrupts

	 * disabled. Normal trap handlers don't.

	 */

	restore_interrupts(regs);



	do_trap(3, SIGTRAP, "int3", 1, regs, error_code, NULL);

}

#endif
@@ -865,8 +896,8 @@ void __kprobes do_int3(struct pt_regs *regs, long error_code) 
 */

void __kprobes do_debug(struct pt_regs *regs, long error_code)

{

	unsigned int condition;

	struct task_struct *tsk = current;

	unsigned int condition;



	trace_hardirqs_fixup();
@@ -914,7 +945,8 @@ void __kprobes do_debug(struct pt_regs * regs, long error_code) 
	/* Ok, finally something we can handle */

	send_sigtrap(tsk, regs, error_code);



	/* Disable additional traps. They'll be re-enabled when

	/*

	 * Disable additional traps. They'll be re-enabled when

	 * the signal is delivered.

	 */

clear_dr7:
@@ -939,8 +971,9 @@ clear_TF_reenable: 
void math_error(void __user *ip)

{

	struct task_struct *task;

	unsigned short cwd;

	unsigned short swd;

	siginfo_t info;

	unsigned short cwd, swd;



	/*

	 * Save the info for the exception handler and clear the error.
@@ -1004,8 +1037,8 @@ void do_coprocessor_error(struct pt_regs * regs, long error_code) 
static void simd_math_error(void __user *ip)

{

	struct task_struct *task;

	siginfo_t info;

	unsigned short mxcsr;

	siginfo_t info;



	/*

	 * Save the info for the exception handler and clear the error.
@@ -1049,21 +1082,20 @@ static void simd_math_error(void __user *ip) 
	force_sig_info(SIGFPE, &info, task);

}



void do_simd_coprocessor_error(struct pt_regs * regs,

					  long error_code)

void do_simd_coprocessor_error(struct pt_regs *regs, long error_code)

{

	if (cpu_has_xmm) {

		/* Handle SIMD FPU exceptions on PIII+ processors. */

		ignore_fpu_irq = 1;

		simd_math_error((void __user *)regs->ip);

	} else {

		return;

	}

	/*

	 * Handle strange cache flush from user space exception

	 * in all other cases.  This is undocumented behaviour.

	 */

	if (regs->flags & VM_MASK) {

			handle_vm86_fault((struct kernel_vm86_regs *)regs,

					  error_code);

		handle_vm86_fault((struct kernel_vm86_regs *)regs, error_code);

		return;

	}

	current->thread.trap_no = 19;
@@ -1071,25 +1103,23 @@ void do_simd_coprocessor_error(struct pt_regs * regs, 
	die_if_kernel("cache flush denied", regs, error_code);

	force_sig(SIGSEGV, current);

}

}



void do_spurious_interrupt_bug(struct pt_regs * regs,

					  long error_code)

void do_spurious_interrupt_bug(struct pt_regs *regs, long error_code)

{

#if 0

	/* No need to warn about this any longer. */

	printk("Ignoring P6 Local APIC Spurious Interrupt Bug...\n");

	printk(KERN_INFO "Ignoring P6 Local APIC Spurious Interrupt Bug...\n");

#endif

}



unsigned long patch_espfix_desc(unsigned long uesp,

					  unsigned long kesp)

unsigned long patch_espfix_desc(unsigned long uesp, unsigned long kesp)

{

	struct desc_struct *gdt = __get_cpu_var(gdt_page).gdt;

	unsigned long base = (kesp - uesp) & -THREAD_SIZE;

	unsigned long new_kesp = kesp - base;

	unsigned long lim_pages = (new_kesp | (THREAD_SIZE - 1)) >> PAGE_SHIFT;

	__u64 desc = *(__u64 *)&gdt[GDT_ENTRY_ESPFIX_SS];



	/* Set up base for espfix segment */

	desc &= 0x00f0ff0000000000ULL;

	desc |=	((((__u64)base) << 16) & 0x000000ffffff0000ULL) |
@@ -1097,6 +1127,7 @@ unsigned long patch_espfix_desc(unsigned long uesp, 
		((((__u64)lim_pages) << 32) & 0x000f000000000000ULL) |

		(lim_pages & 0xffff);

	*(__u64 *)&gdt[GDT_ENTRY_ESPFIX_SS] = desc;



	return new_kesp;

}
@@ -1128,7 +1159,8 @@ EXPORT_SYMBOL_GPL(math_state_restore); 


asmlinkage void math_emulate(long arg)

{

	printk(KERN_EMERG "math-emulation not enabled and no coprocessor found.\n");

	printk(KERN_EMERG

		"math-emulation not enabled and no coprocessor found.\n");

	printk(KERN_EMERG "killing %s.\n", current->comm);

	force_sig(SIGFPE, current);

	schedule();
@@ -1136,23 +1168,21 @@ asmlinkage void math_emulate(long arg) 


#endif /* CONFIG_MATH_EMULATION */





void __init trap_init(void)

{

	int i;



#ifdef CONFIG_EISA

	void __iomem *p = early_ioremap(0x0FFFD9, 4);

	if (readl(p) == 'E'+('I'<<8)+('S'<<16)+('A'<<24)) {



	if (readl(p) == 'E' + ('I'<<8) + ('S'<<16) + ('A'<<24))

		EISA_bus = 1;

	}

	early_iounmap(p, 4);

#endif



#ifdef CONFIG_X86_LOCAL_APIC

	init_apic_mappings();

#endif



	set_trap_gate(0,  &divide_error);

	set_intr_gate(1,  &debug);

	set_intr_gate(2,  &nmi);
@@ -1187,21 +1217,22 @@ void __init trap_init(void) 
		printk("done.\n");

	}

	if (cpu_has_xmm) {

		printk(KERN_INFO "Enabling unmasked SIMD FPU exception "

				"support... ");

		printk(KERN_INFO

			"Enabling unmasked SIMD FPU exception support... ");

		set_in_cr4(X86_CR4_OSXMMEXCPT);

		printk("done.\n");

	}



	set_system_gate(SYSCALL_VECTOR, &system_call);



	/* Reserve all the builtin and the syscall vector. */

	/* Reserve all the builtin and the syscall vector: */

	for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++)

		set_bit(i, used_vectors);



	set_bit(SYSCALL_VECTOR, used_vectors);



	/*

	 * Should be a barrier for any external CPU state.

	 * Should be a barrier for any external CPU state:

	 */

	cpu_init();
@@ -1211,6 +1242,7 @@ void __init trap_init(void) 
static int __init kstack_setup(char *s)

{

	kstack_depth_to_print = simple_strtoul(s, NULL, 0);



	return 1;

}

__setup("kstack=", kstack_setup);