traps_64.c 30.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
 *
 *  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 'entry.S'.
 */
13 14 15 16 17 18 19 20
#include <linux/moduleparam.h>
#include <linux/interrupt.h>
#include <linux/kallsyms.h>
#include <linux/spinlock.h>
#include <linux/kprobes.h>
#include <linux/uaccess.h>
#include <linux/utsname.h>
#include <linux/kdebug.h>
L
Linus Torvalds 已提交
21
#include <linux/kernel.h>
22 23
#include <linux/module.h>
#include <linux/ptrace.h>
L
Linus Torvalds 已提交
24
#include <linux/string.h>
25 26
#include <linux/unwind.h>
#include <linux/delay.h>
L
Linus Torvalds 已提交
27
#include <linux/errno.h>
28 29
#include <linux/kexec.h>
#include <linux/sched.h>
L
Linus Torvalds 已提交
30 31
#include <linux/timer.h>
#include <linux/init.h>
32
#include <linux/bug.h>
33 34
#include <linux/nmi.h>
#include <linux/mm.h>
35

D
Dave Jiang 已提交
36 37 38 39
#if defined(CONFIG_EDAC)
#include <linux/edac.h>
#endif

40 41
#include <asm/stacktrace.h>
#include <asm/processor.h>
L
Linus Torvalds 已提交
42
#include <asm/debugreg.h>
43 44 45
#include <asm/atomic.h>
#include <asm/system.h>
#include <asm/unwind.h>
L
Linus Torvalds 已提交
46 47
#include <asm/desc.h>
#include <asm/i387.h>
48
#include <asm/nmi.h>
L
Linus Torvalds 已提交
49
#include <asm/smp.h>
50
#include <asm/io.h>
L
Linus Torvalds 已提交
51 52
#include <asm/pgalloc.h>
#include <asm/proto.h>
53 54 55
#include <asm/pda.h>

#include <mach_traps.h>
L
Linus Torvalds 已提交
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

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 double_fault(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);
76
asmlinkage void machine_check(void);
L
Linus Torvalds 已提交
77

78
int panic_on_unrecovered_nmi;
79
int kstack_depth_to_print = 12;
80
static unsigned int code_bytes = 64;
81 82
static int ignore_nmis;
static int die_counter;
83

L
Linus Torvalds 已提交
84 85
static inline void conditional_sti(struct pt_regs *regs)
{
86
	if (regs->flags & X86_EFLAGS_IF)
L
Linus Torvalds 已提交
87 88 89
		local_irq_enable();
}

90 91
static inline void preempt_conditional_sti(struct pt_regs *regs)
{
92
	inc_preempt_count();
93
	if (regs->flags & X86_EFLAGS_IF)
94 95 96 97 98
		local_irq_enable();
}

static inline void preempt_conditional_cli(struct pt_regs *regs)
{
99
	if (regs->flags & X86_EFLAGS_IF)
100
		local_irq_disable();
101 102
	/* Make sure to not schedule here because we could be running
	   on an exception stack. */
103
	dec_preempt_count();
104 105
}

106
void printk_address(unsigned long address, int reliable)
107
{
108
#ifdef CONFIG_KALLSYMS
L
Linus Torvalds 已提交
109 110 111
	unsigned long offset = 0, symsize;
	const char *symname;
	char *modname;
112
	char *delim = ":";
C
Cyrill Gorcunov 已提交
113
	char namebuf[KSYM_NAME_LEN];
114
	char reliab[4] = "";
L
Linus Torvalds 已提交
115

116 117 118 119 120 121
	symname = kallsyms_lookup(address, &symsize, &offset,
					&modname, namebuf);
	if (!symname) {
		printk(" [<%016lx>]\n", address);
		return;
	}
122 123 124
	if (!reliable)
		strcpy(reliab, "? ");

125
	if (!modname)
126
		modname = delim = "";
127 128
	printk(" [<%016lx>] %s%s%s%s%s+0x%lx/0x%lx\n",
		address, reliab, delim, modname, delim, symname, offset, symsize);
L
Linus Torvalds 已提交
129
#else
130
	printk(" [<%016lx>]\n", address);
L
Linus Torvalds 已提交
131
#endif
132
}
L
Linus Torvalds 已提交
133

134
static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
135
					unsigned *usedp, char **idp)
