/arch/x86_64/kernel/traps.c

https://bitbucket.org/evzijst/gittest · C · 948 lines · 733 code · 106 blank · 109 comment · 114 complexity · c2753cdd302fe2b646fab79f63e99196 MD5 · raw file 

    

  1. /*
    2. 

  2.  *  linux/arch/x86-64/traps.c
    3. 

  3.  *
    4. 

  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
    5. 

  5.  *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
    6. 

  6.  *
    7. 

  7.  *  Pentium III FXSR, SSE support
    8. 

  8.  *	Gareth Hughes <gareth@valinux.com>, May 2000
    9. 

  9.  *
    10. 

  10.  *  $Id: traps.c,v 1.36 2002/03/24 11:09:10 ak Exp $
    11. 

  11.  */
    12. 

  12. 

  13. /*
    14. 

  14.  * 'Traps.c' handles hardware traps and faults after we have saved some
    15. 

  15.  * state in 'entry.S'.
    16. 

  16.  */
    17. 

  17. #include <linux/config.h>
    18. 

  18. #include <linux/sched.h>
    19. 

  19. #include <linux/kernel.h>
    20. 

  20. #include <linux/string.h>
    21. 

  21. #include <linux/errno.h>
    22. 

  22. #include <linux/ptrace.h>
    23. 

  23. #include <linux/timer.h>
    24. 

  24. #include <linux/mm.h>
    25. 

  25. #include <linux/init.h>
    26. 

  26. #include <linux/delay.h>
    27. 

  27. #include <linux/spinlock.h>
    28. 

  28. #include <linux/interrupt.h>
    29. 

  29. #include <linux/module.h>
    30. 

  30. #include <linux/moduleparam.h>
    31. 

  31. 

  32. #include <asm/system.h>
    33. 

  33. #include <asm/uaccess.h>
    34. 

  34. #include <asm/io.h>
    35. 

  35. #include <asm/atomic.h>
    36. 

  36. #include <asm/debugreg.h>
    37. 

  37. #include <asm/desc.h>
    38. 

  38. #include <asm/i387.h>
    39. 

  39. #include <asm/kdebug.h>
    40. 

  40. #include <asm/processor.h>
    41. 

  41. 

  42. #include <asm/smp.h>
    43. 

  43. #include <asm/pgalloc.h>
    44. 

  44. #include <asm/pda.h>
    45. 

  45. #include <asm/proto.h>
    46. 

  46. #include <asm/nmi.h>
    47. 

  47. 

  48. #include <linux/irq.h>
    49. 

  49. 

  50. 

  51. extern struct gate_struct idt_table[256]; 
    52. 

  52. 

  53. asmlinkage void divide_error(void);
    54. 

  54. asmlinkage void debug(void);
    55. 

  55. asmlinkage void nmi(void);
    56. 

  56. asmlinkage void int3(void);
    57. 

  57. asmlinkage void overflow(void);
    58. 

  58. asmlinkage void bounds(void);
    59. 

  59. asmlinkage void invalid_op(void);
    60. 

  60. asmlinkage void device_not_available(void);
    61. 

  61. asmlinkage void double_fault(void);
    62. 

  62. asmlinkage void coprocessor_segment_overrun(void);
    63. 

  63. asmlinkage void invalid_TSS(void);
    64. 

  64. asmlinkage void segment_not_present(void);
    65. 

  65. asmlinkage void stack_segment(void);
    66. 

  66. asmlinkage void general_protection(void);
    67. 

  67. asmlinkage void page_fault(void);
    68. 

  68. asmlinkage void coprocessor_error(void);
    69. 

  69. asmlinkage void simd_coprocessor_error(void);
    70. 

  70. asmlinkage void reserved(void);
    71. 

  71. asmlinkage void alignment_check(void);
    72. 

  72. asmlinkage void machine_check(void);
    73. 

  73. asmlinkage void spurious_interrupt_bug(void);
    74. 

  74. asmlinkage void call_debug(void);
    75. 

  75. 

  76. struct notifier_block *die_chain;
    77. 

  77. static DEFINE_SPINLOCK(die_notifier_lock);
    78. 

  78. 

  79. int register_die_notifier(struct notifier_block *nb)
    80. 

  80. {
    81. 

  81. 	int err = 0;
    82. 

  82. 	unsigned long flags;
    83. 

  83. 	spin_lock_irqsave(&die_notifier_lock, flags);
    84. 

  84. 	err = notifier_chain_register(&die_chain, nb);
    85. 

  85. 	spin_unlock_irqrestore(&die_notifier_lock, flags);
    86. 

  86. 	return err;
    87. 

  87. }
    88. 

  88. 

  89. static inline void conditional_sti(struct pt_regs *regs)
    90. 

  90. {
    91. 

  91. 	if (regs->eflags & X86_EFLAGS_IF)
    92. 

  92. 		local_irq_enable();
    93. 

  93. }
    94. 

  94. 

  95. static int kstack_depth_to_print = 10;
    96. 

  96. 

  97. #ifdef CONFIG_KALLSYMS
    98. 

  98. #include <linux/kallsyms.h> 
    99. 

  99. int printk_address(unsigned long address)
    100. 

  100. { 
    101. 

  101. 	unsigned long offset = 0, symsize;
    102. 

  102. 	const char *symname;
    103. 

  103. 	char *modname;
    104. 

  104. 	char *delim = ":"; 
    105. 

  105. 	char namebuf[128];
    106. 

  106. 

  107. 	symname = kallsyms_lookup(address, &symsize, &offset, &modname, namebuf); 
    108. 

  108. 	if (!symname) 
    109. 

  109. 		return printk("[<%016lx>]", address);
    110. 

  110. 	if (!modname) 
    111. 

  111. 		modname = delim = ""; 		
    112. 

  112.         return printk("<%016lx>{%s%s%s%s%+ld}",
    113. 

  113. 		      address,delim,modname,delim,symname,offset); 
    114. 

  114. } 
    115. 

  115. #else
    116. 

  116. int printk_address(unsigned long address)
    117. 

  117. { 
    118. 

  118. 	return printk("[<%016lx>]", address);
    119. 

  119. } 
    120. 

  120. #endif
    121. 

  121. 

  122. unsigned long *in_exception_stack(int cpu, unsigned long stack) 
    123. 

  123. { 
    124. 

  124. 	int k;
    125. 

  125. 	for (k = 0; k < N_EXCEPTION_STACKS; k++) {
    126. 

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

  127. 		unsigned long start = tss->ist[k] - EXCEPTION_STKSZ;
    128. 

  128. 

  129. 		if (stack >= start && stack < tss->ist[k])
    130. 

  130. 			return (unsigned long *)tss->ist[k];
    131. 

  131. 	}
    132. 

  132. 	return NULL;
    133. 

  133. } 
    134. 

  134. 

  135. /*
    136. 

  136.  * x86-64 can have upto three kernel stacks: 
    137. 

  137.  * process stack
    138. 

  138.  * interrupt stack
    139. 

  139.  * severe exception (double fault, nmi, stack fault) hardware stack
    140. 

  140.  * Check and process them in order.
    141. 

  141.  */
    142. 

  142. 

  143. void show_trace(unsigned long *stack)
    144. 

  144. {
    145. 

  145. 	unsigned long addr;
    146. 

  146. 	unsigned long *irqstack, *irqstack_end, *estack_end;
    147. 

  147. 	const int cpu = safe_smp_processor_id();
    148. 

  148. 	int i;
    149. 

  149. 

  150. 	printk("\nCall Trace:");
    151. 

  151. 	i = 0; 
    152. 

  152. 	
    153. 

  153. 	estack_end = in_exception_stack(cpu, (unsigned long)stack); 
    154. 

  154. 	if (estack_end) { 
    155. 

  155. 		while (stack < estack_end) { 
    156. 

  156. 			addr = *stack++; 
    157. 

  157. 			if (__kernel_text_address(addr)) {
    158. 

  158. 				i += printk_address(addr);
    159. 

  159. 				i += printk(" "); 
    160. 

  160. 				if (i > 50) {
    161. 

  161. 					printk("\n"); 
    162. 

  162. 					i = 0;
    163. 

  163. 				}
    164. 

  164. 			}
    165. 

  165. 		}
    166. 

  166. 		i += printk(" <EOE> "); 
    167. 

  167. 		i += 7;
    168. 

  168. 		stack = (unsigned long *) estack_end[-2]; 
    169. 

  169. 	}  
    170. 

  170. 

  171. 	irqstack_end = (unsigned long *) (cpu_pda[cpu].irqstackptr);
    172. 

  172. 	irqstack = (unsigned long *) (cpu_pda[cpu].irqstackptr - IRQSTACKSIZE + 64);
    173. 

  173. 

  174. 	if (stack >= irqstack && stack < irqstack_end) {
    175. 

  175. 		printk("<IRQ> ");  
    176. 

  176. 		while (stack < irqstack_end) {
    177. 

  177. 			addr = *stack++;
    178. 

  178. 			/*
    179. 

  179. 			 * If the address is either in the text segment of the
    180. 

  180. 			 * kernel, or in the region which contains vmalloc'ed
    181. 

  181. 			 * memory, it *may* be the address of a calling
    182. 

  182. 			 * routine; if so, print it so that someone tracing
    183. 

  183. 			 * down the cause of the crash will be able to figure
    184. 

  184. 			 * out the call path that was taken.
    185. 

  185. 			 */
    186. 

  186. 			 if (__kernel_text_address(addr)) {
    187. 

  187. 				 i += printk_address(addr);
    188. 

  188. 				 i += printk(" "); 
    189. 

  189. 				 if (i > 50) { 
    190. 

  190. 					printk("\n       ");
    191. 

  191. 					 i = 0;
    192. 

  192. 				 } 
    193. 

  193. 			}
    194. 

  194. 		} 
    195. 

  195. 		stack = (unsigned long *) (irqstack_end[-1]);
    196. 

  196. 		printk(" <EOI> ");
    197. 

  197. 		i += 7;
    198. 

  198. 	} 
    199. 

  199. 

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

  201. 		addr = *stack++;
    202. 

  202. 		if (__kernel_text_address(addr)) {
    203. 

  203. 			i += printk_address(addr);
    204. 

  204. 			i += printk(" "); 
    205. 

  205. 			if (i > 50) { 
    206. 

  206. 				printk("\n       ");
    207. 

  207. 					 i = 0;
    208. 

  208. 			} 
    209. 

  209. 		}
    210. 

  210. 	}
    211. 

  211. 	printk("\n");
    212. 

  212. }
    213. 

  213. 

  214. void show_stack(struct task_struct *tsk, unsigned long * rsp)
    215. 

  215. {
    216. 

  216. 	unsigned long *stack;
    217. 

  217. 	int i;
    218. 

  218. 	const int cpu = safe_smp_processor_id();
    219. 

  219. 	unsigned long *irqstack_end = (unsigned long *) (cpu_pda[cpu].irqstackptr);
    220. 

  220. 	unsigned long *irqstack = (unsigned long *) (cpu_pda[cpu].irqstackptr - IRQSTACKSIZE);    
    221. 

  221. 

  222. 	// debugging aid: "show_stack(NULL, NULL);" prints the
    223. 

  223. 	// back trace for this cpu.
    224. 

  224. 

  225. 	if (rsp == NULL) {
    226. 

  226. 		if (tsk)
    227. 

  227. 			rsp = (unsigned long *)tsk->thread.rsp;
    228. 

  228. 		else
    229. 

  229. 			rsp = (unsigned long *)&rsp;
    230. 

  230. 	}
    231. 

  231. 

  232. 	stack = rsp;
    233. 

  233. 	for(i=0; i < kstack_depth_to_print; i++) {
    234. 

  234. 		if (stack >= irqstack && stack <= irqstack_end) {
    235. 

  235. 			if (stack == irqstack_end) {
    236. 

  236. 				stack = (unsigned long *) (irqstack_end[-1]);
    237. 

  237. 				printk(" <EOI> ");
    238. 

  238. 			}
    239. 

  239. 		} else {
    240. 

  240. 		if (((long) stack & (THREAD_SIZE-1)) == 0)
    241. 

  241. 			break;
    242. 

  242. 		}
    243. 

  243. 		if (i && ((i % 4) == 0))
    244. 

  244. 			printk("\n       ");
    245. 

  245. 		printk("%016lx ", *stack++);
    246. 

  246. 	}
    247. 

  247. 	show_trace((unsigned long *)rsp);
    248. 

  248. }
    249. 

  249. 

  250. /*
    251. 

  251.  * The architecture-independent dump_stack generator
    252. 

  252.  */
    253. 

  253. void dump_stack(void)
    254. 

  254. {
    255. 

  255. 	unsigned long dummy;
    256. 

  256. 	show_trace(&dummy);
    257. 

  257. }
    258. 

  258. 

  259. EXPORT_SYMBOL(dump_stack);
    260. 

  260. 

  261. void show_registers(struct pt_regs *regs)
    262. 

  262. {
    263. 

  263. 	int i;
    264. 

  264. 	int in_kernel = (regs->cs & 3) == 0;
    265. 

  265. 	unsigned long rsp;
    266. 

  266. 	const int cpu = safe_smp_processor_id(); 
    267. 

  267. 	struct task_struct *cur = cpu_pda[cpu].pcurrent; 
    268. 

  268. 

  269. 		rsp = regs->rsp;
    270. 

  270. 

  271. 	printk("CPU %d ", cpu);
    272. 

  272. 	__show_regs(regs);
    273. 

  273. 	printk("Process %s (pid: %d, threadinfo %p, task %p)\n",
    274. 

  274. 		cur->comm, cur->pid, cur->thread_info, cur);
    275. 

  275. 

  276. 	/*
    277. 

  277. 	 * When in-kernel, we also print out the stack and code at the
    278. 

  278. 	 * time of the fault..
    279. 

  279. 	 */
    280. 

  280. 	if (in_kernel) {
    281. 

  281. 

  282. 		printk("Stack: ");
    283. 

  283. 		show_stack(NULL, (unsigned long*)rsp);
    284. 

  284. 

  285. 		printk("\nCode: ");
    286. 

  286. 		if(regs->rip < PAGE_OFFSET)
    287. 

  287. 			goto bad;
    288. 

  288. 

  289. 		for(i=0;i<20;i++)
    290. 

  290. 		{
    291. 

  291. 			unsigned char c;
    292. 

  292. 			if(__get_user(c, &((unsigned char*)regs->rip)[i])) {
    293. 

  293. bad:
    294. 

  294. 				printk(" Bad RIP value.");
    295. 

  295. 				break;
    296. 

  296. 			}
    297. 

  297. 			printk("%02x ", c);
    298. 

  298. 		}
    299. 

  299. 	}
    300. 

  300. 	printk("\n");
    301. 

  301. }	
    302. 

  302. 

  303. void handle_BUG(struct pt_regs *regs)
    304. 

  304. { 
    305. 

  305. 	struct bug_frame f;
    306. 

  306. 	char tmp;
    307. 

  307. 

  308. 	if (regs->cs & 3)
    309. 

  309. 		return; 
    310. 

  310. 	if (__copy_from_user(&f, (struct bug_frame *) regs->rip, 
    311. 

  311. 			     sizeof(struct bug_frame)))
    312. 

  312. 		return; 
    313. 

  313. 	if ((unsigned long)f.filename < __PAGE_OFFSET || 
    314. 

  314. 	    f.ud2[0] != 0x0f || f.ud2[1] != 0x0b) 
    315. 

  315. 		return;
    316. 

  316. 	if (__get_user(tmp, f.filename))
    317. 

  317. 		f.filename = "unmapped filename"; 
    318. 

  318. 	printk("----------- [cut here ] --------- [please bite here ] ---------\n");
    319. 

  319. 	printk(KERN_ALERT "Kernel BUG at %.50s:%d\n", f.filename, f.line);
    320. 

  320. } 
    321. 

  321. 

  322. void out_of_line_bug(void)
    323. 

  323. { 
    324. 

  324. 	BUG(); 
    325. 

  325. } 
    326. 

  326. 

  327. static DEFINE_SPINLOCK(die_lock);
    328. 

  328. static int die_owner = -1;
    329. 

  329. 

  330. void oops_begin(void)
    331. 

  331. {
    332. 

  332. 	int cpu = safe_smp_processor_id(); 
    333. 

  333. 	/* racy, but better than risking deadlock. */ 
    334. 

  334. 	local_irq_disable();
    335. 

  335. 	if (!spin_trylock(&die_lock)) { 
    336. 

  336. 		if (cpu == die_owner) 
    337. 

  337. 			/* nested oops. should stop eventually */;
    338. 

  338. 		else
    339. 

  339. 			spin_lock(&die_lock); 
    340. 

  340. 	}
    341. 

  341. 	die_owner = cpu; 
    342. 

  342. 	console_verbose();
    343. 

  343. 	bust_spinlocks(1); 
    344. 

  344. }
    345. 

  345. 

  346. void oops_end(void)
    347. 

  347. { 
    348. 

  348. 	die_owner = -1;
    349. 

  349. 	bust_spinlocks(0); 
    350. 

  350. 	spin_unlock(&die_lock); 
    351. 

  351. 	if (panic_on_oops)
    352. 

  352. 		panic("Oops"); 
    353. 

  353. } 
    354. 

  354. 

  355. void __die(const char * str, struct pt_regs * regs, long err)
    356. 

  356. {
    357. 

  357. 	static int die_counter;
    358. 

  358. 	printk(KERN_EMERG "%s: %04lx [%u] ", str, err & 0xffff,++die_counter);
    359. 

  359. #ifdef CONFIG_PREEMPT
    360. 

  360. 	printk("PREEMPT ");
    361. 

  361. #endif
    362. 

  362. #ifdef CONFIG_SMP
    363. 

  363. 	printk("SMP ");
    364. 

  364. #endif
    365. 

  365. #ifdef CONFIG_DEBUG_PAGEALLOC
    366. 

  366. 	printk("DEBUG_PAGEALLOC");
    367. 

  367. #endif
    368. 

  368. 	printk("\n");
    369. 

  369. 	notify_die(DIE_OOPS, (char *)str, regs, err, 255, SIGSEGV);
    370. 

  370. 	show_registers(regs);
    371. 

  371. 	/* Executive summary in case the oops scrolled away */
    372. 

  372. 	printk(KERN_ALERT "RIP ");
    373. 

  373. 	printk_address(regs->rip); 
    374. 

  374. 	printk(" RSP <%016lx>\n", regs->rsp); 
    375. 

  375. }
    376. 

  376. 

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

  378. {
    379. 

  379. 	oops_begin();
    380. 

  380. 	handle_BUG(regs);
    381. 

  381. 	__die(str, regs, err);
    382. 

  382. 	oops_end();
    383. 

  383. 	do_exit(SIGSEGV); 
    384. 

  384. }
    385. 

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

  386. {
    387. 

  387. 	if (!(regs->eflags & VM_MASK) && (regs->cs == __KERNEL_CS))
    388. 

  388. 		die(str, regs, err);
    389. 

  389. }
    390. 

  390. 

  391. void die_nmi(char *str, struct pt_regs *regs)
    392. 

  392. {
    393. 

  393. 	oops_begin();
    394. 

  394. 	/*
    395. 

  395. 	 * We are in trouble anyway, lets at least try
    396. 

  396. 	 * to get a message out.
    397. 

  397. 	 */
    398. 

  398. 	printk(str, safe_smp_processor_id());
    399. 

  399. 	show_registers(regs);
    400. 

  400. 	if (panic_on_timeout || panic_on_oops)
    401. 

  401. 		panic("nmi watchdog");
    402. 

  402. 	printk("console shuts up ...\n");
    403. 

  403. 	oops_end();
    404. 

  404. 	do_exit(SIGSEGV);
    405. 

  405. }
    406. 

  406. 

  407. static void do_trap(int trapnr, int signr, char *str, 
    408. 

  408. 			   struct pt_regs * regs, long error_code, siginfo_t *info)
    409. 

  409. {
    410. 

  410. 	conditional_sti(regs);
    411. 

  411. 

  412. #ifdef CONFIG_CHECKING
    413. 

  413.        { 
    414. 

  414.                unsigned long gs; 
    415. 

  415.                struct x8664_pda *pda = cpu_pda + safe_smp_processor_id(); 
    416. 

  416.                rdmsrl(MSR_GS_BASE, gs); 
    417. 

  417.                if (gs != (unsigned long)pda) { 
    418. 

  418.                        wrmsrl(MSR_GS_BASE, pda); 
    419. 

  419.                        printk("%s: wrong gs %lx expected %p rip %lx\n", str, gs, pda,
    420. 

  420. 			      regs->rip);
    421. 

  421.                }
    422. 

  422.        }
    423. 

  423. #endif
    424. 

  424. 

  425. 	if ((regs->cs & 3)  != 0) { 
    426. 

  426. 		struct task_struct *tsk = current;
    427. 

  427. 

  428. 		if (exception_trace && unhandled_signal(tsk, signr))
    429. 

  429. 			printk(KERN_INFO
    430. 

  430. 			       "%s[%d] trap %s rip:%lx rsp:%lx error:%lx\n",
    431. 

  431. 			       tsk->comm, tsk->pid, str,
    432. 

  432. 			       regs->rip,regs->rsp,error_code); 
    433. 

  433. 

  434. 		tsk->thread.error_code = error_code;
    435. 

  435. 		tsk->thread.trap_no = trapnr;
    436. 

  436. 		if (info)
    437. 

  437. 			force_sig_info(signr, info, tsk);
    438. 

  438. 		else
    439. 

  439. 			force_sig(signr, tsk);
    440. 

  440. 		return;
    441. 

  441. 	}
    442. 

  442. 

  443. 

  444. 	/* kernel trap */ 
    445. 

  445. 	{	     
    446. 

  446. 		const struct exception_table_entry *fixup;
    447. 

  447. 		fixup = search_exception_tables(regs->rip);
    448. 

  448. 		if (fixup) {
    449. 

  449. 			regs->rip = fixup->fixup;
    450. 

  450. 		} else	
    451. 

  451. 			die(str, regs, error_code);
    452. 

  452. 		return;
    453. 

  453. 	}
    454. 

  454. }
    455. 

  455. 

  456. #define DO_ERROR(trapnr, signr, str, name) \
    457. 

  457. asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
    458. 

  458. { \
    459. 

  459. 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
    460. 

  460. 							== NOTIFY_STOP) \
    461. 

  461. 		return; \
    462. 

  462. 	do_trap(trapnr, signr, str, regs, error_code, NULL); \
    463. 

  463. }
    464. 

  464. 

  465. #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
    466. 

  466. asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
    467. 

  467. { \
    468. 

  468. 	siginfo_t info; \
    469. 

  469. 	info.si_signo = signr; \
    470. 

  470. 	info.si_errno = 0; \
    471. 

  471. 	info.si_code = sicode; \
    472. 

  472. 	info.si_addr = (void __user *)siaddr; \
    473. 

  473. 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
    474. 

  474. 							== NOTIFY_STOP) \
    475. 

  475. 		return; \
    476. 

  476. 	do_trap(trapnr, signr, str, regs, error_code, &info); \
    477. 

  477. }
    478. 

  478. 

  479. DO_ERROR_INFO( 0, SIGFPE,  "divide error", divide_error, FPE_INTDIV, regs->rip)
    480. 

  480. DO_ERROR( 4, SIGSEGV, "overflow", overflow)
    481. 

  481. DO_ERROR( 5, SIGSEGV, "bounds", bounds)
    482. 

  482. DO_ERROR_INFO( 6, SIGILL,  "invalid operand", invalid_op, ILL_ILLOPN, regs->rip)
    483. 

  483. DO_ERROR( 7, SIGSEGV, "device not available", device_not_available)
    484. 

  484. DO_ERROR( 9, SIGFPE,  "coprocessor segment overrun", coprocessor_segment_overrun)
    485. 

  485. DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
    486. 

  486. DO_ERROR(11, SIGBUS,  "segment not present", segment_not_present)
    487. 

  487. DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0)
    488. 

  488. DO_ERROR(18, SIGSEGV, "reserved", reserved)
    489. 

  489. 

  490. #define DO_ERROR_STACK(trapnr, signr, str, name) \
    491. 

  491. asmlinkage void *do_##name(struct pt_regs * regs, long error_code) \
    492. 

  492. { \
    493. 

  493. 	struct pt_regs *pr = ((struct pt_regs *)(current->thread.rsp0))-1; \
    494. 

  494. 	if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
    495. 

  495. 							== NOTIFY_STOP) \
    496. 

  496. 		return regs; \
    497. 

  497. 	if (regs->cs & 3) { \
    498. 

  498. 		memcpy(pr, regs, sizeof(struct pt_regs)); \
    499. 

  499. 		regs = pr; \
    500. 

  500. 	} \
    501. 

  501. 	do_trap(trapnr, signr, str, regs, error_code, NULL); \
    502. 

  502. 	return regs;		\
    503. 

  503. }
    504. 

  504. 

  505. DO_ERROR_STACK(12, SIGBUS,  "stack segment", stack_segment)
    506. 

  506. DO_ERROR_STACK( 8, SIGSEGV, "double fault", double_fault)
    507. 

  507. 

  508. asmlinkage void do_general_protection(struct pt_regs * regs, long error_code)
    509. 

  509. {
    510. 

  510. 	conditional_sti(regs);
    511. 

  511. 

  512. #ifdef CONFIG_CHECKING
    513. 

  513.        { 
    514. 

  514.                unsigned long gs; 
    515. 

  515.                struct x8664_pda *pda = cpu_pda + safe_smp_processor_id(); 
    516. 

  516.                rdmsrl(MSR_GS_BASE, gs); 
    517. 

  517.                if (gs != (unsigned long)pda) { 
    518. 

  518.                        wrmsrl(MSR_GS_BASE, pda); 
    519. 

  519. 		       oops_in_progress++;
    520. 

  520.                        printk("general protection handler: wrong gs %lx expected %p\n", gs, pda);
    521. 

  521. 		       oops_in_progress--;
    522. 

  522.                }
    523. 

  523.        }
    524. 

  524. #endif
    525. 

  525. 

  526. 	if ((regs->cs & 3)!=0) { 
    527. 

  527. 		struct task_struct *tsk = current;
    528. 

  528. 

  529. 		if (exception_trace && unhandled_signal(tsk, SIGSEGV))
    530. 

  530. 			printk(KERN_INFO
    531. 

  531. 		       "%s[%d] general protection rip:%lx rsp:%lx error:%lx\n",
    532. 

  532. 			       tsk->comm, tsk->pid,
    533. 

  533. 			       regs->rip,regs->rsp,error_code); 
    534. 

  534. 

  535. 		tsk->thread.error_code = error_code;
    536. 

  536. 		tsk->thread.trap_no = 13;
    537. 

  537. 		force_sig(SIGSEGV, tsk);
    538. 

  538. 		return;
    539. 

  539. 	} 
    540. 

  540. 

  541. 	/* kernel gp */
    542. 

  542. 	{
    543. 

  543. 		const struct exception_table_entry *fixup;
    544. 

  544. 		fixup = search_exception_tables(regs->rip);
    545. 

  545. 		if (fixup) {
    546. 

  546. 			regs->rip = fixup->fixup;
    547. 

  547. 			return;
    548. 

  548. 		}
    549. 

  549. 		if (notify_die(DIE_GPF, "general protection fault", regs,
    550. 

  550. 					error_code, 13, SIGSEGV) == NOTIFY_STOP)
    551. 

  551. 			return;
    552. 

  552. 		die("general protection fault", regs, error_code);
    553. 

  553. 	}
    554. 

  554. }
    555. 

  555. 

  556. static void mem_parity_error(unsigned char reason, struct pt_regs * regs)
    557. 

  557. {
    558. 

  558. 	printk("Uhhuh. NMI received. Dazed and confused, but trying to continue\n");
    559. 

  559. 	printk("You probably have a hardware problem with your RAM chips\n");
    560. 

  560. 

  561. 	/* Clear and disable the memory parity error line. */
    562. 

  562. 	reason = (reason & 0xf) | 4;
    563. 

  563. 	outb(reason, 0x61);
    564. 

  564. }
    565. 

  565. 

  566. static void io_check_error(unsigned char reason, struct pt_regs * regs)
    567. 

  567. {
    568. 

  568. 	printk("NMI: IOCK error (debug interrupt?)\n");
    569. 

  569. 	show_registers(regs);
    570. 

  570. 

  571. 	/* Re-enable the IOCK line, wait for a few seconds */
    572. 

  572. 	reason = (reason & 0xf) | 8;
    573. 

  573. 	outb(reason, 0x61);
    574. 

  574. 	mdelay(2000);
    575. 

  575. 	reason &= ~8;
    576. 

  576. 	outb(reason, 0x61);
    577. 

  577. }
    578. 

  578. 

  579. static void unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
    580. 

  580. {	printk("Uhhuh. NMI received for unknown reason %02x.\n", reason);
    581. 

  581. 	printk("Dazed and confused, but trying to continue\n");
    582. 

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

  583. }
    584. 

  584. 

  585. asmlinkage void default_do_nmi(struct pt_regs *regs)
    586. 

  586. {
    587. 

  587. 	unsigned char reason = 0;
    588. 

  588. 

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

  590. 	if (!smp_processor_id())
    591. 

  591. 		reason = get_nmi_reason();
    592. 

  592. 

  593. 	if (!(reason & 0xc0)) {
    594. 

  594. 		if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 0, SIGINT)
    595. 

  595. 								== NOTIFY_STOP)
    596. 

  596. 			return;
    597. 

  597. #ifdef CONFIG_X86_LOCAL_APIC
    598. 

  598. 		/*
    599. 

  599. 		 * Ok, so this is none of the documented NMI sources,
    600. 

  600. 		 * so it must be the NMI watchdog.
    601. 

  601. 		 */
    602. 

  602. 		if (nmi_watchdog > 0) {
    603. 

  603. 			nmi_watchdog_tick(regs,reason);
    604. 

  604. 			return;
    605. 

  605. 		}
    606. 

  606. #endif
    607. 

  607. 		unknown_nmi_error(reason, regs);
    608. 

  608. 		return;
    609. 

  609. 	}
    610. 

  610. 	if (notify_die(DIE_NMI, "nmi", regs, reason, 0, SIGINT) == NOTIFY_STOP)
    611. 

  611. 		return; 
    612. 

  612. 

  613. 	/* AK: following checks seem to be broken on modern chipsets. FIXME */
    614. 

  614. 

  615. 	if (reason & 0x80)
    616. 

  616. 		mem_parity_error(reason, regs);
    617. 

  617. 	if (reason & 0x40)
    618. 

  618. 		io_check_error(reason, regs);
    619. 

  619. }
    620. 

  620. 

  621. asmlinkage void do_int3(struct pt_regs * regs, long error_code)
    622. 

  622. {
    623. 

  623. 	if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) == NOTIFY_STOP) {
    624. 

  624. 		return;
    625. 

  625. 	}
    626. 

  626. 	do_trap(3, SIGTRAP, "int3", regs, error_code, NULL);
    627. 

  627. 	return;
    628. 

  628. }
    629. 

  629. 

  630. /* runs on IST stack. */
    631. 

  631. asmlinkage void *do_debug(struct pt_regs * regs, unsigned long error_code)
    632. 

  632. {
    633. 

  633. 	struct pt_regs *pr;
    634. 

  634. 	unsigned long condition;
    635. 

  635. 	struct task_struct *tsk = current;
    636. 

  636. 	siginfo_t info;
    637. 

  637. 

  638. 	pr = (struct pt_regs *)(current->thread.rsp0)-1;
    639. 

  639. 	if (regs->cs & 3) {
    640. 

  640. 		memcpy(pr, regs, sizeof(struct pt_regs));
    641. 

  641. 		regs = pr;
    642. 

  642. 	}	
    643. 

  643. 

  644. #ifdef CONFIG_CHECKING
    645. 

  645.        { 
    646. 

  646. 	       /* RED-PEN interaction with debugger - could destroy gs */
    647. 

  647.                unsigned long gs; 
    648. 

  648.                struct x8664_pda *pda = cpu_pda + safe_smp_processor_id(); 
    649. 

  649.                rdmsrl(MSR_GS_BASE, gs); 
    650. 

  650.                if (gs != (unsigned long)pda) { 
    651. 

  651.                        wrmsrl(MSR_GS_BASE, pda); 
    652. 

  652.                        printk("debug handler: wrong gs %lx expected %p\n", gs, pda);
    653. 

  653.                }
    654. 

  654.        }
    655. 

  655. #endif
    656. 

  656. 

  657. 	asm("movq %%db6,%0" : "=r" (condition));
    658. 

  658. 

  659. 	if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
    660. 

  660. 						SIGTRAP) == NOTIFY_STOP) {
    661. 

  661. 		return regs;
    662. 

  662. 	}
    663. 

  663. 	conditional_sti(regs);
    664. 

  664. 

  665. 	/* Mask out spurious debug traps due to lazy DR7 setting */
    666. 

  666. 	if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
    667. 

  667. 		if (!tsk->thread.debugreg7) { 
    668. 

  668. 			goto clear_dr7;
    669. 

  669. 		}
    670. 

  670. 	}
    671. 

  671. 

  672. 	tsk->thread.debugreg6 = condition;
    673. 

  673. 

  674. 	/* Mask out spurious TF errors due to lazy TF clearing */
    675. 

  675. 	if ((condition & DR_STEP) &&
    676. 

  676. 	    (notify_die(DIE_DEBUGSTEP, "debugstep", regs, condition,
    677. 

  677. 			1, SIGTRAP) != NOTIFY_STOP)) {
    678. 

  678. 		/*
    679. 

  679. 		 * The TF error should be masked out only if the current
    680. 

  680. 		 * process is not traced and if the TRAP flag has been set
    681. 

  681. 		 * previously by a tracing process (condition detected by
    682. 

  682. 		 * the PT_DTRACE flag); remember that the i386 TRAP flag
    683. 

  683. 		 * can be modified by the process itself in user mode,
    684. 

  684. 		 * allowing programs to debug themselves without the ptrace()
    685. 

  685. 		 * interface.
    686. 

  686. 		 */
    687. 

  687.                 if ((regs->cs & 3) == 0)
    688. 

  688.                        goto clear_TF_reenable;
    689. 

  689. 		if ((tsk->ptrace & (PT_DTRACE|PT_PTRACED)) == PT_DTRACE)
    690. 

  690. 			goto clear_TF;
    691. 

  691. 	}
    692. 

  692. 

  693. 	/* Ok, finally something we can handle */
    694. 

  694. 	tsk->thread.trap_no = 1;
    695. 

  695. 	tsk->thread.error_code = error_code;
    696. 

  696. 	info.si_signo = SIGTRAP;
    697. 

  697. 	info.si_errno = 0;
    698. 

  698. 	info.si_code = TRAP_BRKPT;
    699. 

  699. 	if ((regs->cs & 3) == 0) 
    700. 

  700. 		goto clear_dr7; 
    701. 

  701. 

  702. 	info.si_addr = (void __user *)regs->rip;
    703. 

  703. 	force_sig_info(SIGTRAP, &info, tsk);	
    704. 

  704. clear_dr7:
    705. 

  705. 	asm volatile("movq %0,%%db7"::"r"(0UL));
    706. 

  706. 	notify_die(DIE_DEBUG, "debug", regs, condition, 1, SIGTRAP);
    707. 

  707. 	return regs;
    708. 

  708. 

  709. clear_TF_reenable:
    710. 

  710. 	set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
    711. 

  711. 

  712. clear_TF:
    713. 

  713. 	/* RED-PEN could cause spurious errors */
    714. 

  714. 	if (notify_die(DIE_DEBUG, "debug2", regs, condition, 1, SIGTRAP) 
    715. 

  715. 								!= NOTIFY_STOP)
    716. 

  716. 	regs->eflags &= ~TF_MASK;
    717. 

  717. 	return regs;	
    718. 

  718. }
    719. 

  719. 

  720. static int kernel_math_error(struct pt_regs *regs, char *str)
    721. 

  721. {
    722. 

  722. 	const struct exception_table_entry *fixup;
    723. 

  723. 	fixup = search_exception_tables(regs->rip);
    724. 

  724. 	if (fixup) {
    725. 

  725. 		regs->rip = fixup->fixup;
    726. 

  726. 		return 1;
    727. 

  727. 	}
    728. 

  728. 	notify_die(DIE_GPF, str, regs, 0, 16, SIGFPE);
    729. 

  729. #if 0
    730. 

  730. 	/* This should be a die, but warn only for now */
    731. 

  731. 	die(str, regs, 0);
    732. 

  732. #else
    733. 

  733. 	printk(KERN_DEBUG "%s: %s at ", current->comm, str);
    734. 

  734. 	printk_address(regs->rip);
    735. 

  735. 	printk("\n");
    736. 

  736. #endif
    737. 

  737. 	return 0;
    738. 

  738. }
    739. 

  739. 

  740. /*
    741. 

  741.  * Note that we play around with the 'TS' bit in an attempt to get
    742. 

  742.  * the correct behaviour even in the presence of the asynchronous
    743. 

  743.  * IRQ13 behaviour
    744. 

  744.  */
    745. 

  745. asmlinkage void do_coprocessor_error(struct pt_regs *regs)
    746. 

  746. {
    747. 

  747. 	void __user *rip = (void __user *)(regs->rip);
    748. 

  748. 	struct task_struct * task;
    749. 

  749. 	siginfo_t info;
    750. 

  750. 	unsigned short cwd, swd;
    751. 

  751. 

  752. 	conditional_sti(regs);
    753. 

  753. 	if ((regs->cs & 3) == 0 &&
    754. 

  754. 	    kernel_math_error(regs, "kernel x87 math error"))
    755. 

  755. 		return;
    756. 

  756. 

  757. 	/*
    758. 

  758. 	 * Save the info for the exception handler and clear the error.
    759. 

  759. 	 */
    760. 

  760. 	task = current;
    761. 

  761. 	save_init_fpu(task);
    762. 

  762. 	task->thread.trap_no = 16;
    763. 

  763. 	task->thread.error_code = 0;
    764. 

  764. 	info.si_signo = SIGFPE;
    765. 

  765. 	info.si_errno = 0;
    766. 

  766. 	info.si_code = __SI_FAULT;
    767. 

  767. 	info.si_addr = rip;
    768. 

  768. 	/*
    769. 

  769. 	 * (~cwd & swd) will mask out exceptions that are not set to unmasked
    770. 

  770. 	 * status.  0x3f is the exception bits in these regs, 0x200 is the
    771. 

  771. 	 * C1 reg you need in case of a stack fault, 0x040 is the stack
    772. 

  772. 	 * fault bit.  We should only be taking one exception at a time,
    773. 

  773. 	 * so if this combination doesn't produce any single exception,
    774. 

  774. 	 * then we have a bad program that isn't synchronizing its FPU usage
    775. 

  775. 	 * and it will suffer the consequences since we won't be able to
    776. 

  776. 	 * fully reproduce the context of the exception
    777. 

  777. 	 */
    778. 

  778. 	cwd = get_fpu_cwd(task);
    779. 

  779. 	swd = get_fpu_swd(task);
    780. 

  780. 	switch (((~cwd) & swd & 0x3f) | (swd & 0x240)) {
    781. 

  781. 		case 0x000:
    782. 

  782. 		default:
    783. 

  783. 			break;
    784. 

  784. 		case 0x001: /* Invalid Op */
    785. 

  785. 		case 0x041: /* Stack Fault */
    786. 

  786. 		case 0x241: /* Stack Fault | Direction */
    787. 

  787. 			info.si_code = FPE_FLTINV;
    788. 

  788. 			break;
    789. 

  789. 		case 0x002: /* Denormalize */
    790. 

  790. 		case 0x010: /* Underflow */
    791. 

  791. 			info.si_code = FPE_FLTUND;
    792. 

  792. 			break;
    793. 

  793. 		case 0x004: /* Zero Divide */
    794. 

  794. 			info.si_code = FPE_FLTDIV;
    795. 

  795. 			break;
    796. 

  796. 		case 0x008: /* Overflow */
    797. 

  797. 			info.si_code = FPE_FLTOVF;
    798. 

  798. 			break;
    799. 

  799. 		case 0x020: /* Precision */
    800. 

  800. 			info.si_code = FPE_FLTRES;
    801. 

  801. 			break;
    802. 

  802. 	}
    803. 

  803. 	force_sig_info(SIGFPE, &info, task);
    804. 

  804. }
    805. 

  805. 

  806. asmlinkage void bad_intr(void)
    807. 

  807. {
    808. 

  808. 	printk("bad interrupt"); 
    809. 

  809. }
    810. 

  810. 

  811. asmlinkage void do_simd_coprocessor_error(struct pt_regs *regs)
    812. 

  812. {
    813. 

  813. 	void __user *rip = (void __user *)(regs->rip);
    814. 

  814. 	struct task_struct * task;
    815. 

  815. 	siginfo_t info;
    816. 

  816. 	unsigned short mxcsr;
    817. 

  817. 

  818. 	conditional_sti(regs);
    819. 

  819. 	if ((regs->cs & 3) == 0 &&
    820. 

  820.         	kernel_math_error(regs, "simd math error"))
    821. 

  821. 		return;
    822. 

  822. 

  823. 	/*
    824. 

  824. 	 * Save the info for the exception handler and clear the error.
    825. 

  825. 	 */
    826. 

  826. 	task = current;
    827. 

  827. 	save_init_fpu(task);
    828. 

  828. 	task->thread.trap_no = 19;
    829. 

  829. 	task->thread.error_code = 0;
    830. 

  830. 	info.si_signo = SIGFPE;
    831. 

  831. 	info.si_errno = 0;
    832. 

  832. 	info.si_code = __SI_FAULT;
    833. 

  833. 	info.si_addr = rip;
    834. 

  834. 	/*
    835. 

  835. 	 * The SIMD FPU exceptions are handled a little differently, as there
    836. 

  836. 	 * is only a single status/control register.  Thus, to determine which
    837. 

  837. 	 * unmasked exception was caught we must mask the exception mask bits
    838. 

  838. 	 * at 0x1f80, and then use these to mask the exception bits at 0x3f.
    839. 

  839. 	 */
    840. 

  840. 	mxcsr = get_fpu_mxcsr(task);
    841. 

  841. 	switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) {
    842. 

  842. 		case 0x000:
    843. 

  843. 		default:
    844. 

  844. 			break;
    845. 

  845. 		case 0x001: /* Invalid Op */
    846. 

  846. 			info.si_code = FPE_FLTINV;
    847. 

  847. 			break;
    848. 

  848. 		case 0x002: /* Denormalize */
    849. 

  849. 		case 0x010: /* Underflow */
    850. 

  850. 			info.si_code = FPE_FLTUND;
    851. 

  851. 			break;
    852. 

  852. 		case 0x004: /* Zero Divide */
    853. 

  853. 			info.si_code = FPE_FLTDIV;
    854. 

  854. 			break;
    855. 

  855. 		case 0x008: /* Overflow */
    856. 

  856. 			info.si_code = FPE_FLTOVF;
    857. 

  857. 			break;
    858. 

  858. 		case 0x020: /* Precision */
    859. 

  859. 			info.si_code = FPE_FLTRES;
    860. 

  860. 			break;
    861. 

  861. 	}
    862. 

  862. 	force_sig_info(SIGFPE, &info, task);
    863. 

  863. }
    864. 

  864. 

  865. asmlinkage void do_spurious_interrupt_bug(struct pt_regs * regs)
    866. 

  866. {
    867. 

  867. }
    868. 

  868. 

  869. asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void)
    870. 

  870. {
    871. 

  871. }
    872. 

  872. 

  873. /*
    874. 

  874.  *  'math_state_restore()' saves the current math information in the
    875. 

  875.  * old math state array, and gets the new ones from the current task
    876. 

  876.  *
    877. 

  877.  * Careful.. There are problems with IBM-designed IRQ13 behaviour.
    878. 

  878.  * Don't touch unless you *really* know how it works.
    879. 

  879.  */
    880. 

  880. asmlinkage void math_state_restore(void)
    881. 

  881. {
    882. 

  882. 	struct task_struct *me = current;
    883. 

  883. 	clts();			/* Allow maths ops (or we recurse) */
    884. 

  884. 

  885. 	if (!used_math())
    886. 

  886. 		init_fpu(me);
    887. 

  887. 	restore_fpu_checking(&me->thread.i387.fxsave);
    888. 

  888. 	me->thread_info->status |= TS_USEDFPU;
    889. 

  889. }
    890. 

  890. 

  891. void do_call_debug(struct pt_regs *regs) 
    892. 

  892. { 
    893. 

  893. 	notify_die(DIE_CALL, "debug call", regs, 0, 255, SIGINT); 
    894. 

  894. }
    895. 

  895. 

  896. void __init trap_init(void)
    897. 

  897. {
    898. 

  898. 	set_intr_gate(0,&divide_error);
    899. 

  899. 	set_intr_gate_ist(1,&debug,DEBUG_STACK);
    900. 

  900. 	set_intr_gate_ist(2,&nmi,NMI_STACK);
    901. 

  901. 	set_system_gate(3,&int3);
    902. 

  902. 	set_system_gate(4,&overflow);	/* int4-5 can be called from all */
    903. 

  903. 	set_system_gate(5,&bounds);
    904. 

  904. 	set_intr_gate(6,&invalid_op);
    905. 

  905. 	set_intr_gate(7,&device_not_available);
    906. 

  906. 	set_intr_gate_ist(8,&double_fault, DOUBLEFAULT_STACK);
    907. 

  907. 	set_intr_gate(9,&coprocessor_segment_overrun);
    908. 

  908. 	set_intr_gate(10,&invalid_TSS);
    909. 

  909. 	set_intr_gate(11,&segment_not_present);
    910. 

  910. 	set_intr_gate_ist(12,&stack_segment,STACKFAULT_STACK);
    911. 

  911. 	set_intr_gate(13,&general_protection);
    912. 

  912. 	set_intr_gate(14,&page_fault);
    913. 

  913. 	set_intr_gate(15,&spurious_interrupt_bug);
    914. 

  914. 	set_intr_gate(16,&coprocessor_error);
    915. 

  915. 	set_intr_gate(17,&alignment_check);
    916. 

  916. #ifdef CONFIG_X86_MCE
    917. 

  917. 	set_intr_gate_ist(18,&machine_check, MCE_STACK); 
    918. 

  918. #endif
    919. 

  919. 	set_intr_gate(19,&simd_coprocessor_error);
    920. 

  920. 

  921. #ifdef CONFIG_IA32_EMULATION
    922. 

  922. 	set_system_gate(IA32_SYSCALL_VECTOR, ia32_syscall);
    923. 

  923. #endif
    924. 

  924.        
    925. 

  925. 	set_intr_gate(KDB_VECTOR, call_debug);
    926. 

  926.        
    927. 

  927. 	/*
    928. 

  928. 	 * Should be a barrier for any external CPU state.
    929. 

  929. 	 */
    930. 

  930. 	cpu_init();
    931. 

  931. }
    932. 

  932. 

  933. 

  934. /* Actual parsing is done early in setup.c. */
    935. 

  935. static int __init oops_dummy(char *s)
    936. 

  936. { 
    937. 

  937. 	panic_on_oops = 1;
    938. 

  938. 	return -1; 
    939. 

  939. } 
    940. 

  940. __setup("oops=", oops_dummy); 
    941. 

  941. 

  942. static int __init kstack_setup(char *s)
    943. 

  943. {
    944. 

  944. 	kstack_depth_to_print = simple_strtoul(s,NULL,0);
    945. 

  945. 	return 0;
    946. 

  946. }
    947. 

  947. __setup("kstack=", kstack_setup);
    948.