traps.c 23.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 *  linux/arch/i386/traps.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Pentium III FXSR, SSE support
 *	Gareth Hughes <gareth@valinux.com>, May 2000
 */

/*
 * 'Traps.c' handles hardware traps and faults after we have saved some
 * state in 'asm.s'.
 */
#include <linux/config.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.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>
Linus Torvalds's avatar
Linus Torvalds committed
25
#include <linux/highmem.h>
26
#include <linux/kallsyms.h>
27
#include <linux/ptrace.h>
28
#include <linux/version.h>
Linus Torvalds's avatar
Linus Torvalds committed
29

30 31
#ifdef CONFIG_EISA
#include <linux/ioport.h>
Matthew Wilcox's avatar
Matthew Wilcox committed
32
#include <linux/eisa.h>
33 34
#endif

Linus Torvalds's avatar
Linus Torvalds committed
35 36 37 38
#ifdef CONFIG_MCA
#include <linux/mca.h>
#endif

39
#include <asm/processor.h>
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43 44 45 46
#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/atomic.h>
#include <asm/debugreg.h>
#include <asm/desc.h>
#include <asm/i387.h>
John Levon's avatar
John Levon committed
47
#include <asm/nmi.h>
Linus Torvalds's avatar
Linus Torvalds committed
48 49

#include <asm/smp.h>
50
#include <asm/arch_hooks.h>
Linus Torvalds's avatar
Linus Torvalds committed
51 52

#include <linux/irq.h>
Linus Torvalds's avatar
Linus Torvalds committed
53
#include <linux/module.h>
Linus Torvalds's avatar
Linus Torvalds committed
54

Alan Cox's avatar
Alan Cox committed
55 56
#include "mach_traps.h"

Linus Torvalds's avatar
Linus Torvalds committed
57 58 59 60 61 62 63
asmlinkage int system_call(void);
asmlinkage void lcall7(void);
asmlinkage void lcall27(void);

struct desc_struct default_ldt[] = { { 0, 0 }, { 0, 0 }, { 0, 0 },
		{ 0, 0 }, { 0, 0 } };

Alan Cox's avatar
Alan Cox committed
64 65 66
/* Do we ignore FPU interrupts ? */
char ignore_fpu_irq = 0;

Linus Torvalds's avatar
Linus Torvalds committed
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
/*
 * The IDT has to be page-aligned to simplify the Pentium
 * F0 0F bug workaround.. We have a special link segment
 * for this.
 */
struct desc_struct idt_table[256] __attribute__((__section__(".data.idt"))) = { {0, 0}, };

asmlinkage void divide_error(void);
asmlinkage void debug(void);
asmlinkage void nmi(void);
asmlinkage void int3(void);
asmlinkage void overflow(void);
asmlinkage void bounds(void);
asmlinkage void invalid_op(void);
asmlinkage void device_not_available(void);
asmlinkage void coprocessor_segment_overrun(void);
asmlinkage void invalid_TSS(void);
asmlinkage void segment_not_present(void);
asmlinkage void stack_segment(void);
asmlinkage void general_protection(void);
asmlinkage void page_fault(void);
asmlinkage void coprocessor_error(void);
asmlinkage void simd_coprocessor_error(void);
asmlinkage void alignment_check(void);
asmlinkage void spurious_interrupt_bug(void);
asmlinkage void machine_check(void);

94
static int kstack_depth_to_print = 24;
Linus Torvalds's avatar
Linus Torvalds committed
95

96 97 98 99 100 101 102 103 104 105 106 107
static int valid_stack_ptr(struct task_struct *task, void *p)
{
	if (p <= (void *)task->thread_info)
		return 0;
	if (kstack_end(p))
		return 0;
	return 1;
}

#ifdef CONFIG_FRAME_POINTER
void print_context_stack(struct task_struct *task, unsigned long *stack,
			 unsigned long ebp)