136
{
137
	static char ids[][8] = {
138 139 140 141 142
		[DEBUG_STACK - 1] = "#DB",
		[NMI_STACK - 1] = "NMI",
		[DOUBLEFAULT_STACK - 1] = "#DF",
		[STACKFAULT_STACK - 1] = "#SS",
		[MCE_STACK - 1] = "#MC",
143 144 145
#if DEBUG_STKSZ > EXCEPTION_STKSZ
		[N_EXCEPTION_STACKS ... N_EXCEPTION_STACKS + DEBUG_STKSZ / EXCEPTION_STKSZ - 2] = "#DB[?]"
#endif
146 147
	};
	unsigned k;
L
Linus Torvalds 已提交
148

149 150 151 152
	/*
	 * Iterate over all exception stacks, and figure out whether
	 * 'stack' is in one of them:
	 */
153
	for (k = 0; k < N_EXCEPTION_STACKS; k++) {
154
		unsigned long end = per_cpu(orig_ist, cpu).ist[k];
155 156 157 158
		/*
		 * Is 'stack' above this exception frame's end?
		 * If yes then skip to the next frame.
		 */
159 160
		if (stack >= end)
			continue;
161 162 163 164
		/*
		 * Is 'stack' above this exception frame's start address?
		 * If yes then we found the right frame.
		 */
165
		if (stack >= end - EXCEPTION_STKSZ) {
166 167 168 169 170 171
			/*
			 * Make sure we only iterate through an exception
			 * stack once. If it comes up for the second time
			 * then there's something wrong going on - just
			 * break out and return NULL:
			 */
172 173 174 175 176 177
			if (*usedp & (1U << k))
				break;
			*usedp |= 1U << k;
			*idp = ids[k];
			return (unsigned long *)end;
		}
178 179 180 181 182
		/*
		 * If this is a debug stack, and if it has a larger size than
		 * the usual exception stacks, then 'stack' might still
		 * be within the lower portion of the debug stack:
		 */
183 184 185 186
#if DEBUG_STKSZ > EXCEPTION_STKSZ
		if (k == DEBUG_STACK - 1 && stack >= end - DEBUG_STKSZ) {
			unsigned j = N_EXCEPTION_STACKS - 1;

187 188 189 190 191
			/*
			 * Black magic. A large debug stack is composed of
			 * multiple exception stack entries, which we
			 * iterate through now. Dont look:
			 */
192 193 194 195 196 197 198 199 200 201 202 203
			do {
				++j;
				end -= EXCEPTION_STKSZ;
				ids[j][4] = '1' + (j - N_EXCEPTION_STACKS);
			} while (stack < end - EXCEPTION_STKSZ);
			if (*usedp & (1U << j))
				break;
			*usedp |= 1U << j;
			*idp = ids[j];
			return (unsigned long *)end;
		}
#endif
L
Linus Torvalds 已提交
204 205
	}
	return NULL;
206
}
L
Linus Torvalds 已提交
207 208

/*
S
Simon Arlott 已提交
209
 * x86-64 can have up to three kernel stacks: 
L
Linus Torvalds 已提交
210 211
 * process stack
 * interrupt stack
212
 * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
L
Linus Torvalds 已提交
213 214
 */

215 216
static inline int valid_stack_ptr(struct thread_info *tinfo,
			void *p, unsigned int size, void *end)
217
{
J
Jan Engelhardt 已提交
218
	void *t = tinfo;
219 220 221 222 223 224 225 226 227
	if (end) {
		if (p < end && p >= (end-THREAD_SIZE))
			return 1;
		else
			return 0;
	}
	return p > t && p < t + THREAD_SIZE - size;
}

228 229 230 231 232 233
/* The form of the top of the frame on the stack */
struct stack_frame {
	struct stack_frame *next_frame;
	unsigned long return_address;
};

234 235 236 237 238
static inline unsigned long
print_context_stack(struct thread_info *tinfo,
		unsigned long *stack, unsigned long bp,
		const struct stacktrace_ops *ops, void *data,
		unsigned long *end)
239
{
240 241 242 243 244 245
	struct stack_frame *frame = (struct stack_frame *)bp;

	while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) {
		unsigned long addr;

		addr = *stack;
246
		if (__kernel_text_address(addr)) {
247 248 249 250 251 252 253
			if ((unsigned long) stack == bp + 8) {
				ops->address(data, addr, 1);
				frame = frame->next_frame;
				bp = (unsigned long) frame;
			} else {
				ops->address(data, addr, bp == 0);
			}
254
		}
255
		stack++;
256 257
	}
	return bp;
258 259
}

260
void dump_trace(struct task_struct *task, struct pt_regs *regs,
261
		unsigned long *stack, unsigned long bp,
J
Jan Beulich 已提交
262
		const struct stacktrace_ops *ops, void *data)
L
Linus Torvalds 已提交
263
{
264
	const unsigned cpu = get_cpu();
265
	unsigned long *irqstack_end = (unsigned long*)cpu_pda(cpu)->irqstackptr;
266
	unsigned used = 0;
267
	struct thread_info *tinfo;
L
Linus Torvalds 已提交
268

269 270 271
	if (!task)
		task = current;
	tinfo = task_thread_info(task);
272

273 274 275
	if (!stack) {
		unsigned long dummy;
		stack = &dummy;
276 277
		if (task && task != current)
			stack = (unsigned long *)task->thread.sp;
278 279
	}

280 281
#ifdef CONFIG_FRAME_POINTER
	if (!bp) {
282
		if (task == current) {
283
			/* Grab bp right from our regs */
284
			asm("movq %%rbp, %0" : "=r" (bp) :);
285 286
		} else {
			/* bp is the last reg pushed by switch_to */
287
			bp = *(unsigned long *) task->thread.sp;
288 289 290 291
		}
	}
#endif

292 293 294 295 296
	/*
	 * Print function call entries in all stacks, starting at the
	 * current stack address. If the stacks consist of nested
	 * exceptions
	 */
297 298
	for (;;) {
		char *id;
299 300 301 302 303
		unsigned long *estack_end;
		estack_end = in_exception_stack(cpu, (unsigned long)stack,
						&used, &id);

		if (estack_end) {
304 305
			if (ops->stack(data, id) < 0)
				break;
306

307 308
			bp = print_context_stack(tinfo, stack, bp, ops,
							data, estack_end);
309
			ops->stack(data, "<EOE>");
310 311 312 313 314
			/*
			 * We link to the next stack via the
			 * second-to-last pointer (index -2 to end) in the
			 * exception stack:
			 */
315 316
			stack = (unsigned long *) estack_end[-2];
			continue;
L
Linus Torvalds 已提交
317
		}
318 319 320 321 322 323
		if (irqstack_end) {
			unsigned long *irqstack;
			irqstack = irqstack_end -
				(IRQSTACKSIZE - 64) / sizeof(*irqstack);

			if (stack >= irqstack && stack < irqstack_end) {
324 325
				if (ops->stack(data, "IRQ") < 0)
					break;
326 327
				bp = print_context_stack(tinfo, stack, bp,
						ops, data, irqstack_end);
328 329 330 331 332
				/*
				 * We link to the next stack (which would be
				 * the process stack normally) the last
				 * pointer (index -1 to end) in the IRQ stack:
				 */
333 334
				stack = (unsigned long *) (irqstack_end[-1]);
				irqstack_end = NULL;
335
				ops->stack(data, "EOI");
336
				continue;
L
Linus Torvalds 已提交
337 338
			}
		}
339
		break;
L
Linus Torvalds 已提交
340
	}
341

342
	/*
343
	 * This handles the process stack:
344
	 */
345
	bp = print_context_stack(tinfo, stack, bp, ops, data, NULL);
346
	put_cpu();
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
}
EXPORT_SYMBOL(dump_trace);

static void
print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
{
	print_symbol(msg, symbol);
	printk("\n");
}

static void print_trace_warning(void *data, char *msg)
{
	printk("%s\n", msg);
}

static int print_trace_stack(void *data, char *name)
{
	printk(" <%s> ", name);
	return 0;
}
367

368
static void print_trace_address(void *data, unsigned long addr, int reliable)
369
{
370
	touch_nmi_watchdog();
371
	printk_address(addr, reliable);
372 373
}

J
Jan Beulich 已提交
374
static const struct stacktrace_ops print_trace_ops = {
375 376 377 378 379 380
	.warning = print_trace_warning,
	.warning_symbol = print_trace_warning_symbol,
	.stack = print_trace_stack,
	.address = print_trace_address,
};

381 382
void show_trace(struct task_struct *task, struct pt_regs *regs,
		unsigned long *stack, unsigned long bp)
383 384
{
	printk("\nCall Trace:\n");
385
	dump_trace(task, regs, stack, bp, &print_trace_ops, NULL);
L
Linus Torvalds 已提交
386 387 388
	printk("\n");
}

389
static void
390 391
_show_stack(struct task_struct *task, struct pt_regs *regs,
		unsigned long *sp, unsigned long bp)
L
Linus Torvalds 已提交
392 393 394
{
	unsigned long *stack;
	int i;
395
	const int cpu = smp_processor_id();
396 397
	unsigned long *irqstack_end = (unsigned long *) (cpu_pda(cpu)->irqstackptr);
	unsigned long *irqstack = (unsigned long *) (cpu_pda(cpu)->irqstackptr - IRQSTACKSIZE);
L
Linus Torvalds 已提交
398 399 400 401

	// debugging aid: "show_stack(NULL, NULL);" prints the
	// back trace for this cpu.

402
	if (sp == NULL) {
403 404
		if (task)
			sp = (unsigned long *)task->thread.sp;
L
Linus Torvalds 已提交
405
		else
406
			sp = (unsigned long *)&sp;
L
Linus Torvalds 已提交
407 408
	}

409
	stack = sp;
410
	for (i = 0; i < kstack_depth_to_print; i++) {
L
Linus Torvalds 已提交
411 412 413 414 415 416 417 418 419 420
		if (stack >= irqstack && stack <= irqstack_end) {
			if (stack == irqstack_end) {
				stack = (unsigned long *) (irqstack_end[-1]);
				printk(" <EOI> ");
			}
		} else {
		if (((long) stack & (THREAD_SIZE-1)) == 0)
			break;
		}
		if (i && ((i % 4) == 0))
421 422
			printk("\n");
		printk(" %016lx", *stack++);
423
		touch_nmi_watchdog();
L
Linus Torvalds 已提交
424
	}
425
	show_trace(task, regs, sp, bp);
426 427
}

428
void show_stack(struct task_struct *task, unsigned long *sp)
429
{
430
	_show_stack(task, NULL, sp, 0);
L
Linus Torvalds 已提交
431 432 433 434 435 436 437
}

/*
 * The architecture-independent dump_stack generator
 */
void dump_stack(void)
{
438
	unsigned long stack;
439
	unsigned long bp = 0;
440

441 442 443 444 445
#ifdef CONFIG_FRAME_POINTER
	if (!bp)
		asm("movq %%rbp, %0" : "=r" (bp):);
#endif

446 447 448 449 450
	printk("Pid: %d, comm: %.20s %s %s %.*s\n",
		current->pid, current->comm, print_tainted(),
		init_utsname()->release,
		(int)strcspn(init_utsname()->version, " "),
		init_utsname()->version);
451
	show_trace(NULL, NULL, &stack, bp);
L
Linus Torvalds 已提交
452 453 454 455 456 457 458
}

EXPORT_SYMBOL(dump_stack);