Linus Torvalds's avatar
Linus Torvalds committed
108
{
Linus Torvalds's avatar
Linus Torvalds committed
109
	unsigned long addr;
Linus Torvalds's avatar
Linus Torvalds committed
110

111 112 113 114 115 116 117 118 119 120 121 122 123
	while (valid_stack_ptr(task, (void *)ebp)) {
		addr = *(unsigned long *)(ebp + 4);
		printk(" [<%08lx>] ", addr);
		print_symbol("%s", addr);
		printk("\n");
		ebp = *(unsigned long *)ebp;
	}
}
#else
void print_context_stack(struct task_struct *task, unsigned long *stack,
			 unsigned long ebp)
{
	unsigned long addr;
Linus Torvalds's avatar
Linus Torvalds committed
124

125 126 127 128 129 130 131 132
	while (!kstack_end(stack)) {
		addr = *stack++;
		if (kernel_text_address(addr)) {
			printk(" [<%08lx>] ", addr);
			print_symbol("%s\n", addr);
		}
	}
}
Ingo Molnar's avatar
Ingo Molnar committed
133
#endif
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154

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

	if (!task)
		task = current;

	if (!valid_stack_ptr(task, stack)) {
		printk("Stack pointer is garbage, not printing trace\n");
		return;
	}

	if (task == current) {
		/* Grab ebp right from our regs */
		asm ("movl %%ebp, %0" : "=r" (ebp) : );
	} else {
		/* ebp is the last reg pushed by switch_to */
		ebp = *(unsigned long *) task->thread.esp;
	}

155 156
	while (1) {
		struct thread_info *context;
157 158 159
		context = (struct thread_info *)
			((unsigned long)stack & (~(THREAD_SIZE - 1)));
		print_context_stack(task, stack, ebp);
160 161 162 163
		stack = (unsigned long*)context->previous_esp;
		if (!stack)
			break;
		printk(" =======================\n");
Linus Torvalds's avatar
Linus Torvalds committed
164 165 166
	}
}

Andrew Morton's avatar
Andrew Morton committed
167
void show_stack(struct task_struct *task, unsigned long *esp)
Linus Torvalds's avatar
Linus Torvalds committed
168 169 170 171
{
	unsigned long *stack;
	int i;

Andrew Morton's avatar
Andrew Morton committed
172 173 174 175 176 177
	if (esp == NULL) {
		if (task)
			esp = (unsigned long*)task->thread.esp;
		else
			esp = (unsigned long *)&esp;
	}
Linus Torvalds's avatar
Linus Torvalds committed
178 179

	stack = esp;
Andrew Morton's avatar
Andrew Morton committed
180
	for(i = 0; i < kstack_depth_to_print; i++) {
181
		if (kstack_end(stack))
Linus Torvalds's avatar
Linus Torvalds committed
182 183 184 185 186
			break;
		if (i && ((i % 8) == 0))
			printk("\n       ");
		printk("%08lx ", *stack++);
	}
187
	printk("\nCall Trace:\n");
188
	show_trace(task, esp);
Linus Torvalds's avatar
Linus Torvalds committed
189 190
}

191 192 193 194 195
/*
 * The architecture-independent dump_stack generator
 */
void dump_stack(void)
{
196 197
	unsigned long stack;

198
	show_trace(current, &stack);
199 200
}

201 202
EXPORT_SYMBOL(dump_stack);

Linus Torvalds's avatar
Linus Torvalds committed
203
void show_registers(struct pt_regs *regs)
Linus Torvalds's avatar
Linus Torvalds committed
204 205 206 207 208 209 210 211 212 213 214 215 216
{
	int i;
	int in_kernel = 1;
	unsigned long esp;
	unsigned short ss;

	esp = (unsigned long) (&regs->esp);
	ss = __KERNEL_DS;
	if (regs->xcs & 3) {
		in_kernel = 0;
		esp = regs->esp;
		ss = regs->xss & 0xffff;
	}
Ingo Molnar's avatar
Ingo Molnar committed
217
	print_modules();
218 219 220 221
	printk("CPU:    %d\nEIP:    %04x:[<%08lx>]    %s\nEFLAGS: %08lx"
			"   (%s) \n",
		smp_processor_id(), 0xffff & regs->xcs, regs->eip,
		print_tainted(), regs->eflags, UTS_RELEASE);
Ingo Molnar's avatar
Ingo Molnar committed
222
	print_symbol("EIP is at %s\n", regs->eip);
Linus Torvalds's avatar
Linus Torvalds committed
223 224 225 226 227 228
	printk("eax: %08lx   ebx: %08lx   ecx: %08lx   edx: %08lx\n",
		regs->eax, regs->ebx, regs->ecx, regs->edx);
	printk("esi: %08lx   edi: %08lx   ebp: %08lx   esp: %08lx\n",
		regs->esi, regs->edi, regs->ebp, esp);
	printk("ds: %04x   es: %04x   ss: %04x\n",
		regs->xds & 0xffff, regs->xes & 0xffff, ss);
229 230
	printk("Process %s (pid: %d, threadinfo=%p task=%p)",
		current->comm, current->pid, current_thread_info(), current);
Linus Torvalds's avatar
Linus Torvalds committed
231 232 233 234 235 236 237
	/*
	 * When in-kernel, we also print out the stack and code at the
	 * time of the fault..
	 */
	if (in_kernel) {

		printk("\nStack: ");
238
		show_stack(NULL, (unsigned long*)esp);
Linus Torvalds's avatar
Linus Torvalds committed
239

Ingo Molnar's avatar
Ingo Molnar committed
240
		printk("Code: ");
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
		if(regs->eip < PAGE_OFFSET)
			goto bad;

		for(i=0;i<20;i++)
		{
			unsigned char c;
			if(__get_user(c, &((unsigned char*)regs->eip)[i])) {
bad:
				printk(" Bad EIP value.");
				break;
			}
			printk("%02x ", c);
		}
	}
	printk("\n");
}	

258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
static void handle_BUG(struct pt_regs *regs)
{
	unsigned short ud2;
	unsigned short line;
	char *file;
	char c;
	unsigned long eip;

	if (regs->xcs & 3)
		goto no_bug;		/* Not in kernel */

	eip = regs->eip;

	if (eip < PAGE_OFFSET)
		goto no_bug;
	if (__get_user(ud2, (unsigned short *)eip))
		goto no_bug;
	if (ud2 != 0x0b0f)
		goto no_bug;
	if (__get_user(line, (unsigned short *)(eip + 2)))
		goto bug;
	if (__get_user(file, (char **)(eip + 4)) ||
		(unsigned long)file < PAGE_OFFSET || __get_user(c, file))
		file = "<bad filename>";

Ingo Molnar's avatar
Ingo Molnar committed
283
	printk("------------[ cut here ]------------\n");
284
	printk(KERN_ALERT "kernel BUG at %s:%d!\n", file, line);
285 286 287 288 289 290 291 292 293

no_bug:
	return;

	/* Here we know it was a BUG but file-n-line is unavailable */
bug:
	printk("Kernel BUG\n");
}

Linus Torvalds's avatar
Linus Torvalds committed
294 295 296 297
spinlock_t die_lock = SPIN_LOCK_UNLOCKED;

void die(const char * str, struct pt_regs * regs, long err)
{
298
	static int die_counter;
299
	int nl = 0;
300

Linus Torvalds's avatar
Linus Torvalds committed
301 302
	console_verbose();
	spin_lock_irq(&die_lock);
Linus Torvalds's avatar
Linus Torvalds committed
303
	bust_spinlocks(1);
304
	handle_BUG(regs);
305
	printk(KERN_ALERT "%s: %04lx [#%d]\n", str, err & 0xffff, ++die_counter);
306 307 308 309 310 311 312 313 314 315 316 317 318 319
#ifdef CONFIG_PREEMPT
	printk("PREEMPT ");
	nl = 1;
#endif
#ifdef CONFIG_SMP
	printk("SMP ");
	nl = 1;
#endif
#ifdef CONFIG_DEBUG_PAGEALLOC
	printk("DEBUG_PAGEALLOC");
	nl = 1;
#endif
	if (nl)
		printk("\n");
Linus Torvalds's avatar
Linus Torvalds committed
320
	show_registers(regs);
Linus Torvalds's avatar
Linus Torvalds committed
321
	bust_spinlocks(0);
Linus Torvalds's avatar
Linus Torvalds committed
322
	spin_unlock_irq(&die_lock);
323 324 325 326 327 328 329 330 331
	if (in_interrupt())
		panic("Fatal exception in interrupt");

	if (panic_on_oops) {
		printk(KERN_EMERG "Fatal exception: panic in 5 seconds\n");
		set_current_state(TASK_UNINTERRUPTIBLE);
		schedule_timeout(5 * HZ);
		panic("Fatal exception");
	}
Linus Torvalds's avatar
Linus Torvalds committed
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
	do_exit(SIGSEGV);
}

static inline void die_if_kernel(const char * str, struct pt_regs * regs, long err)
{
	if (!(regs->eflags & VM_MASK) && !(3 & regs->xcs))
		die(str, regs, err);
}

static inline unsigned long get_cr2(void)
{
	unsigned long address;

	/* get the address */
	__asm__("movl %%cr2,%0":"=r" (address));
	return address;
}

350
static inline void do_trap(int trapnr, int signr, char *str, int vm86,
Linus Torvalds's avatar
Linus Torvalds committed
351 352
			   struct pt_regs * regs, long error_code, siginfo_t *info)
{
353 354 355 356 357
	if (regs->eflags & VM_MASK) {
		if (vm86)
			goto vm86_trap;
		goto trap_signal;
	}
Linus Torvalds's avatar
Linus Torvalds committed
358

Linus Torvalds's avatar
Linus Torvalds committed
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
	if (!(regs->xcs & 3))
		goto kernel_trap;