void show_registers(struct pt_regs *regs)
{
	int i;
459
	unsigned long sp;
460
	const int cpu = smp_processor_id();
461
	struct task_struct *cur = cpu_pda(cpu)->pcurrent;
462 463 464
	u8 *ip;
	unsigned int code_prologue = code_bytes * 43 / 64;
	unsigned int code_len = code_bytes;
L
Linus Torvalds 已提交
465

466
	sp = regs->sp;
467
	ip = (u8 *) regs->ip - code_prologue;
L
Linus Torvalds 已提交
468 469 470
	printk("CPU %d ", cpu);
	__show_regs(regs);
	printk("Process %s (pid: %d, threadinfo %p, task %p)\n",
A
Al Viro 已提交
471
		cur->comm, cur->pid, task_thread_info(cur), cur);
L
Linus Torvalds 已提交
472 473 474 475 476

	/*
	 * When in-kernel, we also print out the stack and code at the
	 * time of the fault..
	 */
477 478
	if (!user_mode(regs)) {
		unsigned char c;
L
Linus Torvalds 已提交
479
		printk("Stack: ");
480
		_show_stack(NULL, regs, (unsigned long *)sp, regs->bp);
481
		printk("\n");
L
Linus Torvalds 已提交
482

483 484 485
		printk(KERN_EMERG "Code: ");
		if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) {
			/* try starting at RIP */
486
			ip = (u8 *)regs->ip;
487 488 489 490 491
			code_len = code_len - code_prologue + 1;
		}
		for (i = 0; i < code_len; i++, ip++) {
			if (ip < (u8 *)PAGE_OFFSET ||
					probe_kernel_address(ip, c)) {
L
Linus Torvalds 已提交
492 493 494
				printk(" Bad RIP value.");
				break;
			}
495 496 497 498
			if (ip == (u8 *)regs->ip)
				printk("<%02x> ", c);
			else
				printk("%02x ", c);
L
Linus Torvalds 已提交
499 500 501
		}
	}
	printk("\n");
502
}
L
Linus Torvalds 已提交
503

504
int is_valid_bugaddr(unsigned long ip)
505 506 507
{
	unsigned short ud2;

508
	if (__copy_from_user(&ud2, (const void __user *) ip, sizeof(ud2)))
509 510 511 512
		return 0;

	return ud2 == 0x0b0f;
}
L
Linus Torvalds 已提交
513

A
Andi Kleen 已提交
514
static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED;
L
Linus Torvalds 已提交
515
static int die_owner = -1;
516
static unsigned int die_nest_count;
L
Linus Torvalds 已提交
517

518
unsigned __kprobes long oops_begin(void)
L
Linus Torvalds 已提交
519
{
A
Andrew Morton 已提交
520
	int cpu;
521 522
	unsigned long flags;

523 524
	oops_enter();

525
	/* racy, but better than risking deadlock. */
A
Andi Kleen 已提交
526
	raw_local_irq_save(flags);
A
Andrew Morton 已提交
527
	cpu = smp_processor_id();
A
Andi Kleen 已提交
528
	if (!__raw_spin_trylock(&die_lock)) {
L
Linus Torvalds 已提交
529 530 531
		if (cpu == die_owner) 
			/* nested oops. should stop eventually */;
		else
A
Andi Kleen 已提交
532
			__raw_spin_lock(&die_lock);
L
Linus Torvalds 已提交
533
	}
534
	die_nest_count++;
535
	die_owner = cpu;
L
Linus Torvalds 已提交
536
	console_verbose();
537 538
	bust_spinlocks(1);
	return flags;
L
Linus Torvalds 已提交
539 540
}

541
void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr)
L
Linus Torvalds 已提交
542 543
{ 
	die_owner = -1;
544
	bust_spinlocks(0);
545
	die_nest_count--;
A
Andi Kleen 已提交
546
	if (!die_nest_count)
547
		/* Nest count reaches zero, release the lock. */
A
Andi Kleen 已提交
548 549
		__raw_spin_unlock(&die_lock);
	raw_local_irq_restore(flags);
550 551 552 553
	if (!regs) {
		oops_exit();
		return;
	}
L
Linus Torvalds 已提交
554
	if (panic_on_oops)
555
		panic("Fatal exception");
556
	oops_exit();
557
	do_exit(signr);
558
}
L
Linus Torvalds 已提交
559

560
int __kprobes __die(const char *str, struct pt_regs *regs, long err)
L
Linus Torvalds 已提交
561
{
562
	printk(KERN_EMERG "%s: %04lx [%u] ", str, err & 0xffff, ++die_counter);
L
Linus Torvalds 已提交
563 564 565 566 567 568 569 570 571 572
#ifdef CONFIG_PREEMPT
	printk("PREEMPT ");
#endif
#ifdef CONFIG_SMP
	printk("SMP ");
#endif
#ifdef CONFIG_DEBUG_PAGEALLOC
	printk("DEBUG_PAGEALLOC");
#endif
	printk("\n");
573 574
	if (notify_die(DIE_OOPS, str, regs, err,
			current->thread.trap_no, SIGSEGV) == NOTIFY_STOP)
575
		return 1;
576

L
Linus Torvalds 已提交
577
	show_registers(regs);
578
	add_taint(TAINT_DIE);
L
Linus Torvalds 已提交
579 580
	/* Executive summary in case the oops scrolled away */
	printk(KERN_ALERT "RIP ");
581
	printk_address(regs->ip, 1);
582
	printk(" RSP <%016lx>\n", regs->sp);
583 584
	if (kexec_should_crash(current))
		crash_kexec(regs);
585
	return 0;
L
Linus Torvalds 已提交
586 587
}

588
void die(const char * str, struct pt_regs *regs, long err)
L
Linus Torvalds 已提交
589
{
590 591
	unsigned long flags = oops_begin();

592
	if (!user_mode(regs))
593
		report_bug(regs->ip, regs);
594

595 596 597
	if (__die(str, regs, err))
		regs = NULL;
	oops_end(flags, regs, SIGSEGV);
L
Linus Torvalds 已提交
598 599
}

600 601
notrace __kprobes void
die_nmi(char *str, struct pt_regs *regs, int do_panic)
L
Linus Torvalds 已提交
602
{
603
	unsigned long flags;
604

605
	if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP)
606
		return;
607

608
	flags = oops_begin();
L
Linus Torvalds 已提交
609 610 611 612
	/*
	 * We are in trouble anyway, lets at least try
	 * to get a message out.
	 */
613 614 615
	printk(KERN_EMERG "%s", str);
	printk(" on CPU%d, ip %08lx, registers:\n",
		smp_processor_id(), regs->ip);
L
Linus Torvalds 已提交
616
	show_registers(regs);
617 618
	if (kexec_should_crash(current))
		crash_kexec(regs);
619 620
	if (do_panic || panic_on_oops)
		panic("Non maskable interrupt");
621
	oops_end(flags, NULL, SIGBUS);
622 623
	nmi_exit();
	local_irq_enable();
624
	do_exit(SIGBUS);
L
Linus Torvalds 已提交
625 626
}

627 628 629
static void __kprobes
do_trap(int trapnr, int signr, char *str, struct pt_regs *regs,
	long error_code, siginfo_t *info)
L
Linus Torvalds 已提交
630
{
631 632
	struct task_struct *tsk = current;

633 634
	if (!user_mode(regs))
		goto kernel_trap;
L
Linus Torvalds 已提交
635

636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
	/*
	 * We want error_code and trap_no set for userspace faults and
	 * kernelspace faults which result in die(), but not
	 * kernelspace faults which are fixed up.  die() gives the
	 * process no chance to handle the signal and notice the
	 * kernel fault information, so that won't result in polluting
	 * the information about previously queued, but not yet
	 * delivered, faults.  See also do_general_protection below.
	 */
	tsk->thread.error_code = error_code;
	tsk->thread.trap_no = trapnr;

	if (show_unhandled_signals && unhandled_signal(tsk, signr) &&
	    printk_ratelimit()) {
		printk(KERN_INFO
		       "%s[%d] trap %s ip:%lx sp:%lx error:%lx",
		       tsk->comm, tsk->pid, str,
		       regs->ip, regs->sp, error_code);
		print_vma_addr(" in ", regs->ip);
		printk("\n");
L
Linus Torvalds 已提交
656 657
	}

658 659 660 661 662
	if (info)
		force_sig_info(signr, info, tsk);
	else
		force_sig(signr, tsk);
	return;
L
Linus Torvalds 已提交
663

664
kernel_trap:
665 666 667 668
	if (!fixup_exception(regs)) {
		tsk->thread.error_code = error_code;
		tsk->thread.trap_no = trapnr;
		die(str, regs, error_code);
L
Linus Torvalds 已提交
669
	}
670
	return;
L
Linus Torvalds 已提交
671 672 673
}

#define DO_ERROR(trapnr, signr, str, name) \
674 675 676 677 678
asmlinkage void do_##name(struct pt_regs * regs, long error_code)	\
{									\
	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr)	\
							== NOTIFY_STOP)	\
		return;							\
679
	conditional_sti(regs);						\
680
	do_trap(trapnr, signr, str, regs, error_code, NULL);		\
L
Linus Torvalds 已提交
681 682
}

683 684 685 686 687 688 689 690 691 692 693 694
#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 __user *)siaddr;				\
	trace_hardirqs_fixup();						\
	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr)	\
							== NOTIFY_STOP)	\
		return;							\
695
	conditional_sti(regs);						\
696
	do_trap(trapnr, signr, str, regs, error_code, &info);		\
L
Linus Torvalds 已提交
697 698
}

699 700 701 702 703
DO_ERROR_INFO(0, SIGFPE, "divide error", divide_error, FPE_INTDIV, regs->ip)
DO_ERROR(4, SIGSEGV, "overflow", overflow)
DO_ERROR(5, SIGSEGV, "bounds", bounds)
DO_ERROR_INFO(6, SIGILL, "invalid opcode", invalid_op, ILL_ILLOPN, regs->ip)
DO_ERROR(9, SIGFPE, "coprocessor segment overrun", coprocessor_segment_overrun)
L
Linus Torvalds 已提交
704
DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
705
DO_ERROR(11, SIGBUS, "segment not present", segment_not_present)
L
Linus Torvalds 已提交
706
DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0)
707 708 709 710 711 712 713 714 715 716 717

/* Runs on IST stack */
asmlinkage void do_stack_segment(struct pt_regs *regs, long error_code)
{
	if (notify_die(DIE_TRAP, "stack segment", regs, error_code,
			12, SIGBUS) == NOTIFY_STOP)
		return;
	preempt_conditional_sti(regs);
	do_trap(12, SIGBUS, "stack segment", regs, error_code, NULL);
	preempt_conditional_cli(regs);
}
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734