	trap_signal: {
		struct task_struct *tsk = current;
		tsk->thread.error_code = error_code;
		tsk->thread.trap_no = trapnr;
		if (info)
			force_sig_info(signr, info, tsk);
		else
			force_sig(signr, tsk);
		return;
	}

	kernel_trap: {
374
		if (!fixup_exception(regs))
Linus Torvalds's avatar
Linus Torvalds committed
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
			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;
		return;
	}
}

#define DO_ERROR(trapnr, signr, str, name) \
asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
{ \
	do_trap(trapnr, signr, str, 0, regs, error_code, NULL); \
}

#define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
{ \
	siginfo_t info; \
	info.si_signo = signr; \
	info.si_errno = 0; \
	info.si_code = sicode; \
	info.si_addr = (void *)siaddr; \
	do_trap(trapnr, signr, str, 0, regs, error_code, &info); \
}

#define DO_VM86_ERROR(trapnr, signr, str, name) \
asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
{ \
	do_trap(trapnr, signr, str, 1, regs, error_code, NULL); \
}

#define DO_VM86_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
{ \
	siginfo_t info; \
	info.si_signo = signr; \
	info.si_errno = 0; \
	info.si_code = sicode; \
	info.si_addr = (void *)siaddr; \
	do_trap(trapnr, signr, str, 1, regs, error_code, &info); \
}

DO_VM86_ERROR_INFO( 0, SIGFPE,  "divide error", divide_error, FPE_INTDIV, regs->eip)
DO_VM86_ERROR( 3, SIGTRAP, "int3", int3)
DO_VM86_ERROR( 4, SIGSEGV, "overflow", overflow)
DO_VM86_ERROR( 5, SIGSEGV, "bounds", bounds)
DO_ERROR_INFO( 6, SIGILL,  "invalid operand", invalid_op, ILL_ILLOPN, regs->eip)
DO_ERROR( 9, SIGFPE,  "coprocessor segment overrun", coprocessor_segment_overrun)
DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
DO_ERROR(11, SIGBUS,  "segment not present", segment_not_present)
DO_ERROR(12, SIGBUS,  "stack segment", stack_segment)
DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, get_cr2())

asmlinkage void do_general_protection(struct pt_regs * regs, long error_code)
{
433 434 435
	if (regs->eflags & X86_EFLAGS_IF)
		local_irq_enable();
 
Linus Torvalds's avatar
Linus Torvalds committed
436 437 438 439 440 441 442 443 444 445 446 447
	if (regs->eflags & VM_MASK)
		goto gp_in_vm86;

	if (!(regs->xcs & 3))
		goto gp_in_kernel;

	current->thread.error_code = error_code;
	current->thread.trap_no = 13;
	force_sig(SIGSEGV, current);
	return;

gp_in_vm86:
448
	local_irq_enable();
Linus Torvalds's avatar
Linus Torvalds committed
449 450 451 452
	handle_vm86_fault((struct kernel_vm86_regs *) regs, error_code);
	return;

gp_in_kernel:
453
	if (!fixup_exception(regs))
Linus Torvalds's avatar
Linus Torvalds committed
454 455 456 457 458 459 460 461 462
		die("general protection fault", regs, error_code);
}

static void mem_parity_error(unsigned char reason, struct pt_regs * regs)
{
	printk("Uhhuh. NMI received. Dazed and confused, but trying to continue\n");
	printk("You probably have a hardware problem with your RAM chips\n");

	/* Clear and disable the memory parity error line. */
Alan Cox's avatar
Alan Cox committed
463
	clear_mem_error(reason);
Linus Torvalds's avatar
Linus Torvalds committed
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
}

static void io_check_error(unsigned char reason, struct pt_regs * regs)
{
	unsigned long i;

	printk("NMI: IOCK error (debug interrupt?)\n");
	show_registers(regs);

	/* Re-enable the IOCK line, wait for a few seconds */
	reason = (reason & 0xf) | 8;
	outb(reason, 0x61);
	i = 2000;
	while (--i) udelay(1000);
	reason &= ~8;
	outb(reason, 0x61);
}

static 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. */
	if( MCA_bus ) {
		mca_handle_nmi();
		return;
	}
#endif
John Levon's avatar
John Levon committed
492 493
	printk("Uhhuh. NMI received for unknown reason %02x on CPU %d.\n",
		reason, smp_processor_id());
Linus Torvalds's avatar
Linus Torvalds committed
494 495 496 497
	printk("Dazed and confused, but trying to continue\n");
	printk("Do you have a strange power saving mode enabled?\n");
}