asmlinkage void do_double_fault(struct pt_regs * regs, long error_code)
{
	static const char str[] = "double fault";
	struct task_struct *tsk = current;

	/* Return not checked because double check cannot be ignored */
	notify_die(DIE_TRAP, str, regs, error_code, 8, SIGSEGV);

	tsk->thread.error_code = error_code;
	tsk->thread.trap_no = 8;

	/* This is always a kernel trap and never fixable (and thus must
	   never return). */
	for (;;)
		die(str, regs, error_code);
}
L
Linus Torvalds 已提交
735

736 737
asmlinkage void __kprobes
do_general_protection(struct pt_regs *regs, long error_code)
L
Linus Torvalds 已提交
738
{
739
	struct task_struct *tsk;
740

L
Linus Torvalds 已提交
741 742
	conditional_sti(regs);

743 744 745
	tsk = current;
	if (!user_mode(regs))
		goto gp_in_kernel;
L
Linus Torvalds 已提交
746

747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
	tsk->thread.error_code = error_code;
	tsk->thread.trap_no = 13;

	if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) &&
			printk_ratelimit()) {
		printk(KERN_INFO
			"%s[%d] general protection ip:%lx sp:%lx error:%lx",
			tsk->comm, tsk->pid,
			regs->ip, regs->sp, error_code);
		print_vma_addr(" in ", regs->ip);
		printk("\n");
	}

	force_sig(SIGSEGV, tsk);
	return;
L
Linus Torvalds 已提交
762

763
gp_in_kernel:
764 765
	if (fixup_exception(regs))
		return;
766

767 768 769 770 771 772
	tsk->thread.error_code = error_code;
	tsk->thread.trap_no = 13;
	if (notify_die(DIE_GPF, "general protection fault", regs,
				error_code, 13, SIGSEGV) == NOTIFY_STOP)
		return;
	die("general protection fault", regs, error_code);
L
Linus Torvalds 已提交
773 774
}

775
static notrace __kprobes void
776
mem_parity_error(unsigned char reason, struct pt_regs *regs)
L
Linus Torvalds 已提交
777
{
778 779
	printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
		reason);
780
	printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");
781

D
Dave Jiang 已提交
782
#if defined(CONFIG_EDAC)
783
	if (edac_handler_set()) {
D
Dave Jiang 已提交
784 785 786 787 788
		edac_atomic_assert_error();
		return;
	}
#endif

789
	if (panic_on_unrecovered_nmi)
790 791 792
		panic("NMI: Not continuing");

	printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
L
Linus Torvalds 已提交
793 794 795 796 797 798

	/* Clear and disable the memory parity error line. */
	reason = (reason & 0xf) | 4;
	outb(reason, 0x61);
}

799
static notrace __kprobes void
800
io_check_error(unsigned char reason, struct pt_regs *regs)
L
Linus Torvalds 已提交
801 802 803 804 805 806 807 808 809 810 811 812
{
	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);
	mdelay(2000);
	reason &= ~8;
	outb(reason, 0x61);
}

813
static notrace __kprobes void
814
unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
815
{
J
Jason Wessel 已提交
816 817
	if (notify_die(DIE_NMIUNKNOWN, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP)
		return;
818 819 820
	printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
		reason);
	printk(KERN_EMERG "Do you have a strange power saving mode enabled?\n");
821 822

	if (panic_on_unrecovered_nmi)
823
		panic("NMI: Not continuing");
824

825
	printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
L
Linus Torvalds 已提交
826 827
}

828 829
/* Runs on IST stack. This code must keep interrupts off all the time.
   Nested NMIs are prevented by the CPU. */
830
asmlinkage notrace  __kprobes void default_do_nmi(struct pt_regs *regs)
L
Linus Torvalds 已提交
831 832
{
	unsigned char reason = 0;
A
Ashok Raj 已提交
833 834 835
	int cpu;

	cpu = smp_processor_id();
L
Linus Torvalds 已提交
836

837
	/* Only the BSP gets external NMIs from the system. */
A
Ashok Raj 已提交
838
	if (!cpu)
L
Linus Torvalds 已提交
839 840 841
		reason = get_nmi_reason();

	if (!(reason & 0xc0)) {
842
		if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT)
L
Linus Torvalds 已提交
843 844 845 846 847 848
								== NOTIFY_STOP)
			return;
		/*
		 * Ok, so this is none of the documented NMI sources,
		 * so it must be the NMI watchdog.
		 */
849
		if (nmi_watchdog_tick(regs, reason))
L
Linus Torvalds 已提交
850
			return;
851
		if (!do_nmi_callback(regs, cpu))
852 853
			unknown_nmi_error(reason, regs);

L
Linus Torvalds 已提交
854 855
		return;
	}
856
	if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP)
857
		return;
L
Linus Torvalds 已提交
858 859 860 861 862 863 864 865

	/* AK: following checks seem to be broken on modern chipsets. FIXME */
	if (reason & 0x80)
		mem_parity_error(reason, regs);
	if (reason & 0x40)
		io_check_error(reason, regs);
}

866 867 868 869
asmlinkage notrace __kprobes void
do_nmi(struct pt_regs *regs, long error_code)
{
	nmi_enter();
870

871
	add_pda(__nmi_count, 1);
872

873 874
	if (!ignore_nmis)
		default_do_nmi(regs);
875

876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
	nmi_exit();
}

void stop_nmi(void)
{
	acpi_nmi_disable();
	ignore_nmis++;
}