John Levon's avatar
John Levon committed
498
static void default_do_nmi(struct pt_regs * regs)
Linus Torvalds's avatar
Linus Torvalds committed
499
{
Alan Cox's avatar
Alan Cox committed
500
	unsigned char reason = get_nmi_reason();
John Levon's avatar
John Levon committed
501
 
Linus Torvalds's avatar
Linus Torvalds committed
502
	if (!(reason & 0xc0)) {
503
#ifdef CONFIG_X86_LOCAL_APIC
Linus Torvalds's avatar
Linus Torvalds committed
504 505 506 507 508 509 510
		/*
		 * Ok, so this is none of the documented NMI sources,
		 * so it must be the NMI watchdog.
		 */
		if (nmi_watchdog) {
			nmi_watchdog_tick(regs);
			return;
Linus Torvalds's avatar
Linus Torvalds committed
511
		}
Linus Torvalds's avatar
Linus Torvalds committed
512
#endif
Linus Torvalds's avatar
Linus Torvalds committed
513
		unknown_nmi_error(reason, regs);
Linus Torvalds's avatar
Linus Torvalds committed
514 515 516 517 518 519 520 521 522 523
		return;
	}
	if (reason & 0x80)
		mem_parity_error(reason, regs);
	if (reason & 0x40)
		io_check_error(reason, regs);
	/*
	 * Reassert NMI in case it became active meanwhile
	 * as it's edge-triggered.
	 */
Alan Cox's avatar
Alan Cox committed
524
	reassert_nmi();
Linus Torvalds's avatar
Linus Torvalds committed
525 526
}

John Levon's avatar
John Levon committed
527 528 529 530 531 532 533 534 535
static int dummy_nmi_callback(struct pt_regs * regs, int cpu)
{
	return 0;
}
 
static nmi_callback_t nmi_callback = dummy_nmi_callback;
 
asmlinkage void do_nmi(struct pt_regs * regs, long error_code)
{
536
	int cpu;
John Levon's avatar
John Levon committed
537

538 539 540
	nmi_enter();

	cpu = smp_processor_id();
John Levon's avatar
John Levon committed
541 542 543 544
	++nmi_count(cpu);

	if (!nmi_callback(regs, cpu))
		default_do_nmi(regs);
545 546

	nmi_exit();
John Levon's avatar
John Levon committed
547 548 549 550 551 552 553 554 555 556 557 558
}

void set_nmi_callback(nmi_callback_t callback)
{
	nmi_callback = callback;
}

void unset_nmi_callback(void)
{
	nmi_callback = dummy_nmi_callback;
}

Linus Torvalds's avatar
Linus Torvalds committed
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
/*
 * Our handling of the processor debug registers is non-trivial.
 * We do not clear them on entry and exit from the kernel. Therefore
 * it is possible to get a watchpoint trap here from inside the kernel.
 * However, the code in ./ptrace.c has ensured that the user can
 * only set watchpoints on userspace addresses. Therefore the in-kernel
 * watchpoint trap can only occur in code which is reading/writing
 * from user space. Such code must not hold kernel locks (since it
 * can equally take a page fault), therefore it is safe to call
 * force_sig_info even though that claims and releases locks.
 * 
 * Code in ./signal.c ensures that the debug control register
 * is restored before we deliver any signal, and therefore that
 * user code runs with the correct debug control register even though
 * we clear it here.
 *
 * Being careful here means that we don't have to be as careful in a
 * lot of more complicated places (task switching can be a bit lazy
 * about restoring all the debug state, and ptrace doesn't have to
 * find every occurrence of the TF bit that could be saved away even
 * by user code)
 */
asmlinkage void do_debug(struct pt_regs * regs, long error_code)
{
	unsigned int condition;
	struct task_struct *tsk = current;
	siginfo_t info;

	__asm__ __volatile__("movl %%db6,%0" : "=r" (condition));

589 590 591 592
	/* It's safe to allow irq's after DR6 has been saved */
	if (regs->eflags & X86_EFLAGS_IF)
		local_irq_enable();

Linus Torvalds's avatar
Linus Torvalds committed
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
	/* Mask out spurious debug traps due to lazy DR7 setting */
	if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
		if (!tsk->thread.debugreg[7])
			goto clear_dr7;
	}

	if (regs->eflags & VM_MASK)
		goto debug_vm86;

	/* Save debug status register where ptrace can see it */
	tsk->thread.debugreg[6] = condition;

	/* Mask out spurious TF errors due to lazy TF clearing */
	if (condition & DR_STEP) {
		/*
		 * The TF error should be masked out only if the current
		 * process is not traced and if the TRAP flag has been set
		 * previously by a tracing process (condition detected by
		 * the PT_DTRACE flag); remember that the i386 TRAP flag
		 * can be modified by the process itself in user mode,
		 * allowing programs to debug themselves without the ptrace()
		 * interface.
		 */
616
		if ((regs->xcs & 3) == 0)
617
			goto clear_TF_reenable;
Linus Torvalds's avatar
Linus Torvalds committed
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
		if ((tsk->ptrace & (PT_DTRACE|PT_PTRACED)) == PT_DTRACE)
			goto clear_TF;
	}

	/* Ok, finally something we can handle */
	tsk->thread.trap_no = 1;
	tsk->thread.error_code = error_code;
	info.si_signo = SIGTRAP;
	info.si_errno = 0;
	info.si_code = TRAP_BRKPT;
	
	/* If this is a kernel mode trap, save the user PC on entry to 
	 * the kernel, that's what the debugger can make sense of.
	 */
	info.si_addr = ((regs->xcs & 3) == 0) ? (void *)tsk->thread.eip : 
	                                        (void *)regs->eip;
	force_sig_info(SIGTRAP, &info, tsk);

	/* Disable additional traps. They'll be re-enabled when
	 * the signal is delivered.
	 */
clear_dr7:
	__asm__("movl %0,%%db7"
		: /* no output */
		: "r" (0));
	return;

debug_vm86:
	handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code, 1);
	return;

649 650
clear_TF_reenable:
	set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
Linus Torvalds's avatar
Linus Torvalds committed
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
clear_TF:
	regs->eflags &= ~TF_MASK;
	return;
}

/*
 * Note that we play around with the 'TS' bit in an attempt to get
 * the correct behaviour even in the presence of the asynchronous
 * IRQ13 behaviour
 */
void math_error(void *eip)
{
	struct task_struct * task;
	siginfo_t info;
	unsigned short cwd, swd;

	/*
	 * Save the info for the exception handler and clear the error.
	 */
	task = current;
	save_init_fpu(task);
	task->thread.trap_no = 16;
	task->thread.error_code = 0;
	info.si_signo = SIGFPE;
	info.si_errno = 0;
	info.si_code = __SI_FAULT;
	info.si_addr = eip;
	/*
	 * (~cwd & swd) will mask out exceptions that are not set to unmasked
	 * status.  0x3f is the exception bits in these regs, 0x200 is the
	 * C1 reg you need in case of a stack fault, 0x040 is the stack
	 * fault bit.  We should only be taking one exception at a time,
	 * so if this combination doesn't produce any single exception,
	 * then we have a bad program that isn't syncronizing its FPU usage
	 * and it will suffer the consequences since we won't be able to
	 * fully reproduce the context of the exception
	 */
	cwd = get_fpu_cwd(task);
	swd = get_fpu_swd(task);
	switch (((~cwd) & swd & 0x3f) | (swd & 0x240)) {
		case 0x000:
		default:
			break;
		case 0x001: /* Invalid Op */
695 696
		case 0x041: /* Stack Fault */
		case 0x241: /* Stack Fault | Direction */
Linus Torvalds's avatar
Linus Torvalds committed
697
			info.si_code = FPE_FLTINV;
698
			/* Should we clear the SF or let user space do it ???? */
Linus Torvalds's avatar
Linus Torvalds committed
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
			break;
		case 0x002: /* Denormalize */
		case 0x010: /* Underflow */
			info.si_code = FPE_FLTUND;
			break;
		case 0x004: /* Zero Divide */
			info.si_code = FPE_FLTDIV;
			break;
		case 0x008: /* Overflow */
			info.si_code = FPE_FLTOVF;
			break;
		case 0x020: /* Precision */
			info.si_code = FPE_FLTRES;
			break;
	}
	force_sig_info(SIGFPE, &info, task);
}

asmlinkage void do_coprocessor_error(struct pt_regs * regs, long error_code)
{
Alan Cox's avatar
Alan Cox committed
719
	ignore_fpu_irq = 1;
Linus Torvalds's avatar
Linus Torvalds committed
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
	math_error((void *)regs->eip);
}