void restart_nmi(void)
{
	ignore_nmis--;
	acpi_nmi_enable();
}

891
/* runs on IST stack. */
892
asmlinkage void __kprobes do_int3(struct pt_regs *regs, long error_code)
L
Linus Torvalds 已提交
893
{
P
Peter Zijlstra 已提交
894 895
	trace_hardirqs_fixup();

896 897
	if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP)
			== NOTIFY_STOP)
L
Linus Torvalds 已提交
898
		return;
899

900
	preempt_conditional_sti(regs);
L
Linus Torvalds 已提交
901
	do_trap(3, SIGTRAP, "int3", regs, error_code, NULL);
902
	preempt_conditional_cli(regs);
L
Linus Torvalds 已提交
903 904
}

905 906 907
/* Help handler running on IST stack to switch back to user stack
   for scheduling or signal handling. The actual stack switch is done in
   entry.S */
908
asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
909 910 911
{
	struct pt_regs *regs = eregs;
	/* Did already sync */
912
	if (eregs == (struct pt_regs *)eregs->sp)
913 914
		;
	/* Exception from user space */
915
	else if (user_mode(eregs))
A
Al Viro 已提交
916
		regs = task_pt_regs(current);
917 918
	/* Exception from kernel and interrupts are enabled. Move to
 	   kernel process stack. */
919 920
	else if (eregs->flags & X86_EFLAGS_IF)
		regs = (struct pt_regs *)(eregs->sp -= sizeof(struct pt_regs));
921 922 923 924 925
	if (eregs != regs)
		*regs = *eregs;
	return regs;
}

L
Linus Torvalds 已提交
926
/* runs on IST stack. */
927 928
asmlinkage void __kprobes do_debug(struct pt_regs * regs,
				   unsigned long error_code)
L
Linus Torvalds 已提交
929 930 931 932 933
{
	unsigned long condition;
	struct task_struct *tsk = current;
	siginfo_t info;

934 935
	trace_hardirqs_fixup();

936
	get_debugreg(condition, 6);
L
Linus Torvalds 已提交
937

938 939 940 941 942 943
	/*
	 * The processor cleared BTF, so don't mark that we need it set.
	 */
	clear_tsk_thread_flag(tsk, TIF_DEBUGCTLMSR);
	tsk->thread.debugctlmsr = 0;

L
Linus Torvalds 已提交
944
	if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
945
						SIGTRAP) == NOTIFY_STOP)
946
		return;
947

948
	preempt_conditional_sti(regs);
L
Linus Torvalds 已提交
949 950 951

	/* Mask out spurious debug traps due to lazy DR7 setting */
	if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
952
		if (!tsk->thread.debugreg7)
L
Linus Torvalds 已提交
953 954 955 956 957
			goto clear_dr7;
	}

	tsk->thread.debugreg6 = condition;

R
Roland McGrath 已提交
958 959 960 961
	/*
	 * Single-stepping through TF: make sure we ignore any events in
	 * kernel space (but re-enable TF when returning to user mode).
	 */
962
	if (condition & DR_STEP) {
963 964
		if (!user_mode(regs))
			goto clear_TF_reenable;
L
Linus Torvalds 已提交
965 966 967 968 969 970 971 972
	}

	/* 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;
973
	info.si_addr = user_mode(regs) ? (void __user *)regs->ip : NULL;
974
	force_sig_info(SIGTRAP, &info, tsk);
L
Linus Torvalds 已提交
975 976

clear_dr7:
977
	set_debugreg(0, 7);
978
	preempt_conditional_cli(regs);
979
	return;
L
Linus Torvalds 已提交
980 981 982

clear_TF_reenable:
	set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
983
	regs->flags &= ~X86_EFLAGS_TF;
984
	preempt_conditional_cli(regs);
985
	return;
L
Linus Torvalds 已提交
986 987
}

988
static int kernel_math_error(struct pt_regs *regs, const char *str, int trapnr)
L
Linus Torvalds 已提交
989
{
990
	if (fixup_exception(regs))
L
Linus Torvalds 已提交
991
		return 1;
992

993
	notify_die(DIE_GPF, str, regs, 0, trapnr, SIGFPE);
994
	/* Illegal floating point operation in the kernel */
995
	current->thread.trap_no = trapnr;
L
Linus Torvalds 已提交
996 997 998 999 1000 1001 1002 1003 1004 1005 1006
	die(str, regs, 0);
	return 0;
}

/*
 * 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
 */
asmlinkage void do_coprocessor_error(struct pt_regs *regs)
{
1007
	void __user *ip = (void __user *)(regs->ip);
1008
	struct task_struct *task;
L
Linus Torvalds 已提交
1009 1010 1011 1012
	siginfo_t info;
	unsigned short cwd, swd;

	conditional_sti(regs);
1013
	if (!user_mode(regs) &&
1014
	    kernel_math_error(regs, "kernel x87 math error", 16))
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
		return;

	/*
	 * 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;
1027
	info.si_addr = ip;
L
Linus Torvalds 已提交
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
	/*
	 * (~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 synchronizing 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);
1040
	switch (swd & ~cwd & 0x3f) {
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
	case 0x000: /* No unmasked exception */
	default: /* Multiple exceptions */
		break;
	case 0x001: /* Invalid Op */
		/*
		 * swd & 0x240 == 0x040: Stack Underflow
		 * swd & 0x240 == 0x240: Stack Overflow
		 * User must clear the SF bit (0x40) if set
		 */
		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;
L
Linus Torvalds 已提交
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
	}
	force_sig_info(SIGFPE, &info, task);
}