void simd_math_error(void *eip)
{
	struct task_struct * task;
	siginfo_t info;
	unsigned short mxcsr;

	/*
	 * Save the info for the exception handler and clear the error.
	 */
	task = current;
	save_init_fpu(task);
	task->thread.trap_no = 19;
	task->thread.error_code = 0;
	info.si_signo = SIGFPE;
	info.si_errno = 0;
	info.si_code = __SI_FAULT;
	info.si_addr = eip;
	/*
	 * The SIMD FPU exceptions are handled a little differently, as there
	 * is only a single status/control register.  Thus, to determine which
	 * unmasked exception was caught we must mask the exception mask bits
	 * at 0x1f80, and then use these to mask the exception bits at 0x3f.
	 */
	mxcsr = get_fpu_mxcsr(task);
	switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) {
		case 0x000:
		default:
			break;
		case 0x001: /* Invalid Op */
			info.si_code = FPE_FLTINV;
			break;
		case 0x002: /* Denormalize */
		case 0x010: /* Underflow */
			info.si_code = FPE_FLTUND;
			break;
		case 0x004: /* Zero Divide */
			info.si_code = FPE_FLTDIV;
			break;
		case 0x008: /* Overflow */
			info.si_code = FPE_FLTOVF;
			break;
		case 0x020: /* Precision */
			info.si_code = FPE_FLTRES;
			break;
	}
	force_sig_info(SIGFPE, &info, task);
}

asmlinkage void do_simd_coprocessor_error(struct pt_regs * regs,
					  long error_code)
{
	if (cpu_has_xmm) {
		/* Handle SIMD FPU exceptions on PIII+ processors. */
Alan Cox's avatar
Alan Cox committed
776
		ignore_fpu_irq = 1;
Linus Torvalds's avatar
Linus Torvalds committed
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
		simd_math_error((void *)regs->eip);
	} else {
		/*
		 * Handle strange cache flush from user space exception
		 * in all other cases.  This is undocumented behaviour.
		 */
		if (regs->eflags & VM_MASK) {
			handle_vm86_fault((struct kernel_vm86_regs *)regs,
					  error_code);
			return;
		}
		die_if_kernel("cache flush denied", regs, error_code);
		current->thread.trap_no = 19;
		current->thread.error_code = error_code;
		force_sig(SIGSEGV, current);
	}
}

asmlinkage 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");
#endif
}

/*
 *  'math_state_restore()' saves the current math information in the
 * old math state array, and gets the new ones from the current task
 *
 * Careful.. There are problems with IBM-designed IRQ13 behaviour.
 * Don't touch unless you *really* know how it works.
810
 *
811 812
 * Must be called with kernel preemption disabled (in this case,
 * local interrupts are disabled at the call-site in entry.S).
Linus Torvalds's avatar
Linus Torvalds committed
813 814 815
 */
asmlinkage void math_state_restore(struct pt_regs regs)
{
816 817
	struct thread_info *thread = current_thread_info();
	struct task_struct *tsk = thread->task;
Linus Torvalds's avatar
Linus Torvalds committed
818

819
	clts();		/* Allow maths ops (or we recurse) */
820 821 822
	if (!tsk->used_math)
		init_fpu(tsk);
	restore_fpu(tsk);
823
	thread->status |= TS_USEDFPU;	/* So we fnsave on switch_to() */
Linus Torvalds's avatar
Linus Torvalds committed
824 825 826 827 828 829 830 831 832 833 834 835 836 837
}

#ifndef CONFIG_MATH_EMULATION

asmlinkage void math_emulate(long arg)
{
	printk("math-emulation not enabled and no coprocessor found.\n");
	printk("killing %s.\n",current->comm);
	force_sig(SIGFPE,current);
	schedule();
}

#endif /* CONFIG_MATH_EMULATION */

Brian Gerst's avatar
Brian Gerst committed
838
#ifdef CONFIG_X86_F00F_BUG
Linus Torvalds's avatar
Linus Torvalds committed
839 840
void __init trap_init_f00f_bug(void)
{
Brian Gerst's avatar
Brian Gerst committed
841
	__set_fixmap(FIX_F00F_IDT, __pa(&idt_table), PAGE_KERNEL_RO);
Linus Torvalds's avatar
Linus Torvalds committed
842 843

	/*
844 845
	 * Update the IDT descriptor and reload the IDT so that
	 * it uses the read-only mapped virtual address.
Linus Torvalds's avatar
Linus Torvalds committed
846
	 */
847
	idt_descr.address = fix_to_virt(FIX_F00F_IDT);
848
	__asm__ __volatile__("lidt %0" : : "m" (idt_descr));
Linus Torvalds's avatar
Linus Torvalds committed
849 850 851
}
#endif