asmlinkage void bad_intr(void)
{
	printk("bad interrupt"); 
}

asmlinkage void do_simd_coprocessor_error(struct pt_regs *regs)
{
1076
	void __user *ip = (void __user *)(regs->ip);
1077
	struct task_struct *task;
L
Linus Torvalds 已提交
1078 1079 1080 1081
	siginfo_t info;
	unsigned short mxcsr;

	conditional_sti(regs);
1082
	if (!user_mode(regs) &&
1083
        	kernel_math_error(regs, "kernel simd math error", 19))
L
Linus Torvalds 已提交
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
		return;

	/*
	 * 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;
1096
	info.si_addr = ip;
L
Linus Torvalds 已提交
1097 1098 1099 1100 1101 1102 1103 1104
	/*
	 * 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)) {
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
	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;
L
Linus Torvalds 已提交
1124 1125 1126 1127 1128 1129 1130 1131 1132
	}
	force_sig_info(SIGFPE, &info, task);
}

asmlinkage void do_spurious_interrupt_bug(struct pt_regs * regs)
{
}

asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void)
1133 1134 1135 1136
{
}

asmlinkage void __attribute__((weak)) mce_threshold_interrupt(void)
L
Linus Torvalds 已提交
1137 1138 1139 1140
{
}

/*
1141
 * 'math_state_restore()' saves the current math information in the
L
Linus Torvalds 已提交
1142 1143 1144 1145 1146 1147 1148 1149 1150
 * 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.
 */
asmlinkage void math_state_restore(void)
{
	struct task_struct *me = current;

1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
	if (!used_math()) {
		local_irq_enable();
		/*
		 * does a slab alloc which can sleep
		 */
		if (init_fpu(me)) {
			/*
			 * ran out of memory!
			 */
			do_group_exit(SIGKILL);
			return;
		}
		local_irq_disable();
	}

1166
	clts();				/* Allow maths ops (or we recurse) */
1167
	restore_fpu_checking(&me->thread.xstate->fxsave);
A
Al Viro 已提交
1168
	task_thread_info(me)->status |= TS_USEDFPU;
1169
	me->fpu_counter++;
L
Linus Torvalds 已提交
1170
}
1171
EXPORT_SYMBOL_GPL(math_state_restore);
L
Linus Torvalds 已提交
1172 1173 1174

void __init trap_init(void)
{
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
	set_intr_gate(0, &divide_error);
	set_intr_gate_ist(1, &debug, DEBUG_STACK);
	set_intr_gate_ist(2, &nmi, NMI_STACK);
 	set_system_gate_ist(3, &int3, DEBUG_STACK); /* int3 can be called from all */
	set_system_gate(4, &overflow); /* int4 can be called from all */
	set_intr_gate(5, &bounds);
	set_intr_gate(6, &invalid_op);
	set_intr_gate(7, &device_not_available);
	set_intr_gate_ist(8, &double_fault, DOUBLEFAULT_STACK);
	set_intr_gate(9, &coprocessor_segment_overrun);
	set_intr_gate(10, &invalid_TSS);
	set_intr_gate(11, &segment_not_present);
	set_intr_gate_ist(12, &stack_segment, STACKFAULT_STACK);
	set_intr_gate(13, &general_protection);
	set_intr_gate(14, &page_fault);
	set_intr_gate(15, &spurious_interrupt_bug);
	set_intr_gate(16, &coprocessor_error);
	set_intr_gate(17, &alignment_check);
L
Linus Torvalds 已提交
1193
#ifdef CONFIG_X86_MCE
1194
	set_intr_gate_ist(18, &machine_check, MCE_STACK);
L
Linus Torvalds 已提交
1195
#endif
1196
	set_intr_gate(19, &simd_coprocessor_error);
L
Linus Torvalds 已提交
1197 1198 1199 1200

#ifdef CONFIG_IA32_EMULATION
	set_system_gate(IA32_SYSCALL_VECTOR, ia32_syscall);
#endif
1201 1202 1203 1204
	/*
	 * initialize the per thread extended state:
	 */
        init_thread_xstate();
L
Linus Torvalds 已提交
1205
	/*
1206
	 * Should be a barrier for any external CPU state:
L
Linus Torvalds 已提交
1207 1208 1209 1210
	 */
	cpu_init();
}

1211
static int __init oops_setup(char *s)
1212
{
1213 1214 1215 1216 1217
	if (!s)
		return -EINVAL;
	if (!strcmp(s, "panic"))
		panic_on_oops = 1;
	return 0;
1218
}
1219
early_param("oops", oops_setup);
L
Linus Torvalds 已提交
1220 1221 1222

static int __init kstack_setup(char *s)
{
1223 1224
	if (!s)
		return -EINVAL;
1225
	kstack_depth_to_print = simple_strtoul(s, NULL, 0);
1226
	return 0;
L
Linus Torvalds 已提交
1227
}
1228
early_param("kstack", kstack_setup);
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238

static int __init code_bytes_setup(char *s)
{
	code_bytes = simple_strtoul(s, NULL, 0);
	if (code_bytes > 8192)
		code_bytes = 8192;

	return 1;
}
__setup("code_bytes=", code_bytes_setup);