852
#define _set_gate(gate_addr,type,dpl,addr,seg) \
Linus Torvalds's avatar
Linus Torvalds committed
853 854 855 856 857 858 859 860 861
do { \
  int __d0, __d1; \
  __asm__ __volatile__ ("movw %%dx,%%ax\n\t" \
	"movw %4,%%dx\n\t" \
	"movl %%eax,%0\n\t" \
	"movl %%edx,%1" \
	:"=m" (*((long *) (gate_addr))), \
	 "=m" (*(1+(long *) (gate_addr))), "=&a" (__d0), "=&d" (__d1) \
	:"i" ((short) (0x8000+(dpl<<13)+(type<<8))), \
862
	 "3" ((char *) (addr)),"2" ((seg) << 16)); \
Linus Torvalds's avatar
Linus Torvalds committed
863 864 865 866 867 868 869 870 871 872 873
} while (0)


/*
 * This needs to use 'idt_table' rather than 'idt', and
 * thus use the _nonmapped_ version of the IDT, as the
 * Pentium F0 0F bugfix can have resulted in the mapped
 * IDT being write-protected.
 */
void set_intr_gate(unsigned int n, void *addr)
{
874
	_set_gate(idt_table+n,14,0,addr,__KERNEL_CS);
Linus Torvalds's avatar
Linus Torvalds committed
875 876 877 878
}

static void __init set_trap_gate(unsigned int n, void *addr)
{
879
	_set_gate(idt_table+n,15,0,addr,__KERNEL_CS);
Linus Torvalds's avatar
Linus Torvalds committed
880 881 882 883
}

static void __init set_system_gate(unsigned int n, void *addr)
{
884
	_set_gate(idt_table+n,15,3,addr,__KERNEL_CS);
Linus Torvalds's avatar
Linus Torvalds committed
885 886 887 888
}

static void __init set_call_gate(void *a, void *addr)
{
889 890 891 892 893 894
	_set_gate(a,12,3,addr,__KERNEL_CS);
}

static void __init set_task_gate(unsigned int n, unsigned int gdt_entry)
{
	_set_gate(idt_table+n,5,0,0,(gdt_entry<<3));
Linus Torvalds's avatar
Linus Torvalds committed
895 896
}

897

Linus Torvalds's avatar
Linus Torvalds committed
898 899 900
void __init trap_init(void)
{
#ifdef CONFIG_EISA
901
	if (isa_readl(0x0FFFD9) == 'E'+('I'<<8)+('S'<<16)+('A'<<24)) {
Linus Torvalds's avatar
Linus Torvalds committed
902
		EISA_bus = 1;
903
	}
Linus Torvalds's avatar
Linus Torvalds committed
904 905
#endif

Dave Jones's avatar
Dave Jones committed
906 907 908 909
#ifdef CONFIG_X86_LOCAL_APIC
	init_apic_mappings();
#endif

Linus Torvalds's avatar
Linus Torvalds committed
910
	set_trap_gate(0,&divide_error);
911
	set_intr_gate(1,&debug);
Linus Torvalds's avatar
Linus Torvalds committed
912 913 914 915 916 917
	set_intr_gate(2,&nmi);
	set_system_gate(3,&int3);	/* int3-5 can be called from all */
	set_system_gate(4,&overflow);
	set_system_gate(5,&bounds);
	set_trap_gate(6,&invalid_op);
	set_trap_gate(7,&device_not_available);
918
	set_task_gate(8,GDT_ENTRY_DOUBLEFAULT_TSS);
Linus Torvalds's avatar
Linus Torvalds committed
919 920 921 922 923
	set_trap_gate(9,&coprocessor_segment_overrun);
	set_trap_gate(10,&invalid_TSS);
	set_trap_gate(11,&segment_not_present);
	set_trap_gate(12,&stack_segment);
	set_trap_gate(13,&general_protection);
Linus Torvalds's avatar
Linus Torvalds committed
924
	set_intr_gate(14,&page_fault);
Linus Torvalds's avatar
Linus Torvalds committed
925 926 927
	set_trap_gate(15,&spurious_interrupt_bug);
	set_trap_gate(16,&coprocessor_error);
	set_trap_gate(17,&alignment_check);
928
#ifdef CONFIG_X86_MCE
Linus Torvalds's avatar
Linus Torvalds committed
929
	set_trap_gate(18,&machine_check);
930
#endif
Linus Torvalds's avatar
Linus Torvalds committed
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
	set_trap_gate(19,&simd_coprocessor_error);

	set_system_gate(SYSCALL_VECTOR,&system_call);

	/*
	 * default LDT is a single-entry callgate to lcall7 for iBCS
	 * and a callgate to lcall27 for Solaris/x86 binaries
	 */
	set_call_gate(&default_ldt[0],lcall7);
	set_call_gate(&default_ldt[4],lcall27);

	/*
	 * Should be a barrier for any external CPU state.
	 */
	cpu_init();

947
	trap_init_hook();
Linus Torvalds's avatar
Linus Torvalds committed
948
}